Calculation · list prices of September 21, 2026 to October 3, 2026
Prompt caching calculator: when the cache pays off.
A cache write costs more than plain input. Each cache read costs less. This calculator finds the turn where the cache has paid for itself. Then it prices a day and a month with the cache and without it.
It is arithmetic on list prices, not a benchmark. We check the formula against sessions that we recorded.
New to prompt caching? See how the cache fills, turn by turn.
List-price calculation · Example input
Claude Sonnet 5.5
$85.20
saved each month with the cache
64% less than no cache · $48.00 with the cache, $133 without · 20 sessions a day, 10 turns each
$1.60 a day with the cache, $4.44 without.
Turn 1 costs $0.02 more than no cache. Each later turn saves $0.018. The cache has paid for itself by turn 3, after 2 reads.
The cache saves $85.20 a month (64%), a calculation. Break-even turn 3.
Monthly cost with the cache
- Uncached input
- $1.20
- Cache writes
- $24.00
- Cache reads
- $10.80
- Output
- $12.00
One session = 10,000 prefix × $4 write + 9 × 10,000 × $0.2 read + 10 × 100 new × $2 + 10 × 200 out × $10, ÷ 1M = $0.08
Month = 30 days × 20 sessions × $0.08 = $48.00
What the cache costs and saves
Two views of the same inputs: one session, turn by turn, and every model side by side.
Cost of one session, turn by turn
Claude Sonnet 5.5 · 10,000 tokens cached · running total in US dollars
Break-even: turn 3
| Turn | This turn, with the cache | This turn, no cache | Running total, with the cache | Running total, no cache | Cache has paid for itself |
|---|---|---|---|---|---|
| 1 | $0.042 | $0.022 | $0.042 | $0.022 | No |
| 2 | $0.0042 | $0.022 | $0.046 | $0.044 | No |
| 3 | $0.0042 | $0.022 | $0.051 | $0.067 | Yes |
| 4 | $0.0042 | $0.022 | $0.055 | $0.089 | Yes |
| 5 | $0.0042 | $0.022 | $0.059 | $0.11 | Yes |
| 6 | $0.0042 | $0.022 | $0.063 | $0.13 | Yes |
| 7 | $0.0042 | $0.022 | $0.067 | $0.16 | Yes |
| 8 | $0.0042 | $0.022 | $0.072 | $0.18 | Yes |
| 9 | $0.0042 | $0.022 | $0.076 | $0.2 | Yes |
| 10 | $0.0042 | $0.022 | $0.08 | $0.22 | Yes |
Calculation: tokens × list price, not a billCost axis starts at $0
Claude Sonnet 5.5: a session of 10 turns costs $0.08 with the cache and $0.22 without it. The running total with the cache is at or below the total without it from turn 3. A list-price calculation, not a bill.
Each line adds the cost of the turns so far. With the cache, turn 1 writes the prefix and later turns read it. Without it, every turn sends the whole prefix as plain input.
The same inputs on every model
Monthly cost with the cache · 20 sessions a day, 10 turns each · lowest first
Sorted by monthly cost, cheapest first. Pick a model to price it above.
- Gemini 3.x Flash (Google · break-even turn 1 · no cache $49.95 · prices of September 21, 2026): $13.50 per month
- Claude Haiku 4.5 (Anthropic · break-even turn 3 · no cache $66.60 · prices of September 21, 2026): $24.00 per month
- GPT-6.1 Sol (OpenAI · break-even turn 1 · no cache $133 · prices of October 3, 2026): $30.60 per month
- Claude Sonnet 5.5 (Anthropic · break-even turn 3 · no cache $133 · prices of September 21, 2026): $48.00 per month; selected
- Claude Opus 5.5 (Anthropic · break-even turn 3 · no cache $266 · prices of September 21, 2026): $85.20 per month
- Claude Opus 5 (Anthropic · break-even turn 3 · no cache $333 · prices of September 21, 2026): $120 per month
- Claude Fable 5.1 (Anthropic · break-even turn 3 · no cache $666 · prices of September 21, 2026): $200 per month
- Hollow bar: list-price calculation, not a bill
| Model | Vendor | Input $/M | Cache write $/M | Cache read $/M | Output $/M | Price date | Source | Break-even turn | Reads needed (exact) | Per month, with the cache | Per month, no cache |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Gemini 3.x Flash | $0.75 | $0.75 | $0.075 | $3.75 | September 21, 2026 | Google Gemini list prices | 1 | 0 | $13.50 | $49.95 | |
| Claude Haiku 4.5 | Anthropic | $1 | $2 | $0.1 | $5 | September 21, 2026 | Anthropic list prices (Claude models) | 3 | 1.111 | $24.00 | $66.60 |
| GPT-6.1 Sol | OpenAI | $2 | $2 | $0.1 | $10 | October 3, 2026 | OpenAI list prices | 1 | 0 | $30.60 | $133 |
| Claude Sonnet 5.5 | Anthropic | $2 | $4 | $0.2 | $10 | September 21, 2026 | Anthropic list prices (Claude models) | 3 | 1.111 | $48.00 | $133 |
| Claude Opus 5.5 | Anthropic | $4 | $8 | $0.2 | $20 | September 21, 2026 | Anthropic list prices (Claude models) | 3 | 1.053 | $85.20 | $266 |
| Claude Opus 5 | Anthropic | $5 | $10 | $0.5 | $25 | September 21, 2026 | Anthropic list prices (Claude models) | 3 | 1.111 | $120 | $333 |
| Claude Fable 5.1 | Anthropic | $10 | $20 | $0.25 | $50 | September 21, 2026 | Anthropic list prices (Claude models) | 3 | 1.026 | $200 | $666 |
Calculation: list prices on the dates shown, not a billBars start at $0
7 models priced with the same tokens. Lowest with the cache: Gemini 3.x Flash, $13.50 a month. Highest: Claude Fable 5.1, $200. Claude Haiku 4.5, Claude Sonnet 5.5, Claude Opus 5.5, Claude Opus 5 and Claude Fable 5.1 break even on turn 3. Gemini 3.x Flash and GPT-6.1 Sol break even on turn 1.
We price the same tokens on every model. A different model would use a different number of tokens for the same work. The break-even turn comes from the three prices alone.
Checked against measured sessions
We recorded Claude Code sessions of 5 turns over one fixed prompt. The caching study priced their tokens at list prices. The figure shows the mean of the sessions.
Recorded session: running cost with and without the cache
Claude Sonnet 5.5 · Claude Code · mean of 3 sessions · list-price calculation on recorded tokens
Break-even: turn 2
| Turn | Sessions | Input tokens | Read from cache | Written to cache | USD with the cache (calculation) | USD without (calculation) |
|---|---|---|---|---|---|---|
| 1 | 3 | 7831 | 1463 | 6366 | $0.026 | $0.016 |
| 2 | 3 | 7889 | 7829 | 58 | $0.0019 | $0.016 |
| 3 | 3 | 7970 | 7887 | 81 | $0.002 | $0.016 |
| 4 | 3 | 8032 | 7968 | 62 | $0.0096 | $0.024 |
| 5 | 3 | 8861 | 8030 | 829 | $0.0058 | $0.019 |
n = 3 sessions, mean per turnTokens are recorded; dollars are a calculation at list prices
Claude Sonnet 5.5 · Claude Code: over 5 turns the cache cost $0.045 and no cache $0.09 (mean of 3 sessions). The running total with the cache is at or below the total without it from turn 2. A list-price calculation on recorded tokens.
Each point is the mean over the sessions of the cost that the caching study calculated from recorded tokens at list prices. The figure draws no interval.
- The recorded session paid back on turn 2. For the same prices, the formula gives turn 3 for a new prefix.
- On turn 1, 1,463 of 7,831 input tokens were already in the cache: the CLI's own prefix. So turn 1 paid the write price on only 6,366 tokens. Each later turn read 7,829 tokens or more.
- The formula gives the recorded cost gap on all 5 turns. The largest difference is $0.0000014 (calculation).
Our CLI test saw 0 of 4 later sessions reuse it. A follow-up study changed the working folder and where the prompt sits. Read it for the result. Open the recorded study · Read the follow-up
More measured numbers
These numbers come from the public studies. We recorded the tokens. Dollar figures are calculations at list prices.
Calculation on recorded tokens
50%
List-price saving from the cache over 15 turns, Claude Sonnet 5.5 · Claude Code (calculation)
($0.1350 vs $0.2698)
Calculation on recorded tokens
53%
List-price saving from the cache over 15 turns, Claude Opus 5.5 · Claude Code (calculation)
($0.2551 vs $0.5442)
Measured
94.0%
Share of input served from cache
n = 33
Calculation on recorded tokens
$87.23
Recorded tokens at Sonnet 5.5 list price
n = 33
Calculation on recorded tokens
$343.33
Sonnet 5.5 without caching (calculation)
n = 33
Measured
93.0%
Cache-read share of recorded input (economics data)
n = 2362
Measured
0 of 4
Later sessions whose first turn read the ledger from an earlier session’s cache
n = 4
Over 33 SWE-bench Verified attempts, 94.0% of the input tokens were cache reads. At Sonnet 5.5 list prices those tokens cost $87.23. Without the cache they would cost $343.33, or 3.9 times as much (calculation).
How the numbers are made
- Turn 1 with the cache costs (write price − input price) × prefix more than no cache.
- Each later turn saves (input price − cache-read price) × prefix.
- The break-even turn is 1 plus (write − input) ÷ (input − cache read), rounded up to a whole number.
- New input and output cost the same with the cache and without it, so they do not change the break-even turn.
Claude Sonnet 5.5: ($4 − $2) ÷ ($2 − $0.2) = 1.11 reads, so the cache pays for itself on turn 3.
Assumptions
- This is a calculation, not a bill. Each number is tokens times a list price.
- The prefix is the same on every turn. Turn 1 writes it to the cache. Later turns read it.
- Each turn’s new input costs the plain input price. A real session also adds earlier questions and answers to the prefix. This model leaves that out. The recorded session above includes it.
- For Anthropic models, a cache write costs twice the input price. This is a 1-hour write, the rule of our studies. For other vendors, a write costs the input price.
- The caching study assumes a 5-minute write at 1.25 times the input price. No recorded turn used one, so the calculator does not offer it.
- The model has no batch discount, storage fee or minimum prefix size. A month is 30 days.
- The reuse switch assumes one cache write a day. A 1-hour write lasts one hour, so each session must start within an hour of the one before.
- Prices are vendor list prices of September 21, 2026 to October 3, 2026. Each price shows its own date in the model table. These are pinned study prices, not a current vendor quote.
Questions about prompt caching cost
How much does Anthropic prompt caching cost?
At list prices of September 21, 2026, Claude Sonnet 5.5 costs $2 per million input tokens. A cache read costs $0.2 per million. A 1-hour cache write costs $4 per million, twice the input price. These are the prices and the write rule that our studies use. Other Claude models, per million tokens. Claude Haiku 4.5: input $1, read $0.1, write $2. Claude Opus 5.5: input $4, read $0.2, write $8. Claude Opus 5: input $5, read $0.5, write $10. Claude Fable 5.1: input $10, read $0.25, write $20.
When does prompt caching pay off?
Claude Haiku 4.5, Claude Sonnet 5.5, Claude Opus 5.5, Claude Opus 5 and Claude Fable 5.1 break even on turn 3. Gemini 3.x Flash and GPT-6.1 Sol break even on turn 1. Turn 1 costs more because of the write. Each later turn costs less because of the read. This is a calculation from three prices. It does not depend on the size of the prefix. Where a write costs the same as plain input, the cache never costs more.
How much did the cache save in measured sessions?
In our 5-turn Claude Code sessions, the cache saved 50% ($0.1350 vs $0.2698) for Claude Sonnet 5.5 over 15 turns. It saved 53% ($0.2551 vs $0.5442) for Claude Opus 5.5. These are list-price calculations on recorded tokens. The cache paid for itself on turn 2.
Does a new session reuse the cache of an earlier session?
Our CLI test saw 0 of 4 later sessions reuse it. A follow-up study changed the working folder and where the prompt sits. Read it for the result. The reuse switch in the calculator is an assumption: one cache write a day.
What does this calculator leave out?
It leaves out the history that a real session adds to the prefix, the 5-minute write, batch discounts, storage fees and minimum prefix sizes. It uses a 30-day month. It prices the same tokens on every model, so it does not say which model does the work well.