Prompt cache break-even: after how many reuses does a cached prefix cost less?

Key numbers

The charts

Hover or focus a row for its exact value, interval and sample. Each chart has a Table view.

Tables

Method

1. This study makes no new model call and has no raw file of its own. It calculates from two inputs. The first is the turn tokens that the caching study recorded in 6 Claude Code sessions (3 on Sonnet 5.5, 3 on Opus 5.5). The second is the list prices in the price sources.
2. A prefix of T tokens goes out in k + 1 requests. The first request writes it to the cache. The k later requests, the reuses, read it. Prices are USD per million tokens: input i, cache read r, cache write w.
3. No cache: (k + 1) × T × i. A 1-hour write: T × w + k × T × r, where w is the listed 1-hour write price (twice i for every Anthropic model in the price list). A 5-minute write: T × 1.25 × i + k × T × r.
4. The 1.25 is the multiplier that the caching study protocol states as Anthropic’s published figure. It is not in the price list. It is an assumption here. No 5-minute write occurred in the recorded sessions.
5. Break-even: the cached prefix costs less when k > (w − i) ÷ (i − r). The exact break-even is that fraction. The reuses needed is the smallest non-negative whole number above it. A negative fraction means the first request already costs less, with zero reuses.
6. A share f of the prefix can already be in the cache when the first request arrives. That request reads the share and writes the rest: T × (f × r + (1 − f) × w) + k × T × r.
7. In the recorded sessions, turn 1 read 1,463 tokens on its first request. The usage counters do not record read/write timing. That is f = 19% (8,778 of 46,978 tokens, 6 sessions). Its origin was not isolated. The dollar figures use f = 0, the whole prefix new, which is the stricter case. The break-even rows show both.
8. T is the rounded mean turn-1 input (uncached input + cache reads + cache writes) of a model’s recorded sessions. For Sonnet 5.5 it is 7,831 tokens (range 7,831 to 7,832, n = 3). For Opus 5.5 it is 7,828 tokens (the same in every session, n = 3). A session of N turns is N requests that send the prefix, so k = N − 1. The cost tables give 1,000 sessions of 1, 2, 3, 5, 10 and 20 turns.
9. Split case: 10 requests as one 10-turn session (one write, 9 reads) against 10 one-turn sessions (10 writes). Each recorded session ran in a fresh process and a new temporary working folder. Of 4 later sessions, 0 met the reuse proxy. The split case assumes a wholly new prefix with no shared reuse; the receipts do not test that exact case. The reuse proxy follows the caching study’s rule: turn 1 reads more than it writes.
10. Opus 5.5 price question: the price list gives a cache read of $0.2 per million (5% of the $4 input price). Another table of the product lists $0.4 (10%). This study did not check the vendor price. Every Opus 5.5 row and the second Opus line show both values.
11. Check against the recorded sessions, on the input side only (output excluded). The recorded 5-turn sessions saved 55.4% on Sonnet 5.5 (n = 3; session range 54.3% to 57.1%) and 59.2% on Opus 5.5 (n = 3; range 58.5% to 59.7%). These ranges are not confidence intervals. The formula gives 52.0% and 56.0% with a new prefix, and 59.1% and 63.3% with 19% already cached. The two formula cases bracket the recorded figure for both models. The recorded sessions also wrote the tokens that each turn added.
12. With output included, the recorded saving is 50.0% for Sonnet 5.5 (n = 3; session range 47.5% to 54.1%) and 53.1% for Opus 5.5 (n = 3; session range 51.4% to 54.3%). These are list-price calculations. The ranges are not confidence intervals.
13. Everything is a list-price calculation, not a bill. The sample behind T is n = 3 sessions per model.

Caveats

• The retained Claude protocol file was created at 14:43:55 UTC, after the first counted session at 14:35:39 UTC on 2026-10-06. Its declaration says 14:25 UTC, but file times do not verify that claim. Treat this as a retrospective protocol record.
• The source has 30 attempted Claude turns, 0 failed turns and 0 turns without token usage. Failed turns with usage remain in cost totals. Missing usage cannot be priced. No quality rate or cache-caused speed effect is claimed.
• 7 counted turns record a provider rate-limit warning status. The retained outcome log says there was no warning. The protocol calls for a stop on limit text in an error or warning. These receipts do not establish whether that text appeared; this discrepancy remains unresolved.
• One shared Mac and one synthetic ledger supplied these tokens. The ledger was shortened once after a two-call probe and before the counted sessions. All 30 counted answers passed, so this task set hits a quality ceiling. This calculation does not rank model quality or speed.
• A calculation, not a run and not a bill. The recorded calls used flat subscriptions. The prices are list prices dated 2026-09-21 (Anthropic) and 2026-10-03 (OpenAI); they can change.
• The formula prices the shared prefix only. A real turn also writes new tokens to the cache at the write price. In the recorded sessions that was 58 to 1,117 tokens per turn after turn 1. A real turn also produces output, which costs the same with or without the cache. The check against the recorded sessions shows the size of this effect.
• The formula assumes that every reuse arrives before the cache entry expires. An entry lasts 5 minutes or 1 hour, by write type. When the gap between requests is longer, the write repeats and the saving shrinks.
• The recorded sessions wrote 1-hour entries only (0 of 30 turns wrote a 5-minute entry). The 5-minute rows use an assumed 1.25 multiplier that this study did not test.
• Only 0 of 4 later sessions met the read-more-than-write proxy (95% Wilson 0% to 49%). They still read some cached tokens. This proxy does not establish cache provenance. Each recorded session ran in a fresh process and a new temporary working folder. The caching study protocol names that folder as one untested hypothesis for the miss, and this study did not test it. The split case assumes no shared reuse and a wholly new prefix. It does not price the partly cached recorded first turns. A script that keeps one working folder may read an earlier session’s cache: check your own receipts before you use the split case.
• The 19% already-cached share is not a constant. We recorded it on Sonnet 5.5 and Opus 5.5 sessions. For Haiku 4.5 and Fable 5.1 it is a what-if. The one Haiku 4.5 probe session (outside every cell) read 0 tokens from the cache on turn 1.
• The Opus 5.5 cache-read price is open: $0.2 or $0.4 per million. This study shows both. Resolve the price before you quote an Opus figure.
• The dollar figures depend on T: one synthetic ledger in one CLI version, 3 sessions per model. A different prefix changes the dollars. It does not change the break-even reuses, which depend on the price ratios only.
• The GPT rows follow the price list, which has no write surcharge. Another table of the product lists a write price of 1.25× input for both models. At that price they need 1 reuse (exact break-even 0.26 and 0.28), and a prefix used once costs 1.25 times as much. We did not check the vendor price. The Codex app-server reports no cache writes, and this study did not test reuse for GPT. The caching study measured Codex reads on a larger context.

Sources

• Cost with and without the prompt cache (calculation)

  Calculation · October 6, 2026

  Recorded tokens per turn × Anthropic list prices. With the cache: uncached input at the input price, cache reads at the cache-read price, 1-hour cache writes at twice the input price, 5-minute writes at 1.25 times (an assumption; none occurred). Without a cache: every input token at the input price. Output is priced the same in both. Not a bill.

  Raw data: caching-consistency/caching.json

• Caching sessions and repeated prompts (Claude Code and Codex CLI)

  Our recorded runs · October 6, 2026

  Part 1: 5-turn CLI sessions over a fixed synthetic ledger, with the cache counters each provider reports per turn. Part 2: three prompts with deterministic validators, 10 repetitions per model. Declared protocols, validator controls before inference, every attempt kept; answers are published as ordinal ids, never as text.

  Raw data: caching-consistency/caching.json, caching-consistency/consistency.json

• Anthropic list prices (Claude models)

  Vendor price list · September 21, 2026

  Prices as listed by the vendor on 2026-09-21 and recorded in the product price table. Cache reads at the listed rate, one-hour cache writes at twice the input price.

• OpenAI list prices

  Vendor price list · October 3, 2026

  Token prices as listed by the vendor on 2026-10-03.

Download the data

The study as JSON (with its sources), every chart point as CSV, or the whole public dataset. Free to reuse under CC BY 4.0: credit Agent and link the study.

Cite as: Agent public benchmarks, “Prompt cache break-even: after how many reuses does a cached prefix cost less?”, updated October 6, 2026, https://agent.sasid.ai/benchmarks/prompt-cache-break-even.

Models and comparisons in this study

• Claude Sonnet 5.5
• Claude Opus 5.5
• Claude Haiku 4.5
• Claude Fable 5.1

• Claude Sonnet 5.5 vs Claude Opus 5.5
• All comparisons

Write-ups on this study