A five-minute cache write costs 1.25x the input price, and one read pays it back. Prompt caching is the biggest discount I have found on the Claude API, and the easiest to get wrong. It saves up to 97.5% on repeated input, but only if the repeat happens before the cache expires. If it does not, caching costs you extra.
All prices below come from Anthropic’s pricing documentation, read on 09/28/2026.
How Claude prompt caching is priced
Caching splits your input into three kinds of token, each with its own price:
- Cache write: the first time a prompt prefix is sent with caching on, Claude stores it. You pay a premium on those tokens.
- Cache read: later requests that start with the same prefix read it from the cache. You pay a small fraction of the input price.
- Uncached input: anything after the cached prefix is billed at the normal input price.
Anthropic offers two cache lifetimes, and they price the write differently:
| Token type | Price, as a multiple of base input |
|---|---|
| Cache write, five-minute lifetime | 1.25x |
| Cache write, one-hour lifetime | 2x |
| Cache read, most models | 0.1x |
| Cache read, Opus 5.5 | 0.05x |
| Cache read, Fable 5.1 | 0.025x |
Output tokens are not affected. Caching only changes what you pay for input.
The prices per model
Per million tokens, from the same page:
| Model | Input | Cache write (5 min) | Cache write (1 hour) | Cache read |
|---|---|---|---|---|
| Fable 5.1 | $10 | $12.50 | $20 | $0.25 |
| Opus 5.5 | $4 | $5 | $8 | $0.20 |
| Opus 5 | $5 | $6.25 | $10 | $0.50 |
| Sonnet 5.5 and Sonnet 5 | $2 | $2.50 | $4 | $0.20 |
| Haiku 4.5 | $1 | $1.25 | $2 | $0.10 |
Look at the last column. Fable 5.1 lists at five times the input price of Sonnet 5.5, but reads its cache for only 25% more. Opus 5.5 reads its cache for the same $0.20 as Sonnet 5.5. For work that is mostly cache reads, the price gap between models is much smaller than the input prices suggest.
The break-even point
Anthropic’s pricing page states the rule. I checked the arithmetic, and it is short enough for you to check too.
Five-minute cache. The write costs 0.25x more than sending the prefix uncached. Each read saves 0.9x (you pay 0.1x instead of 1x). One read saves more than the write cost. Caching pays after one read.
One-hour cache. The write costs 1x more than uncached. Each read saves 0.9x. One read saves 0.9x, not enough. Two reads save 1.8x. Caching pays after two reads.
On Opus 5.5 and Fable 5.1 each read saves even more (0.95x and 0.975x), but the break-even count stays the same.
If a prefix is written and never read again before it expires, you paid 25% or 100% extra for nothing. That is the one way caching makes a bill bigger.
Worked example: a 50,000-token prefix, reused 10 times
Say every request I send starts with the same 50,000 tokens: a system prompt, tool definitions and a reference document. You send 10 requests inside the five-minute window. Only the prefix is priced here. The new text and the output in each request cost the same either way.
| Model | No caching (10 full sends) | Five-minute cache (1 write, 9 reads) | Saving |
|---|---|---|---|
| Haiku 4.5 | $0.50 | $0.1075 | 78.5% |
| Sonnet 5.5 | $1.00 | $0.215 | 78.5% |
| Opus 5.5 | $2.00 | $0.34 | 83% |
| Fable 5.1 | $5.00 | $0.7375 | 85% |
How the Sonnet 5.5 row works: uncached, each send is 50,000 tokens at $2 per million, or $0.10, and 10 sends cost $1.00. Cached, the first send is a write at $2.50 per million, or $0.125. The nine reads cost $0.20 per million, or $0.01 each, for $0.09. Total: $0.215.
The saving grows with reuse. At 100 requests the cached Sonnet 5.5 prefix costs $1.115 against $10.00 uncached, an 89% cut.
Where caching matters most: agents and Claude Code
An agent re-sends its whole context on every turn. Turn 200 of a Claude Code session carries everything from turns 1 to 199 as its prefix. Without caching, that prefix would be billed in full every turn.
I measured this on a real day. In Opus 5.5 vs Fable 5.1 I broke down 2,979 turns of my own Claude Code work. On Opus 5 prices, cache reads were the largest single line of the day: $170 of a $359 total. That is also why the Opus 5.5 cache-read cut mattered more than its 20% cheaper input price. The same day came to $220 at Opus 5.5 prices.
If you run Claude Code on a Pro or Max plan instead of the API, caching still matters. Long sessions use your limit faster, as I explain in Claude usage limits, and the habits that keep a prefix stable also keep a session cheap. Claude Code usage limits lists them.
Three ways to lose the discount
- Changing the prefix. A cache matches from the start of the prompt. Edit one line of the system prompt or reorder the tools and every later token is a new write. Put what changes at the end.
- Letting it expire. A gap longer than the cache lifetime means the next request writes again. If your requests are spread out, the one-hour cache is cheaper despite its 2x write.
- Caching something used once. A one-off prompt with caching on pays the write premium and never reads it back.
Caching does not change what you send. It changes what you pay to send it again.
Or send less. A shorter prefix costs less to write and less to read. Reduce Claude token usage with progressive disclosure covers that.
Other discounts that stack
- Batch API: 50% off input and output, and it combines with caching.
- Long context: on Claude 4.6 and later models, the full one-million-token context is billed at the standard price, so a large cached prefix does not trigger a long-context premium.
Price your own prefix
The Claude token counter estimates the tokens in any text you paste and prices them on every current Claude model. It also takes cache-read and cache-write token counts, with a five-minute or one-hour lifetime, and prices those at each model’s own multiplier. Paste your system prompt and tool definitions to see what a write and each read cost.
Cache multipliers differ by model: Opus 5.5 and Fable 5.1 both break the usual 0.1x rule. Claude Cost Watch is a waitlist for a short email that flags changes like that. Nothing is charged today.
Sources
All read on 09/28/2026.
- Cache multipliers, per-model prices, break-even rule, batch and long-context pricing: platform.claude.com/docs/en/about-claude/pricing
- Measured Claude Code day: Opus 5.5 vs Fable 5.1
- Full price list: Claude pricing
No link on this page is an affiliate link.