Claude Prompt Caching in 2026: How to Cut Your API Bill by Up to 90%

Claude prompt caching lets you reuse large, unchanged chunks of a prompt — system instructions, long documents, codebase context — across multiple API calls at a fraction of the normal input token price. For teams running agentic coding tools, RAG pipelines, or chat apps with long system prompts, enabling it correctly can cut the input-token portion of a Claude API bill by 70-90%, without any change to model quality.

What Prompt Caching Actually Does

Every Claude API request re-sends the full context window: system prompt, tool definitions, retrieved documents, conversation history. Normally, Anthropic charges full input-token price for all of it, every single call — even if 95% of that content is byte-for-byte identical to the previous request.

Prompt caching changes the economics. When you mark a prefix of your prompt as cacheable, the API stores it server-side for a short TTL (5 minutes by default, extendable in some setups). On the next request within that window, if the cached prefix matches exactly, you pay a small caching-read rate instead of full price for that segment — commonly cited around one-tenth of standard input cost, while a fresh cache write costs somewhat more than a normal read (a one-time premium you recoup after 2+ reuses).

Where Caching Pays Off Most

The pattern is consistent: the bigger and more static your context, and the more requests you fire within the cache TTL, the more caching saves you. A one-off single question with a short prompt won't benefit much — a coding agent that re-sends the same 8,000-token system prompt on every tool call benefits enormously.

How to Structure Requests for Maximum Cache Hits

Three things matter for getting cache hits instead of silent full-price misses:

• Order matters. Put static content (system prompt, fixed instructions, shared documents) at the very start of the prompt, and put the variable, per-request content (the user's latest message) at the end. Caching works on exact-match prefixes — any change earlier in the prompt invalidates everything after it.
• Keep the TTL window alive. If your app has bursty traffic with long gaps, cache entries expire between calls and you pay the write premium every time. Batch related calls close together where possible.
• Watch your proxy/gateway. If you're calling Claude through a third-party API relay or unified-API service, ask whether it actually forwards cache-control markers and reports cache-read tokens separately in the response. Some cheap relays strip these fields or don't support caching at all — meaning you silently pay full price on every call even though your code is written to request caching.

A Minimal Example

In the Anthropic Messages API, you mark a cacheable block by adding a cache_control field to that content block. A typical coding-agent request looks like this:

{
  "model": "claude-sonnet-5",
  "system": [
    {
      "type": "text",
      "text": "<long system prompt + repo context, ~6000 tokens>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [
    {"role": "user", "content": "Fix the null check in auth.py"}
  ]
}

On the first call, that 6,000-token system block is written to cache at a small premium over the normal rate. On the next call within the TTL window — say, the agent's next tool-use turn — the same block is read from cache at a steep discount, and only the new user message and the model's own output are billed at full price. Over a long agent session with dozens of tool calls, this is where the bulk of the savings comes from: you're not paying full price to re-send the same repo context on every single turn.

The response usage object also reports cache_creation_input_tokens and cache_read_input_tokens separately from regular input_tokens, so you can verify caching is actually firing rather than assuming it from the bill alone. If those fields are always zero or missing when calling through a relay, that's a sign the relay isn't passing caching through.

Frequently Asked Questions

Does prompt caching reduce output quality?

No. Caching only affects billing and latency for the reused input segment — the model still processes the identical content and produces the same output it would have without caching.

How long does the Claude cache last?

The standard cache TTL is short (minutes, not hours), refreshed on each hit. If no request reuses the cached prefix before it expires, the next call pays the full write cost again.

Can I use prompt caching through a third-party API gateway?

Only if the gateway passes through Anthropic's cache-control headers and correctly bills cache-read vs. cache-write tokens. This varies a lot between relay services, so check pricing/cache docs before assuming it's supported.

This last point is worth double-checking before you commit to a provider, because it's an easy way to silently lose most of the savings caching is supposed to give you. Safa API is a unified relay in front of Claude, GPT, and Gemini that explicitly supports prompt caching pass-through, so coding agents and RAG apps get the same cache discounts they'd get calling Anthropic directly — on top of already lower per-token pricing. It also skips the credit-card requirement (Alipay works fine) and gives you one endpoint and one key for all three model families, so you're not juggling separate accounts just to compare costs.