Claude, GPT, and Gemini all discount cached input tokens, but the mechanics differ enough that a prompt cheap to cache on one provider can be expensive on another. Anthropic charges extra to write a cache and about a tenth of the base price to read one. OpenAI caches automatically at a flat 50% discount with no write cost. Google’s Gemini models discount cached reads to roughly a tenth of standard input but add an hourly storage fee for caches you create explicitly. Which setup actually saves money depends on how often you reuse the same prefix and how long it needs to stay warm.
\nWhy Cache Pricing Is Never Just One Number
\nA cache price has at least three moving parts: what it costs to write the cache the first time, what it costs to read it on every later request, and how long it survives before you have to write it again. A fourth part, the minimum prompt length before caching is even allowed, decides whether a given request qualifies at all. Providers that look cheaper on the headline discount can end up costing more once you add in how often you have to repay the write cost.
\nClaude’s Prompt Caching: Write Multipliers, TTL Choices, and Per-Model Minimums
\nAnthropic’s prompt caching charges a premium to write a cache and a steep discount to read one, and the size of that premium depends on how long you ask the cache to live. The default is a 5-minute, or “ephemeral,” cache that refreshes for free every time it’s read, measured from the start of the request rather than the end. An optional 1-hour cache costs more to write and suits prompts reused less often than every five minutes but more than once an hour, including batch jobs, according to Anthropic’s own documentation.
\n| Operation | Multiplier vs. base input price |
|---|---|
| 5-minute cache write (default) | 1.25x |
| 1-hour cache write | 2x |
| Cache read / hit, standard Claude models | 0.1x |
| Cache read / hit, Claude Opus 5.5 / Sonnet 5.5 | 0.05x |
The minimum prompt length before Claude will cache anything also varies by model generation. Shorter prompts are simply processed without caching and without an error.
\n| Minimum cacheable tokens | Models |
|---|---|
| 512 | Opus 5.5, Sonnet 5.5, Opus 5, Fable 5, Mythos 5, Haiku 5.5 |
| 1,024 | Sonnet 5, Sonnet 4.6, Sonnet 4.5, Sonnet 4, Opus 4.8, Opus 4.1, Opus 4 |
| 2,048 | Opus 4.7, Haiku 3.5 |
| 4,096 | Opus 4.6, Opus 4.5, Haiku 4.5 |
If you haven’t wired caching into a Claude integration yet, our walkthrough on setting up prompt caching breakpoints in the Claude API covers where to place the cache_control blocks and how to confirm a request actually hit the cache.
\nOpenAI’s Automatic Caching: A Flat Discount, No Write Fee
\nOpenAI’s caching needs no configuration and carries no separate write charge. Any prompt over the minimum length is automatically eligible, and the discount applies the moment a request reuses a matching prefix.
\n- Cached input tokens cost 50% less than uncached ones — GPT-4o input, for example, drops from $2.50 to $1.25 per million tokens.
- Caching applies only to prompts longer than 1,024 tokens; the cached prefix starts at 1,024 tokens and grows in 128-token increments.
- Caches are typically cleared after 5\u201310 minutes of inactivity, and are removed within one hour of last use regardless of activity.
Because there’s no write multiplier, a prompt you only reuse two or three times still comes out ahead on OpenAI, where the same pattern on Claude’s 5-minute cache has to earn back a 1.25x write cost before the 0.1x read price makes it worthwhile. Full details are in OpenAI’s prompt caching announcement and documentation.
\nGemini’s Implicit and Explicit Caching: Cheap Reads, a Storage Bill
\nGemini splits caching into two modes. Implicit caching is turned on by default for Gemini 2.5 and newer models and needs no setup at all; Google states the savings are passed on automatically whenever a request hits a cache, without publishing a separate implicit-cache token price. Explicit caching, where you create and manage a cache object yourself, is priced separately and adds an hourly storage charge on top of a discounted read price, per Google’s context caching documentation.
\nImplicit caching has its own minimum prompt size, and it’s higher than either Claude’s or OpenAI’s floor: 2,048 tokens for Gemini 2.5 Flash and Pro, and 4,096 tokens for the newer Gemini 3.1 Pro Preview, 3.6 Flash, 3.8 Flash, and 4 Argon.
\n| Model | Standard input (per 1M tokens) | Cached input (per 1M tokens) | Storage (per 1M tokens / hour) |
|---|---|---|---|
| Gemini 3.1 Pro Preview | $2.00 (\u2264200k), $4.00 (>200k) | $0.20 (\u2264200k), $0.40 (>200k) | $4.50 |
| Gemini 3.8 / 3.6 Flash | $0.75 through Dec 31, 2026 | $0.075 through Dec 31, 2026 | $0.50 through Dec 31, 2026 |
| Gemini 3 Flash Preview | $0.50 (text/image/video) | $0.05 (text/image/video) | $1.00 |
| Gemini 4 Argon | n/a (implicit-only) | $0.10 through Nov 30, 2026 | Not published |
Gemini 4 Argon supports implicit caching only; Google’s pricing page does not list a storage fee for it because there’s no explicit cache object to store. Explicit caching is also unavailable in the Interactions API.
\nSide by Side: What Each Provider Actually Charges
\nLined up on the same four axes, the differences in how each provider structures the bill become clearer than any single pricing page shows on its own.
\n| Provider | Write cost | Read / hit discount | Default TTL | Minimum tokens to cache |
|---|---|---|---|---|
| Claude (Anthropic) | 1.25x base (5-min) or 2x base (1-hour) | ~0.1x base (0.05x on Opus 5.5 / Sonnet 5.5) | 5 minutes, refreshed on each read | 512\u20134,096 depending on model |
| GPT (OpenAI) | None | 0.5x base (flat 50% off) | ~5\u201310 min idle, 1 hour max | 1,024, +128 per increment |
| Gemini (Google) | None for implicit; storage fee for explicit | ~0.1x base on Pro/Flash models | Not published for implicit; configurable for explicit | 2,048\u20134,096 depending on model |
For more of this same three-way split applied to request limits rather than caching, see how rate limits and pricing tiers compare across the major AI APIs, and if you’re new to the concept of caching itself, start with our plain-English explainer on what prompt caching is.
\nA Worked Example: The Same 10,000-Token System Prompt, Three Providers
\nHere’s what the published prices above actually mean for a concrete case, using only arithmetic on the public rates — not a benchmark or a timed test. Say an app sends a fixed 10,000-token system prompt on every one of 20 requests inside a five-minute window, on a mid-tier model from each provider.
\n- Claude Sonnet 5 ($3/M base input): the first request writes the cache at 1.25x ($0.0375), and the next 19 reads cost 0.1x each ($0.003 each, $0.057 total) — versus $0.60 with no caching at all.
- GPT (assume $2.50/M base, matching GPT-4o): the first request is uncached ($0.025), and the next 19 are automatically billed at 50% off ($0.0125 each, $0.2375 total) — versus $0.50 uncached.
- Gemini 3.8 Flash ($0.75/M base, implicit caching, price locked through 2026): if every request hits the implicit cache, 20 requests at the full rate would be $0.15; Google doesn’t publish a separate implicit-read price, so the realized savings depend on the hit rate it reports back in the response rather than a number you can compute in advance.
The pattern holds more generally: Claude’s write multiplier means a prefix reused only once or twice barely breaks even, while OpenAI’s zero-write-cost design pays off from the very first repeat. Gemini’s implicit caching removes the decision entirely but also removes the ability to predict savings before you’ve actually sent the traffic.
\nWhere Caching Stops Helping, Regardless of Provider
Caching only pays off when a meaningful chunk of the prompt is byte-for-byte identical across requests, and all three providers share the same two failure modes. The first is a prefix that changes on every call — a system prompt that gets a timestamp or a random request ID spliced into its first few hundred tokens invalidates the cache before it can be reused, on Claude and OpenAI alike, because both match on an exact prefix rather than a fuzzy similarity score. The second is a conversation that grows by appending new turns after the cached segment: that pattern is exactly what caching is good at, since the shared prefix (system prompt, tool definitions, long reference documents) stays fixed while only the newest user and assistant turns change, but it only helps if the application actually places the stable content first and the variable content last.
The other stacking detail worth knowing before estimating savings from a pricing page alone: Anthropic’s multipliers combine with other discounts rather than replacing them. A cached Batch API request, for instance, applies the cache read multiplier on top of the batch discount rather than one or the other, and the same logic applies to long-context and data-residency surcharges. None of the three providers’ public pricing pages compute that combined number for you, so a cost estimate built only from the headline cache discount will usually be wrong once batch processing or long-context pricing is also in play.
How to Pick a Cache Setup for Your Workload
\n- Reused 2\u20133 times in a few minutes: OpenAI’s automatic discount or Gemini’s implicit caching come out ahead, since neither charges a write premium.
- Reused dozens of times within an hour, with a long static prefix: Claude’s 1-hour cache amortizes its 2x write cost quickly and then reads at a steep discount.
- Bursty traffic with idle gaps longer than 10 minutes: OpenAI’s cache will likely have expired between bursts; Claude’s 1-hour option or Gemini’s explicit caching (despite its storage fee) may hold the prefix warm for less than repeatedly repaying a write cost.
- Short prompts under roughly 1,000 tokens: none of the three will cache them, so restructuring to push shared instructions above each provider’s minimum is the only way to benefit at all.
Function calling is the other place these three providers quietly diverge even when the surface-level feature looks identical; see how Claude, OpenAI, and Gemini each define function calling for the same kind of side-by-side breakdown.
\n
