Prompt caching is not one product with five price tags — it is three different products, and the cheapest one depends on how long you go between turns. OpenAI and Anthropic sell you a guarantee, charging a premium to write and holding the entry for a published window. Google rents you storage by the hour, with no write premium and no stated ceiling. xAI and DeepSeek charge nothing to write, nothing to store, and promise nothing at all.
So the decision is set by your idle gap, not your rate card. Under 30 minutes, nearly everything works and the discount is all that matters. In the 30-to-60-minute band, Anthropic wins on its free refresh. Past an hour, only OpenAI’s 12-hour tier holds at a bounded price. Past 12 hours, no cache survives anywhere — and buying the long tier there costs you double for nothing.
Three ways to sell retention
The asymmetry that matters: a write premium is a one-time charge that does not care how long your gap is, while storage is a recurring charge that scales linearly with it, and “free” buys no promise at all. That single structural difference is why Google is the cheapest cache for a chat session and the most expensive one for an overnight agent — and it is invisible on every rate card.
| OpenAI (GPT-5.6+) | Anthropic | Google (explicit) | xAI | DeepSeek | |
|---|---|---|---|---|---|
| Tiers | "30m" default, "12h" | 5 min default, "ttl": "1h" | Any ttl, default 1 hour | None | None |
| Write cost | 1.25x / 2.5x input | 1.25x / 2x input | None | None | None |
| Storage cost | None | None | $0.50–$4.50 / 1M / hour | None | None |
| Read cost | 0.1x input (0.05x on GPT-6.1 Sol and GPT-6.1 Terra) | 0.1x (0.05x Opus/Sonnet 5.5; 0.025x Fable/Mythos 5.1) | 0.1x (0.05x Argon) | 0.25x on Grok 4.7 | 0.02x |
| Read extends it? | To “at least 30 minutes after that read”; does not restart a 12-hour clock | ”Refreshed for no additional cost”, no stated cap | No — PATCH the TTL instead | n/a | n/a |
| Clock starts | At the write | At request start, not response end | At cache creation | n/a | n/a |
| Min cacheable prefix | 1,024 tokens | 512–4,096 by model | 4,096 (implicit, current models) | Not stated | Not stated |
| Writes per request | 4 | 4 breakpoints | n/a | n/a | n/a |
| Longest window | 12 hours | 1 hour | No stated maximum | Not stated | ”hours to a few days” |
| Can you pin it? | Yes | Yes | Not on Gemini 4 Argon+ | No | No |
Prices and terms verified 25 October 2026 against OpenAI’s prompt-caching guide and pricing, Anthropic’s prompt caching and pricing, Google’s context caching and pricing, xAI’s prompt caching and pricing, and DeepSeek’s KV cache guide. The same rates drive our API cost calculator and pricing tracker.
Two rows deserve attention before the arithmetic. xAI’s cache discount is the worst on the market — 75% off on Grok 4.7, against 90% to 98% everywhere else — and it is the only vendor that publishes no retention figure of any kind. And Anthropic’s read multiplier is no longer a flat 0.1x: it fell to 0.05x on Opus 5.5 and Sonnet 5.5 and to 0.025x on Fable 5.1 and Mythos 5.1, which we covered when Fable’s cache-read price was cut.
What it costs to hold a 50,000-token prefix
One resident 50,000-token prefix, re-read on every turn, priced on each vendor’s cheapest viable strategy for that gap. Prefix tokens only — output is excluded so the retention effect is not buried. Each figure is in the vendor’s own tokens; Anthropic meters roughly 1.49x more tokens for the same English text, which is a separate penalty priced in what a long prompt actually costs.
| Model | Chat: 10 turns, 2 min apart | Agent: 8 turns, 45 min apart | Cron: 6 turns, 2 h apart | Daily: 2 turns, 24 h apart |
|---|---|---|---|---|
| GPT-6 Luna | $0.01075 | $0.01600 | $0.01500 | $0.01250 |
| Claude Haiku 5.5 | $0.01075 | $0.01350 | $0.03750 | $0.01250 |
| GPT-6.1 Sol | $0.17000 | $0.28500 | $0.27500 | $0.50000 |
| GPT-6.1 Terra | $0.08500 | $0.14250 | $0.13750 | $0.25000 |
| Claude Sonnet 5.5 | $0.17000 | $0.23500 | $0.75000 | $0.25000 |
| Gemini 3.8 Flash | $0.07875 | $0.19500 | $0.22500 | $0.07500 |
| Gemini 3.1 Pro Preview | $0.25750 | $0.80000 | $0.60000 | $0.20000 |
| Grok 4.7 | $0.32500 | $0.27500 | $0.22500 | $0.12500 |
| DeepSeek Flash | $0.00885 | $0.00855 | $0.00825 | $0.00765 |
Read the rows, not the columns. The winner changes three times across four workloads. Haiku 5.5 and Luna tie on a chat session, Haiku takes the 45-minute agent, Luna takes the 2-hour cron job by 2.5x, and the two converge again on a daily job because neither cache survives the night. Sonnet 5.5 beats GPT-6.1 Sol at 45 minutes and loses to it by 2.7x at two hours — same two models, opposite answers, decided purely by the clock.
GPT-6.1 Terra, added to the table on 27 October 2026, is exactly half of GPT-6.1 Sol in every column — OpenAI halved input, cached input and both cache-write tiers by the same factor, so the whole row scales cleanly and the ranking against the Claude models flips. Sonnet 5.5 beats Sol at 45 minutes but loses to Terra at every gap in the table, and Terra at two hours ($0.1375) is now cheaper than Gemini 3.8 Flash ($0.225) and Grok 4.7 ($0.225) on the same workload. Terra carries the identical 30-minute default, 12-hour option and “does not restart the clock” read behaviour as the rest of the GPT-6 family, so nothing above changes except the absolute numbers — why it also makes OpenAI’s reasoning badge uninformative.
That 2.5x on the cron row is the cache clock in isolation, with tokenizer differences held out. Our Luna vs Haiku 5.5 head-to-head measures the same workload at 3.71x, and the two figures are consistent: 2.50x of clock multiplied by 1.49x of tokenizer is 3.73x. Retention is the larger of the two penalties, and it is the one neither rate card mentions.
Google’s cache has a shelf life, and it is far shorter than its default TTL
This is the finding that no vendor page states, because only Google is structured so that it can be true: an idle Gemini cache can cost more than the prompt it is caching. Storage accrues whether you read the cache or not, so there is a gap length past which deleting the cache and re-sending the prompt is strictly cheaper.
The break-even is where storage for the gap plus one cached read equals one uncached send:
| Model | Input / 1M | Storage / 1M / hour | Hold it longer than… |
|---|---|---|---|
| Gemini 3.1 Pro Preview (priority) | $2.00 | $8.10 | 12 minutes |
| Gemini 3.1 Flash-Lite (standard) | $0.25 | $1.00 | 13 minutes |
| Gemini 3.5 Flash-Lite | $0.30 | $1.00 | 16 minutes |
| Gemini 3.1 Pro Preview (standard) | $2.00 | $4.50 | 24 minutes |
| Gemini 3.1 Pro Preview (>200k prompt) | $4.00 | $4.50 | 48 minutes |
| Gemini 3.8 Flash (to 31 Dec 2026) | $0.75 | $0.50 | 81 minutes |
| Gemini 3.6 Flash (to 31 Dec 2026) | $0.75 | $0.50 | 81 minutes |
…and you should drop it. Google’s default TTL, if you do not set one, is 1 hour — which is past the break-even on five of the seven rows above. The default setting is the losing setting for most of the lineup, and on Gemini 3.1 Pro Preview holding a cache for its default hour costs 2.25x what re-sending the prompt would.
Two details sharpen this. Google’s prices rise on 1 January 2027 — Gemini 3.8 Flash storage from $0.50 to $1.00 per million per hour as input goes $0.75 to $1.50 — but because both halves double, the 81-minute break-even does not move. And the batch discount does not apply to cached tokens: for Batch and Flex the caching row reads “Same as Standard”, so caching and batching do not compound as they do on Anthropic, where multipliers “stack with other pricing modifiers such as the Batch API discount”.
The practical rule on Google is the inverse of the rule everywhere else: set the shortest TTL that covers your actual gap, and delete caches you are done with. On this pricing model, caches.delete() is the cost lever.
And on Argon, the guarantee is gone
Explicit caching — the mechanism Google says carries a “cost saving guarantee” — now lives in the legacy Generate Content API and is “not supported in the Interactions API, or for Gemini 4 Argon and onward.” Google’s newest flagship, on sale at $2 until its price doubles on 1 December 2026, runs implicit caching only: no pinning, no TTL, and an explicit “no cost saving guarantee” in Google’s own description. Argon’s cached rate is an excellent 0.05x of input and its pricing tables carry no storage line at all — but you cannot promise anyone you will hit it. The advice Google offers instead is a hint: “Try putting large and common contents at the beginning of your prompt.” So the 24-minute break-even is a problem only on the older, pinnable models; on Argon you have the opposite problem of no control at all.
OpenAI’s 12-hour tier is a trap outside one specific band
The 12-hour tier is the only published window longer than an hour in the market, and it is genuinely decisive on the 2-hour cron job above. But it is the wrong purchase on both sides of a narrow band, for two different reasons.
Below 30 minutes it is pure overpayment. The default 30-minute tier costs 1.25x to write against 2.5x, and crucially it self-renews: a read “refreshes coverage to at least 30 minutes after that read.” Any workload whose turns land under 30 minutes apart holds a cache indefinitely at half the write price.
Above 12 hours it is worse than doing nothing special. A read “does not restart a 12-hour clock,” so the window is a hard one-shot. On a daily job waking every 24 hours the cache is always dead on arrival, and the 12-hour tier bills 2.5x for each doomed write where the default tier bills 1.25x — $0.02500 against $0.01250 on the 50,000-token prefix above. Identical cache-hit rate of zero, at exactly double the price. Buying the long tier for a gap longer than 12 hours is buying retention you cannot use.
Two further terms shape the purchase. Upgrading a live 30-minute entry to 12 hours “charges a new 12-hour write for those tokens, without credit for the earlier write,” so you cannot ladder up cheaply; and each request can create up to four cache writes, one of which the implicit breakpoint consumes. Note too that OpenAI’s older models — GPT-5.5 and earlier — carried no cache-write charge at all, using a prompt_cache_retention parameter whose 24h value retained entries “for up to 24 hours”. The write premium arrived with the newer lineup, as did Astra’s cache-write premium: migrating forward on OpenAI means picking up a cost line that did not previously exist.
Anthropic’s window is shorter than the number on the page
Anthropic sells the shortest maximum window of the three guaranteed vendors — 1 hour — and two details make it shorter still in practice.
The clock starts when your request starts, not when the response ends: “Time spent generating a response counts against the lifetime: if a response takes 4 minutes to stream, a follow-up request that reuses the same cached prefix must start within about 1 minute of that response completing.” On a reasoning model that thinks before answering, a nominal 5-minute window can leave under a minute of real idle time.
What Anthropic sells in exchange is the best refresh terms anywhere: “The cache is refreshed for no additional cost each time the cached content is used,” with no published cap. A 1-hour entry read every 50 minutes stays alive forever at 2x write paid once — which is precisely why Anthropic wins the 45-minute column above, 16% cheaper than Luna’s 12-hour tier on the same workload. Anthropic’s own break-even guidance matches ours: the 5-minute tier “pays off after one cache read” and the 1-hour tier “after two cache reads.”
One Anthropic-specific landmine: on Claude Haiku 5.5, “cache reads and cache writes count toward a request’s prompt length,” and crossing 100,000 tokens quintuples every rate, cache included. A 95%-cached prompt is still a full-length prompt for threshold purposes — the 100,000-token cliff is not something caching lets you dodge. Minimum cacheable prefixes also vary more than most buyers assume — 512 tokens on the current flagship and Haiku 5.5, but 4,096 on Opus 4.6, Opus 4.5 and Haiku 4.5 — and requests under the minimum are “processed without caching, and no error is returned”, a silent failure worth asserting on in tests.
What the free caches do and do not promise
xAI and DeepSeek charge nothing to write and nothing to store, which makes them unbeatable on the cost table and unusable in a forecast.
xAI publishes no retention figure at all. Its FAQ asks the question directly — “How long do cache entries persist?” — and answers only that “Cache entries can be evicted at any time due to server load or restarts.” Caching is automatic on “all grok language models,” your one lever is the x-grok-conv-id header for sticky routing, and “cache entries are stored per-server.” There is no TTL parameter and no way to force a hit — only to force a miss. Combined with a 0.25x read on Grok 4.7, the weakest discount here, caching is not a reason to choose Grok — see the Grok review for what is.
DeepSeek’s cache is on disk, and it is the longest-lived in practice. “Once the cache is no longer in use, it will be automatically cleared, usually within a few hours to a few days” — an idleness trigger rather than a clock, on a system DeepSeek calls “best-effort”. Its discount is the steepest anywhere: $0.003 against $0.15 on deepseek-flash, 98% off. Two caveats matter more than that headline. Matching is stricter than ordinary prefix matching, because a cached unit must match in full: a first request of A + B followed by A + C misses entirely, and DeepSeek’s own long-document example concedes “the first two requests will not hit the cache.” And cache-hit prices are time-of-day dependent — peak hours, 01:00–04:00 and 06:00–10:00 UTC Monday to Friday, cost exactly double, cached input included. Our DeepSeek review covers the residency and lifecycle trade-offs, and we priced the newer endpoints when Search and Fetch went on the meter.
For either vendor, model the uncached price and treat cache hits as margin you did not plan for.
Which to buy
| If your gap between turns is… | Buy | Why |
|---|---|---|
| Under 5 minutes | Anything — pick on rate | Every cache holds; the read discount is the only variable |
| 5–30 minutes | GPT-6 Luna or Gemini Flash | Luna’s 30-min default self-renews at 1.25x; Gemini is still inside its storage break-even |
| 30–60 minutes | Claude Haiku 5.5 / Sonnet 5.5 | Free refresh on a 1-hour entry; 16% under Luna’s 12-hour tier on the same workload |
| 1–12 hours | GPT-6 Luna, GPT-6.1 Terra or GPT-6.1 Sol, 12h tier | The only bounded-price window past an hour; 2.5x once, not per hour. Terra is half of Sol at the same terms |
| Over 12 hours | Nobody — use the cheap write tier | No cache survives; the long tier costs 2x for the same zero hit rate |
| Unpredictable | Anthropic, or model uncached | Free refresh is the only term that degrades gracefully |
| Cheapest at any gap, non-sensitive data | DeepSeek Flash | 98% off and a disk cache lasting hours to days — but best-effort, and 2x at peak hours |
| Needs a defensible forecast | OpenAI or Anthropic | Only published, guaranteed windows; Google’s newest model and both free caches guarantee nothing |
The general lesson is the one the rate cards hide: retention is priced on a different axis from tokens, and no two vendors use the same axis. Before comparing cache-read discounts, measure your median gap between turns. That one number decides more of the bill than the discount does — and on Google, it decides whether caching saves you money at all.
If you are choosing a model rather than a caching strategy, what a long prompt actually costs covers the length cliffs that interact with these caches. Lifecycle dates for every model named here are on model retirements.
What changed
- 27 Oct 2026: GPT-6.1 Terra added — $1/$5 with $0.05 cache reads and $1.25/$2.50 cache writes, exactly half of GPT-6.1 Sol on every line at identical retention terms — see analysis.
- 25 Oct 2026: Page published. All five vendors’ retention terms, write multipliers, read multipliers and storage rates verified against vendor caching docs and pricing pages. Notable at publication: Google’s explicit caching is now legacy and unsupported on Gemini 4 Argon and later; xAI publishes no TTL figure at all; DeepSeek’s documentation no longer states a 64-token cache block size.
Frequently asked questions
Which vendor's prompt cache survives the longest gap between turns?
OpenAI's, at a published 12 hours, and it is the only vendor that sells a window longer than one hour. Anthropic's maximum is 1 hour. Google's explicit caches have no stated maximum TTL at all, but you pay per hour to hold one, so the economics expire long before the cache does. xAI publishes no retention figure whatsoever — its FAQ answers 'How long do cache entries persist?' with 'Cache entries can be evicted at any time due to server load or restarts.' DeepSeek states the longest effective window of anyone, 'usually within a few hours to a few days', but calls the system 'best-effort' and guarantees nothing. So: the longest guaranteed window is OpenAI's 12 hours, and the longest likely window is DeepSeek's disk cache. Terms verified 25 October 2026.
Does reading a cache extend its life?
On Anthropic, yes and for free: 'The cache is refreshed for no additional cost each time the cached content is used', with no published cap on how many times. That makes a 1-hour entry read every 50 minutes effectively immortal. On OpenAI, only partly — a read 'refreshes coverage to at least 30 minutes after that read', but it 'does not restart a 12-hour clock'. So OpenAI's 30-minute tier self-renews indefinitely while its 12-hour tier is a hard one-shot window. On Google, reads do not extend anything; you extend a cache by PATCHing its TTL and paying more storage. On xAI and DeepSeek, eviction is driven by memory pressure and idleness rather than a clock, so there is nothing to extend.
Is Google's prompt caching cheaper or more expensive than OpenAI's?
It depends entirely on how long you hold the cache, because Google charges on a different axis. Google levies no cache-write premium but bills storage per million tokens per hour — $4.50 on Gemini 3.1 Pro Preview, $0.50 on Gemini 3.8 Flash through 31 December 2026. That makes Google cheapest for very short gaps and the most expensive option for long ones. On Gemini 3.1 Pro Preview the break-even is 24 minutes: hold a cache longer than that and you have paid more in storage than simply re-sending the prompt would have cost. OpenAI's 12-hour write premium, by contrast, is a one-time 2.5x charge that does not grow with the gap. Prices verified 25 October 2026.
Should I buy OpenAI's 12-hour cache tier?
Only if your gap between turns is longer than 30 minutes and shorter than 12 hours. Outside that band it loses money. Below 30 minutes the default tier costs 1.25x to write instead of 2.5x and renews itself on every read, so the long tier is pure overpayment. Above 12 hours the window expires before your next turn arrives and you pay the 2.5x premium for retention you never use — on a daily job waking every 24 hours, the 12-hour tier costs exactly 2x the default tier for an identical number of cache misses. The tier is also Responses-API-only, and upgrading an existing 30-minute entry to 12 hours 'charges a new 12-hour write for those tokens, without credit for the earlier write.'
Why does Anthropic's 5-minute cache expire sooner than I expect?
Because the clock starts when the request starts, not when it finishes. Anthropic's caching page is explicit: 'The lifetime is measured from the start of the request that writes or reads the cache entry, not from the end of its response. Time spent generating a response counts against the lifetime: if a response takes 4 minutes to stream, a follow-up request that reuses the same cached prefix must start within about 1 minute of that response completing.' On a reasoning model with long thinking blocks, a nominal 5-minute window can leave under a minute of usable idle time. The 1-hour tier at 2x write is the practical fix, and it is why Anthropic's free refresh matters more than its headline TTL.
Do the cheapest caches — xAI's and DeepSeek's — actually save money?
DeepSeek's does, dramatically: a cache hit on deepseek-flash costs $0.003 against $0.15 for a miss, which is 98% off, the steepest discount of any vendor here, and there is no write premium or storage fee. xAI's is the weakest discount in the market: Grok 4.7 cache hits cost $0.50 against $2.00 input, only 75% off, where every OpenAI, Anthropic and Google model gives 90-98%. Both are automatic and free to write, and both are explicitly best-effort — DeepSeek 'does not guarantee a 100% cache hit rate' and xAI warns that 'Prompt caching is not 100% guaranteed.' Neither can be pinned, so neither belongs in a cost model you need to defend. Treat their savings as upside, not budget.
Can I guarantee a cache hit on Google's newest models?
No. Explicit caching — the mechanism Google describes as carrying a 'cost saving guarantee' — has been moved into the legacy Generate Content API and is 'not supported in the Interactions API, or for Gemini 4 Argon and onward.' Argon and later run implicit caching only, which Google describes as having 'no cost saving guarantee' and which you influence only by hint: 'Try putting large and common contents at the beginning of your prompt.' So on Google's newest flagship you cannot pin a prefix, cannot set a TTL, and cannot promise a finance team a cache-hit rate. The upside is that implicit caching has no published storage charge, so the 24-minute break-even that governs explicit caches does not apply.