Prompt Caching vs Batch Discounts: One $0.10 Cache Read, Three Different Bills

Claude Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon all list $2 per million input tokens, $10 per million output tokens and $0.10 per million cached tokens. On paper, the prompt caching discount comparison ends there. Price the same chat session on each rate card and the effective input rate still ranges from $0.25 to $0.69 per million tokens. That 2.8x spread is caused entirely by rules that sit below the headline price.

The short answer: for interactive work, caching is the only discount that applies, and Anthropic and OpenAI price it identically at $2 models. For offline work, batch and caching stack to roughly a quarter to a third of list input price at Anthropic and OpenAI. Google's rate card is cheapest until 30 November, then doubles.

Prompt caching rates: one cache-read price, three different rate cards

Prompt caching means the provider stores the processed form of a prompt prefix, such as your system prompt and tool definitions. A later request that repeats it pays a reduced rate. Every frontier lab now offers it. The cache-read price is the number vendors advertise, and it has converged.

The table below takes each lab's model priced at $2 per million input tokens. These are not the same tier inside each lab's line-up. Gemini 4 Argon is Google's flagship reasoning model, while Sonnet 5.5 and GPT-6.1 Sol sit below Anthropic's and OpenAI's top models. We matched on price because price is the comparison this post is about, not capability.

Sources: Anthropic pricing, OpenAI pricing, OpenAI prompt caching guide, Gemini pricing and Gemini caching docs, all read 25 October 2026. Last verified 25 October 2026.

Cache writes are where the rate cards split

Anthropic and OpenAI both charge a premium the first time a prefix is stored. Anthropic's pricing page sets a 5-minute write at 1.25x base input and a 1-hour write at 2x. OpenAI's caching guide states that for GPT-5.6 and later, writes cost 1.25x for the default 30-minute lifetime and 2.5x for 12 hours.

Google publishes no write premium for implicit caching, which is now the only kind Gemini 4 Argon supports. Its documentation says simply that it passes on savings if a request hits a cache. That sounds like the best deal of the three, and for some workloads it is. Google's older caching page also describes implicit caching as carrying no cost-saving guarantee, which is the other half of that bargain.

The cache lifetime decides how often you pay the write

A cheaper write that expires sooner is not cheaper if your traffic is bursty. Anthropic's default cache lives 5 minutes. OpenAI's default for GPT-5.6 and later lives 30 minutes at the same 1.25x price. For a support chat where a customer pauses to find an order number, that difference is the gap between a cache hit and paying the write again. On this one variable, we think OpenAI's default is the better buy for human-paced traffic.

How the three workloads in this comparison are built

An effective rate only means something against a defined workload. We built three, each common enough that most teams running an LLM product have at least one of them in production. Every number below is an assumption we chose, not a measurement of anyone's traffic. The rates applied to them are the published ones.

Chat session. A 5,000-token system prompt, already warm in cache from earlier users, followed by 10 turns. Each user message is 150 tokens and each reply is 350 tokens. The whole conversation is resent each turn, so the session totals 74,000 input tokens and 3,500 output tokens. On Anthropic and OpenAI, 69,350 of those input tokens are cache reads and 4,650 are cache writes.

RAG query. A 3,000-token fixed instruction block, warm in cache, plus 8,000 tokens of retrieved passages that change on every query, a 100-token question and a 500-token answer. That is 11,100 input tokens per query, of which only the instruction block can ever be a cache hit. Retrieval-augmented generation is cache-hostile by design, because the expensive part is the part that changes. We cover the long-context alternative in the comparison of RAG against long-context cost.

Agent loop. A 12,000-token system prompt with tool definitions, a 500-token task, then 20 steps. Each step emits a 300-token tool call and appends a 1,500-token tool result. Input grows from 12,500 tokens at step 1 to 46,700 at step 20, for 592,000 input and 6,000 output tokens across the run. On Anthropic and OpenAI, 557,300 input tokens are reads and 34,700 are writes.

We assumed every request lands inside its cache lifetime, and that the shared prefix is already warm. Both assumptions flatter caching. Real hit rates are lower, and the section on weaknesses returns to that.

Effective rates for chat, RAG and agent loops, by lab

The effective input rate is the blended price you pay per million input tokens. It mixes reads, writes and uncached tokens in the proportions a workload actually produces. It is the number to put in a cost model, because the list price and the cache-read price are both fictions for any real workload.

Zan Digital calculation. Totals include output tokens at each model's list output rate. The RAG instruction block of 3,000 tokens sits under Gemini's 4,096-token implicit-caching minimum, so the Gemini RAG rows assume no cache hit. Workload shapes are illustrative.

Chat: identical at Anthropic and OpenAI, nearly triple at Google

Sonnet 5.5 and GPT-6.1 Sol produce the same chat bill to the tenth of a cent. Their read, write and output rates match exactly. Caching cuts the session from $0.183 uncached to $0.054, a reduction of about 71%. The only thing separating them is cache lifetime, which our model holds constant and your traffic will not.

Gemini's 2,050-token rule changes the chat and agent answers

Gemini 4 Argon should win on the rate card. It has the same $0.10 read price and, as far as Google documents, no write premium. On a naive calculation it is the cheapest option for both chat and agent loops: our agent loop would cost $0.125 in input tokens against $0.142 at the other two.

Google's caching documentation adds one sentence that reverses this. For Gemini 4, it says the model caches the full previous request only if the new request adds at least 2,050 tokens. For smaller additions, it re-processes the last 2,050 tokens of the previous request at the standard input rate.

Our chat turns add 500 tokens. Our agent steps add 1,800. Both fall under the line, so every turn after the first pays full price on 2,050 old tokens plus the new ones. In the chat session that moves 23,100 tokens to the $2 rate. In the agent loop it moves 73,650 tokens there, and uncached input becomes 57% of the Gemini run's total cost.

When Gemini's implicit cache is the cheapest of the three

The rule flips cleanly at the threshold. Below 2,050 new tokens per request, Anthropic and OpenAI are always cheaper per append, because paying 1.25x on a few hundred tokens beats paying 1x on more than 2,000. Above 2,050 tokens per append, Gemini bills new tokens at $2 against $2.50 for a cache write elsewhere, a 20% saving on every append.

That makes Gemini 4 Argon the better fit for agents that pull large documents, long search results or file contents into each step. It is the weaker fit for conversational products and tight tool loops with short results. If your agent's tool outputs are trimmed, as we would recommend for quality reasons anyway, you are on the wrong side of Google's line.

Where prompt caching and batch discounts stack, and where they do not

All three labs offer a batch interface at 50% off input and output in exchange for asynchronous delivery. Gemini's batch documentation gives a 24-hour target turnaround. The question buyers ask is whether the cache discount applies on top. The answer differs by lab, and only one of the three says it plainly.

Anthropic documents the stack in words

Anthropic's pricing page states that its cache multipliers stack with other pricing modifiers, including the Batch API discount and data residency. A cache read on Sonnet 5.5 inside a batch therefore costs $0.05 per million tokens, and a 5-minute write costs $1.25. The same page notes that batch is not available with Fast mode, while caching multipliers do apply there.

OpenAI shows the stack on the rate card only

OpenAI's batch table lists a batch cached-input price of $0.05 for GPT-6.1 Sol, plus batch write prices of $1.25 and $2.50. Its prompt caching guide does not mention batch at all. Older batch rows for models such as gpt-4o show no cached-input price, and community threads from that era report no cache discount in batch. For GPT-5.6 and later, the card is the only evidence, and we would treat it as binding until a bill says otherwise.

Google's two pages disagree

The Gemini pricing page lists a batch context-caching price of $0.05 for Argon, half the standard $0.10. The batch-mode page says a cache hit inside a batch pays the standard context caching rates. It also says you reuse a cache by naming a cached_content resource, which is explicit caching, and Google's caching page says explicit caching is not supported for Gemini 4 Argon. We could not reconcile these from the documentation. Our RAG figures avoid the question, because the instruction block falls under Google's minimum anyway.

The larger point is about workload, not vendor. Batch requires you to accept delivery inside a day. A chat user will not wait, and an agent step depends on the result of the step before it. So the stacked rate, roughly a third of list input price for our RAG query, is only available to backfills, evaluations, document processing and offline enrichment. If most of your token volume is interactive, the batch discount is irrelevant to your bill and you should stop modelling it.

The small-model tier follows the same pattern, with one long-context trap

The $0.10 input tier shows the same convergence. Claude Haiku 5.5 and GPT-6 Luna both list $0.10 input, $0.50 output and $0.01 for a cache read, and both charge $0.125 for a default cache write. Run our agent loop through either and the whole 20-step run costs about $0.013, against $0.20 on the $2 models.

Gemini 3.8 Flash sits higher at $0.75 input, $3.75 output and $0.075 for cached tokens, and it still offers explicit caching with storage at $0.50 per million tokens per hour. Its prices double on 1 January 2027, which we tracked in the analysis of the Gemini Flash price increase.

The trap is long context. Anthropic prices Haiku 5.5 by prompt length: a request over 100,000 tokens pays $0.50 input and $0.05 per cache read, five times the short rate. Anthropic's page adds that each request is priced on its own, including cache reads, so a request over the threshold pays the higher price even when most of it is cached. OpenAI doubles its rates above 272,000 input tokens. Sonnet 5.5, by contrast, bills its full 1 million token window at one rate. An agent loop that runs long enough to cross a threshold changes vendor rankings mid-run, and most cost dashboards will not show you when it happened.

Where this prompt caching comparison is weakest

Three things could make the numbers above wrong for your business. One of them is large enough that we would not quote our chat figure for Google without it.

The workloads are ours, and they flatter caching

Every request in our model lands inside its cache lifetime with a warm shared prefix. Real traffic misses. Anthropic's 5-minute default will expire between human chat turns more often than OpenAI's 30 minutes, and Gemini's implicit cache carries no guarantee at all. Change the turn size, the tool result size or the hit rate and the ranking can change. The Gemini result in particular rests on our reading of a single documented sentence about the 2,050-token rule. If Google applies it differently in billing, the Gemini chat and agent figures move toward the naive, cheaper calculation.

Output tokens and capability are not equal across the three

We priced output at list and held output volume constant. In practice, reasoning models emit thinking tokens billed as output, and Google's page states that Argon's output price includes thinking tokens. A model that thinks twice as long at the same output rate erases most of an input-side advantage. We also matched models on price, not quality. If one model finishes your task in fewer agent steps, it can win on total cost despite a worse effective rate. We examined that gap in the piece on model routing and quality loss.

Finally, these are prices on a single date. Google's Argon pricing is explicitly temporary, OpenAI marks some GPT-5.6 pricing as promotional, and Anthropic withdrew a scheduled Sonnet 5 increase in September. Any figure here should be re-checked before it goes into a budget.

Frequently asked questions

Where to start this week

Pull one day of usage from your provider and split input tokens into three buckets: cache reads, cache writes and uncached. Divide total input spend by total input tokens. That is your effective rate, and it is the only one worth comparing against another vendor's card.

Then measure the size of what each request appends. If most appends are under 2,050 tokens, Google's implicit cache will cost you more than its rate card implies. If your cache writes cost more than your cache reads, as they did in our agent loop, look at cache lifetime before you look at a cheaper model. For the wider question of why these bills keep rising while unit prices fall, see the breakdown of cheap tokens and rising AI bills.

Related reading