Send the same long document to an AI model a thousand times, and prompt caching can make a large difference. In the example below, a $389.12 GPT-6 Astra bill falls to $94.58. That’s a saving of $294.54, or about 76%.

But change the workload so that more of the bill comes from generating answers, and the saving falls to 36%. Write the document into a cache on every request without ever reusing it, and the bill goes up.

All three results follow from the same price list. The useful question is how much of your workload can earn the discount.

What gets cheaper

Prompt caching lets a model reuse work it has already done on the beginning of a request: a document, system instructions, or tool definitions that stay the same between calls. The model still generates a fresh answer. This is different from storing a completed response and serving it again.

The distinction matters because the discount applies to reused input. New questions and newly generated answers still incur their usual charges. A cache write can also cost more than ordinary input.

Here are the rates used in this article, checked on October 18, 2026. All figures are US dollars per million tokens, for standard first-party API service at the context lengths in our examples.

Model Ordinary input Cached input First write of the prefix Output
GPT-6 Astra $10.00 $1.00 $12.50 $50.00
Claude Opus 5.5 $4.00 $0.20 $5.00, using the five-minute cache $20.00
Gemini 4 Argon $2.00 $0.10 Ordinary input price on a miss $10.00

Sources: OpenAI pricing, Anthropic’s Opus 5.5 documentation, and Google’s pricing table. OpenAI and Anthropic’s write prices are the full charge for those tokens; don’t add ordinary input charges again. Argon’s rates are promotional through November 30, 2026. Google lists doubled input, cached-input, and output rates from December 1.

These models illustrate three billing arrangements. The table says nothing about which produces the best answer.

A document you ask about repeatedly

Imagine an application answering 1,000 questions about the same document. Each request contains a stable prefix of 32,768 tokens, another 1,024 tokens of changing input, and 1,024 billable output tokens.

For this calculation, the first request is cold and the next 999 reuse the entire prefix. That’s an optimistic scenario, not a measured hit rate. It also assumes identical token quantities across providers to isolate their billing; the same document would not necessarily tokenize to the same length on each model.

Model All input at ordinary rates One cold request, then 999 hits Whole-bill saving
GPT-6 Astra $389.12 $94.58 75.7%
Claude Opus 5.5 $155.65 $31.29 79.9%
Gemini 4 Argon $77.82 $15.63 79.9%

The Astra row is easy to unpack. Without caching, input costs $337.92 and output costs $51.20. With caching, the bill becomes:

  • $0.4096 to write the document prefix once.
  • $32.7352 to read that prefix on the other 999 requests.
  • $10.24 for the changing input.
  • $51.20 for the generated output.

That adds up to $94.5848 before rounding. Input spending falls about 87%, while the whole bill falls about 76%. The output charge never moved.

Google’s row is conditional on those implicit cache hits actually happening. Its caching documentation recommends common prefixes and closely spaced requests to improve the chances; it does not promise this hit rate. The all-ordinary-price column is a calculation baseline, including where automatic caching makes it a counterfactual.

Misses change the result quickly

The attractive row above hides the hardest operational question: how often does the cache actually help?

Keep the Astra workload unchanged, but now assume every miss writes the full prefix again. This makes the write cost explicit instead of quietly treating unsuccessful requests as ordinary input.

Full-prefix hits out of 1,000 requests Total bill Change from the $389.12 baseline
0 $471.04 21.1% more expensive
500 $282.62 27.4% saved
900 $131.89 66.1% saved
999 $94.58 75.7% saved

At zero hits, you keep paying a write premium and never collect the read discount. That is how caching can increase a bill.

At these rates, one write followed by one successful reuse already beats two ordinary reads of the same prefix: $12.50 + $1.00 versus $10.00 + $10.00 per million prefix tokens. Anthropic’s five-minute Opus cache also pays back after one reuse. Its one-hour write costs twice ordinary input, so that option needs two successful reuses to get ahead. These comparisons concern prefix costs; everything else stays equal.

A long answer leaves less room to save

Now consider a revision workflow: a stable prefix of 16,384 tokens, 4,096 tokens of changing instructions, and 4,096 billable output tokens per request.

Across 1,000 Astra requests, the ordinary-price bill is $409.60. Even with one write and 999 full-prefix hits, it only falls to $262.33—a saving of 35.9%.

The reason is visible in the bill. Output alone costs $204.80, half the original total. Caching the input cannot reduce that half. Include any billed reasoning tokens in the output total, once, when applying this calculation to a reasoning model.

This is why a provider’s cached-token discount is a poor forecast on its own. Two applications can use the same model and achieve the same hit rate while saving very different percentages.

Timing and prompt layout matter

The repeated material must be at the beginning of the request and match the cached prefix. Put a changing timestamp before a long document, and the prefix may stop matching before the useful material starts. Put stable instructions and documents first, followed by the changing question.

Retention also limits reuse. OpenAI’s current caching guide documents a 30-minute explicit TTL and refresh on reuse; routing still affects hits. Anthropic offers five-minute and one-hour options. Repeated calls a minute apart are a very different prospect from an occasional question hours later.

Short prompts may not qualify at all. The documented minimums for the models here are 1,024 visible prefix tokens for Astra, 512 cacheable tokens for Opus 5.5, and 4,096 input tokens for Argon. Our document example clears all three.

For your own estimate, start with a few days of usage records. Separate cache reads, cache writes, ordinary input, and output into non-overlapping quantities. Multiply each by its rate, then compare the result with the same requests billed at ordinary input prices. Check the provider’s field definitions before adding totals: some input counters already include cached tokens.

The document-heavy example saves nearly $295 because it repeatedly reuses a large input. The revision example saves about $147 because much more of its money goes into answers. Your request mix determines which calculation is closer.

Calculation notes

These are billing models, not paid API experiments. They exclude taxes, tools, batch discounts, regional uplifts, and higher context-price bands. Output length is held fixed; the examples do not measure speed or answer quality. Argon uses implicit caching, while the Astra and Opus examples use explicit prefix caching. No separately billed storage object is included.

The calculation script contains the rates, workloads, and arithmetic behind every cost table here. Related: why language changes token costs.