GPT-6 Cached Input Pricing Explained: What a Cache Hit Actually Costs

I used to think of prompt caching as a nice-to-have — the kind of optimization you get to after the real work is done. Then I ran the numbers on an agent that sends the same 50,000-token system prompt with every request, and caching turned out to be the whole ballgame: the same request costs $0.122 uncached and $0.027 cached on GPT-6.1 Sol. That is a 78% cut, before you touch the model, the prompt, or anything else.

Here is the short version. A cached GPT-6 token costs 5–10% of a fresh one: $0.01 on Luna, $0.05 on Terra, $0.10 on 6.1 Sol, $1.00 on Astra, per million tokens. Writing to the cache costs extra — 1.25× the input rate for the default 30-minute lifetime, 2.5× for the 12-hour option OpenAI added on October 20. The rest of this article is the fine print that decides whether those discounts land in your bill or stay on the pricing page.

The rate card

All four GPT-6 models, short context (up to 272K input tokens), per million tokens, from OpenAI's pricing page, verified November 11, 2026:

Two patterns worth noticing. First, the read discount is not uniform: Sol 6.1 and Terra read cache at 5% of input, while Luna and Astra read at 10%. That is why Sol 6.1's cached token ($0.10) costs the same as Luna's fresh token. Second, the write is a multiplier on input, not a flat fee — 1.25× for 30 minutes, 2.5× for 12 hours — so the write on Astra ($12.50) costs more than the entire input leg of the same prefix on Sol 6.1. Write costs scale with the model, not just with the prefix.

For comparison across the fence: Claude Fable 5.2 reads cache at $0.20, which is 2.5% of its $8 input price — a deeper percentage discount than any GPT-6 model, though in absolute dollars it still costs twice what Sol 6.1 charges for a cached token.

How caching actually works

OpenAI's prompt caching guide is refreshingly blunt about the mechanics, and three of them decide your bill. First, caching is on by default — you do not opt in, you opt out by breaking the conditions. Second, the cache only holds a prefix: the unchanged tokens at the start of the prompt. Anything after the first changed token is processed at full price, so the stable material — system prompt, tool definitions, retrieved documents — goes first, and the thing that changes every request goes last. Third, the prefix has to clear a minimum of 1,024 visible input tokens before it can be cached at all. A 300-token system prompt will never hit, no matter how often you repeat it.

The prefix also has to match exactly. Change a tool description, reorder a schema, tweak reasoning.effort at the request level, and the cache entry after that change is dead — the guide says the prefix after the first changed token cannot match. OpenAI's workaround is to append a configuration_update item instead of changing request-level settings, which keeps the original prefix intact. In practice this is where most cache-hit rates quietly die: someone edits a system prompt on Tuesday and wonders why the bill doubled on Wednesday.

One more honest caveat from the guide: the cache lifetime is a minimum, not a promise. OpenAI says the lifetime "governs eligibility for cache-read pricing" and "does not guarantee that every request reuses stored KV tensors." You can do everything right and still miss. That is why you should budget on a measured hit rate from your own usage dashboard, not on the 100% line in the table below.

Worked example: one request, then a month of them

Take a realistic agentic request on GPT-6.1 Sol: a 50,000-token cached prefix (system prompt, tool schemas, a reference doc), a 1,000-token fresh user message, and 2,000 tokens of output. Short context, Standard speed.

The output leg does not move — caching never touches output tokens — which is exactly why the saving is 78% here and not 95%. The input leg collapses from $0.102 to $0.007, but the $0.020 of output is now three-quarters of the cached request's cost. If your workload is output-heavy, caching helps less than the headline suggests; if it is input-heavy, it helps more. Run that same request 100,000 times a month and the bill is $12,200 uncached vs $2,700 cached — $9,500 a month, $114,000 a year, for changing nothing except the order of your prompt.

Real hit rates are never 100%. Here is the same month at realistic rates:

The shape of that chart is the point. Going from 0% to 50% saves $4,750 a month; going from 80% to 95% saves another $1,425. Every point of hit rate is worth real money, and the cheapest way to buy hit rate is usually not a new model — it is putting the stable material first and stopping the casual prompt edits. OpenAI's own example in the guide makes the same point from the other side: ten requests, one write and nine full reads, cost 2.15× the ordinary input price, against 10× without caching.

The write costs nobody budgets for

Cache reads are the discount everyone quotes; cache writes are the line item that surprises people. The first request that creates an entry pays the write rate on the whole prefix — on Sol 6.1, a 50,000-token prefix costs $0.125 to write at the 30-minute rate and $0.25 at the 12-hour rate. That sounds trivial until traffic goes quiet: the 30-minute entry lapses after 30 minutes of no reads, and the next request pays the write again. A prefix that lapses every hour costs 24 writes a day; at $0.125 a write that is $3 a day, $90 a month — still small next to $9,500 of savings, but on Astra the same 50K prefix costs $0.625 a write, and 24 lapses a day is $15 a day, $450 a month, for the privilege of caching.

The practical rule: if your traffic is continuous, you pay one write and forget about it — each read refreshes the 30-minute clock. If your traffic arrives in bursts with gaps longer than 30 minutes, count the writes. You can see both numbers in your usage data: cached_tokens tells you what you read, cache_write_tokens tells you what you wrote, split into 30-minute and 12-hour buckets.

30 minutes or 12 hours?

Since October 20, the Responses API lets you pick a 12-hour minimum lifetime with prompt_cache_options.ttl set to "12h". The write costs double — 2.5× input instead of 1.25× — and the read price is identical either way. So the 12-hour option only pays when it avoids at least two re-writes of the 30-minute cache. On Sol 6.1 with our 50K prefix: one 12-hour write is $0.25; three 30-minute writes (the first plus two lapses) are $0.375. If your prefix would lapse twice or more inside 12 hours, buy the 12 hours. If it lapses once or never, the 30-minute default is cheaper.

The guide suggests mixing them in one request: put the all-day material at the start of the prompt with a 12-hour breakpoint, and session context that changes every few minutes on a 30-minute breakpoint. That is the right shape for most agents — stable instructions up front, rolling conversation behind them — and explicit mode lets you place up to four breakpoints per request so you can draw the line exactly where the stable material ends.

The long-context catch

Cross 272,000 input tokens and the whole request reprices — cached reads included. The cached-input rate doubles: Luna $0.02, Terra $0.10, Sol 6.1 $0.20, Astra $2.00 per million, and the write rates double with them (Astra's 30-minute write becomes $25.00, its 12-hour write $50.00). The read is still 5–10% of the long-context input rate, so the percentage discount survives — but a cache-heavy 500K-token request on Astra still pays $1.00 per million cached tokens, ten times what Sol 6.1 charges for a fresh token. Long prompts do not break caching; they just move the goalposts, and the model choice starts to matter more than the hit rate. If your prefixes routinely run past 272K, the comparison that matters is in my Fable 5.2 vs Astra piece, where the cliff does the deciding.

What caching cannot fix

Three limits, so nobody walks away thinking this is free money. Output tokens are never cached — a workload that generates long responses pays full output price no matter what. Prefixes under 1,024 tokens do not cache at all, so short system prompts get zero benefit. And a cache hit is never guaranteed: entries lapse, exact matches fail, and OpenAI is explicit that the lifetime governs pricing eligibility, not reuse. Treat the hit-rate table above as a planning tool, then go read your actual cached_tokens in the usage dashboard and re-plan on the real number. Prices verified November 11, 2026 — always confirm on the official pricing page before making decisions.

Sources

• OpenAI API pricing — GPT-6 cached input, 30m and 12h write rates, verified November 11, 2026.
• OpenAI prompt caching guide — 1,024-token minimum, exact prefix matching, 1.25×/2.5× write rates, 0.1×/0.05× read rates, 12-hour lifetime, four breakpoints per request.
• OpenAI API changelog — 12-hour prompt caching added October 20, 2026.