Prompt Caching Pricing Explained (2026): How Much Each Provider's Cache Actually Saves
We compare cache-read discounts and cache-write premiums across 520 priced models, then work through a 20k-token-prefix, 1,000-requests-a-day example to show monthly cost with and without caching, plus the break-even hit rate.
1. What prompt caching is, and what this data can tell us
Most production LLM traffic is repetitive. A support bot sends the same 5,000-token policy document with every question; a coding agent resends its system prompt, tool schemas and the whole conversation so far on every turn. Prompt caching lets the provider reuse the already-processed prefix of a prompt and bill those tokens at a reduced "cached input" rate instead of the full input rate. For prefix-heavy workloads this is usually the single largest lever on the bill, bigger than most model-swap decisions.
This article measures that lever with the site's own pricing database. Data as of 2026-10-05: of the 520
priced models in our catalog (excluding :batch variants and ~latest aliases; 67 of them
are free variants listed at $0), 286 list a cached-input price (63% of the 453 paid models) and 77 (17%) list a
separate cache-write price. Provider counts below are of paid models only. For each model we compute two
ratios: the cache-read discount (cached input ÷ input) and the cache-write
premium (cache write ÷ input).
One caveat shapes everything below: these are OpenRouter routing prices, which reflect the default endpoint OpenRouter currently routes to. Provider rules that decide whether you actually get a cache hit (how long an entry lives, the minimum prompt length that can be cached, whether you must mark cache breakpoints explicitly or the provider caches automatically) are not in the pricing payload, so we do not state them here. Check each provider's docs for those. What the payload does give us is the price of a cached read, the price of a write where one exists, and, for some models, long-prompt price tiers.
2. Cache-read discounts by provider
The headline: the median model in the catalog bills cached tokens at 12.5% of its input price, and 44% of models with a cached price sit at or below 10%. Exactly 109 of the 286 are priced at precisely one tenth of input. But the spread underneath is wide, and it is the spread that matters when you choose a model.
| Provider | Models with cached price | Median cached ÷ input | Range | Cache-write price listed |
|---|---|---|---|---|
| OpenAI | 56 of 77 | 10% | 5%–203%* | 14 models (GPT-5.6, GPT-6 families), 1.25× input |
| Anthropic | 24 of 24 | 10% | 2.5%–12% | All 24, 1.2–1.25× input |
| 23 of 31 | 10% | 10%–56% | 20 models, flat $0.04–$0.38/M (below input) | |
| Qwen (Alibaba) | 31 of 59 | 20% | 9%–70% | 19 models, mostly 1.25× input |
| Mistral AI | 19 of 26 | 10% | 10%–11% | None |
| Z.ai | 16 of 17 | 19% | 10%–100%* | None |
| xAI | 15 of 15 | 25% | 10%–25% | None |
| DeepSeek | 13 of 17 | 38%* | 2%–100%* | None |
| Xiaomi | 8 of 8 | 2% | 0.8%–20% | None |
| MiniMax | 6 of 8 | 10% | 10%–20% | None |
| Moonshot AI | 5 of 7 | 25% | 16%–33% | None |
| NVIDIA | 4 of 9 | 55% | 20%–75% | None |
* Includes rows where the cached price equals or exceeds input, which usually signals a mixed endpoint rather than a real absence of discount (examples: gpt-oss-120b at $0.037/M input but $0.075/M cached; DeepSeek V4 Flash at $0.03/M for both). Treat ratios of 100% or more as a data-quality flag and verify against the provider's own pricing page.
Three patterns stand out. First, the discount deepens with each generation. OpenAI's GPT-4o family, o1 and o3-mini bill cached input at 50% of input; GPT-4.1, o3 and o4-mini at 25%; the GPT-5 family at 10%; and GPT-6.1 Sol at 5% ($0.10/M against $2.00/M), half the cached price of GPT-6 Sol, which sits at $0.20/M. Anthropic shows the same drift: Claude Sonnet and Opus tiers are at 10%, but Claude Opus 5.5 is at 5% ($0.20/M on $4.00/M) and Claude Fable 5.1 at 2.5% ($0.25/M on $10.00/M, versus $1.00/M for Fable 5).
Second, the extremes belong to the cheap labs. Xiaomi's MiMo-V2.6 Pro lists cached input at $0.0036/M against $0.435/M input, a 99.2% discount. DeepSeek V4.1 Flash lists $0.006/M on $0.30/M (2%), and DeepSeek V3.2 a clean 10% ($0.028/M on $0.28/M). At the other end, NVIDIA and a few smaller hosts give only 20–75% off, so for them a cache hit saves a fraction of what it saves elsewhere.
Third, coverage is uneven. Only 4 of NVIDIA's 9 paid models and 5 of Moonshot's 7 list a cached price at all. If you are comparing a long-prefix workload across models, the model with no cached price (25 providers with paid models list none) is effectively billing every token at full rate.
A quick way to use the table: the effective price of the cacheable part of your prompt is h × r + (1 − h) × w, expressed as a share of the input price. At an 80% hit rate, a model with a 10% read price and no write premium bills that prefix at 28% of list (0.8 × 0.10 + 0.2 × 1.00). A 5% model gets to 24%. A model with a 10% read price but a 1.25× write price lands at 33% (0.8 × 0.10 + 0.2 × 1.25). A 50%-discount model, even at a perfect hit rate, never gets below half of list.
3. Who charges for cache writes
A cache read is only half the price structure. Some providers also charge more than the normal input rate the first time a prefix is stored. From the payload:
- Anthropic: yes, on every model. The write rate is 1.25× input on 23 of 24 models (Claude 3
Haiku is 1.2×). For example Claude Sonnet 4.6
is $3.00/M input, $3.75/M write, $0.30/M read. The payload also carries a second, separate
input_cache_write_1hprice on 21 of the 24 Anthropic models, uniformly 2× input ($6.00/M for Sonnet 4.6), implying the plain write rate belongs to a shorter-lived tier. The exact durations are not in the payload; check Anthropic's docs. - OpenAI: only on the newest families. 14 models list a write price at 1.25× input (GPT-5.6 Sol/Luna/Terra, the GPT-6 and GPT-6.1 families). GPT-5.4, GPT-5.5 and everything older list reads only, so a miss simply costs normal input.
- Qwen: on the Plus/Max/Flash tiers. 19 models list a write price, 1.25× input on most (for instance $0.40/M against $0.32/M input on Qwen3.7 Plus).
- Google: a figure, but not a premium. 20 Gemini rows list a
cache_writevalue, yet it is below the input price ($0.375/M on the Pro models, $0.0417/M on Gemini 3.6–3.8 Flash), and it is identical ($0.0833/M) across Flash models whose input prices differ 15-fold, from $0.10 to $1.50/M. A value that does not scale with input looks like a storage-style fee rather than a multiple of input. We do not treat it as a write premium below, and you should read Google's docs before budgeting for it. - Everyone else we checked (DeepSeek, Moonshot, Z.ai, MiniMax, xAI, Mistral, Xiaomi, and others): no write price. A cache miss costs the normal input rate; a hit is a pure discount.
The practical consequence is a risk asymmetry. With no write price, caching cannot lose money. With a 1.25× write price, a prefix that is written and never reused costs you 25% more than not caching at all.
4. Worked example: 20k-token prefix, 1,000 requests a day
Take an assistant with a 20,000-token prefix (system prompt plus tool definitions) that is identical across requests. Each request adds 500 new input tokens and returns 400 output tokens. Volume is 1,000 requests a day, 30,000 a month. Let P = 20,000 prefix tokens, n = 500, o = 400, and per-million prices p (input), r (cached read), w (write; use p when the model lists no write premium), q (output). With cache hit rate h on the prefix:
cost per request = ( P × [ h × r + (1 − h) × w ] + n × p + o × q ) ÷ 1,000,000
Without caching, set h = 0 and w = p. Prices come from the database as of 2026-10-05:
| Model | Input $/M | Cached read $/M | Write $/M | Output $/M |
|---|---|---|---|---|
| Claude Sonnet 4.6 | $3.00 | $0.30 | $3.75 | $15.00 |
| GPT-5.4 | $2.50 | $0.25 | none | $15.00 |
| GPT-6.1 Sol | $2.00 | $0.10 | $2.50 | $10.00 |
| Gemini 3.1 Pro Preview | $2.00 | $0.20 | n/a (see §3) | $12.00 |
| Kimi K2.6 | $0.95 | $0.16 | none | $4.00 |
| DeepSeek V3.2 | $0.28 | $0.028 | none | $0.42 |
Monthly cost for 30,000 requests, at three prefix hit rates:
| Model | No caching | h = 100% | h = 90% | h = 50% | Break-even h |
|---|---|---|---|---|---|
| Claude Sonnet 4.6 | $2,025 | $405 | $612 (−70%) | $1,440 (−29%) | 21.7% |
| GPT-5.4 | $1,718 | $368 | $503 (−71%) | $1,043 (−39%) | any |
| GPT-6.1 Sol | $1,350 | $210 | $354 (−74%) | $930 (−31%) | 20.8% |
| Gemini 3.1 Pro Preview | $1,374 | $294 | $402 (−71%) | $834 (−39%) | any |
| Kimi K2.6 | $632 | $158 | $206 (−67%) | $395 (−37%) | any |
| DeepSeek V3.2 | $177 | $26 | $41 (−77%) | $102 (−43%) | any |
Reading it: the prefix is 87–95% of the uncached bill on every model here, which is why the cached rate dominates the outcome and output price barely matters (output is only 3–11% of the uncached total). Check one row by hand: Sonnet 4.6 uncached is 20,500 × $3.00 ÷ 1M + 400 × $15.00 ÷ 1M = $0.0615 + $0.0060 = $0.0675 per request, × 30,000 = $2,025. At a 90% hit rate the prefix costs 20,000 × (0.9 × $0.30 + 0.1 × $3.75) ÷ 1M = $0.0129, and the total comes to $612. Note too that the absolute gap between models dwarfs the caching effect: cached DeepSeek V3.2 at $26 a month is about 1/15 of cached Sonnet 4.6, even before you ask whether the quality difference justifies it. For your own volumes, the cost calculator does the uncached side.
Break-even. A paid write costs w − p extra once and saves p − r on every subsequent read, so the number of reuses needed is:
reuses k > (w − p) ÷ (p − r) or, as a hit rate: h > (w − p) ÷ (w − r)
For Sonnet 4.6 that is (3.75 − 3.00) ÷ (3.00 − 0.30) = 0.28 reuses, so a single reuse already pays the write back, and the hit-rate form gives 21.7%. For GPT-6.1 Sol it is 0.26 reuses (20.8%). The 1-hour write tier is stricter: (6.00 − 3.00) ÷ 2.70 = 1.11, so Sonnet 4.6 needs two reuses inside the window. Where there is no write premium (w = p) the numerator is zero and any hit saves money. The catch is not the number of reuses; it is whether your traffic keeps the entry alive, and that depends on the provider's cache lifetime. At 1,000 evenly spread requests a day you send one about every 86 seconds, but real traffic is bursty.
5. When caching does not help
- Output-dominated calls. Caching discounts only input. Keep the 500 new tokens but shrink the prefix to 2,000 and raise output to 2,000 tokens on Sonnet 4.6: uncached is $0.0375 a request, fully cached $0.0321, a 14% saving instead of 80%.
- A prefix that is not actually stable. Caching works on a shared beginning of the prompt. A timestamp, user name or reordered tool list at the top of the prompt changes everything after it. Put static content first and per-request content last.
- Low or bursty traffic. If entries expire between requests, you pay writes repeatedly. On a 1.25× write model, hit rates under about 22% are worse than not caching.
- Prompts below the provider's minimum, or models with no cached price. Minimum cacheable lengths differ by provider and are not in the payload; check the docs. Of the catalog, 37% of paid models list no cached rate.
- Long-prompt price tiers. 55 models carry an override that applies above a prompt-length threshold. GPT-5.4 above 272,000 prompt tokens moves to $5.00 input, $0.50 cached and $22.50 output; Gemini 3.1 Pro above 200,000 moves to $4.00 / $0.40 / $18.00. The discount ratio holds, but the base moves.
- Suspect data. A 100% ratio on a mixed-endpoint model is usually a routing artifact, not a real offer.
6. Checklist before you rely on caching
- Measure your stable-prefix share: tokens identical from the start of the prompt, per request.
- Look up the model's three prices (input, cached read, write) and compute (w − p) ÷ (w − r).
- Read the provider's docs for cache lifetime, minimum length and whether caching is automatic or opt-in.
- Compare your request spacing with the cache lifetime to estimate a realistic hit rate, not 100%.
- Reorder the prompt so static content leads and variable content trails; keep tool lists stable.
- Log the cached-token counts your API returns and compare against the invoice for a week.
- Re-run the numbers at your long-prompt tail if any calls cross a price-tier threshold.
For the basics of per-token billing see the token pricing guide; for why the same model can price differently across platforms, see why LLM prices differ by platform.