Since July 2026, OpenAI’s cheapest GPT-5.6 model has billed prompt caching differently than almost anything that came before it. Instead of a flat discount for reusing a prompt, GPT-5.6 Luna charges a premium — 1.25 times the normal input rate — every time it has to write a new prefix into its cache. Reading that same cached prefix back later costs only a tenth of the standard rate.
That structure sounds simple until you start running actual workloads through it. Whether it saves money or quietly adds cost depends entirely on how often your prompts get reused before the cache expires. We ran the math against OpenAI’s own published rates to find the real break-even point — and it isn’t quite the number that’s been circulating.
Table of Contents
What Changed With GPT-5.6 Luna’s Caching Model
GPT-5.6 Luna is the fastest and least expensive tier in OpenAI’s GPT-5.6 family, sitting below Terra and the flagship Sol. The family had an unusually short rollout: OpenAI announced a limited preview on June 26, 2026, restricted to a small group of trusted partners through the API and Codex only, before making all three models generally available on July 9, 2026 — just thirteen days later.
Luna’s prompt caching supports two modes. Implicit caching lets OpenAI automatically place a cache breakpoint at the end of your latest message, which works well for conversations that simply keep growing. Explicit caching lets developers mark exactly where a cache breakpoint should sit, useful when only part of a prompt — a system message or a set of tool definitions, say — is worth preserving. Both are documented for “GPT-5.6 and later” as a family, not as a feature unique to Luna.
Current Pricing — and Why the Date Matters
As of this writing, GPT-5.6 Luna costs $0.20 per million input tokens, $0.02 per million cached input tokens, and $1.20 per million output tokens.
| Component | Price (per 1M tokens) |
|---|---|
| Input (uncached) | $0.20 |
| Cached input (read) | $0.02 |
| Output | $1.20 |
| Cache write | $0.25 (1.25× uncached input) |
Rates effective July 30, 2026. Luna launched July 9, 2026 at $1.00 input / $6.00 output.
That’s not the price it launched at. On July 30, 2026 — three weeks after general availability — OpenAI cut Luna’s price by 80%. Terra received a smaller 20% cut the same day; Sol’s pricing didn’t change.
| Date | Event |
|---|---|
| June 26, 2026 | Limited preview announced (API and Codex only, trusted partners) |
| July 9, 2026 | General availability across ChatGPT, Codex, and the API |
| July 30, 2026 | Luna price cut 80%; Terra cut 20%; Sol unchanged |
OpenAI framed the reduction as passing along inference-efficiency gains. CNBC and Axios both reported that OpenAI faces growing pressure from cost-sensitive enterprise customers and rival labs; a separate independent analysis noted the cut came shortly after Anthropic’s Claude Opus 5 and Google’s Gemini 3.6 Flash had both launched in the preceding weeks. Whatever the cause, any cost estimate built on Luna’s original $1.00/$6.00 rates is now out of date — worth checking before trusting a caching calculator that hasn’t been refreshed since July.
How the Cache-Write Fee Actually Works
A cache write happens when a prompt’s prefix isn’t already sitting in OpenAI’s cache — the first time you send it, after the cache entry has expired, or if high traffic routes your request to a different machine that doesn’t have a matching copy. To be eligible at all, a prefix needs to be at least 1,024 tokens long; anything shorter simply can’t be cached on GPT-5.6 and later.
Once written, a cached prefix stays available for at least 30 minutes after its last use — that’s currently the only time-to-live value OpenAI offers for this model generation, set via prompt_cache_options.ttl: “30m”. Reusing the cache before it expires resets that 30-minute clock without triggering another write charge. There’s no way to manually clear a cache entry; it lives or dies purely on that timer.
It’s worth being precise about one thing that’s easy to get wrong: the 1.25x write fee and 0.1x read discount aren’t documented as something exclusive to Luna. OpenAI’s own prompt caching guide describes them as the standard behavior for “GPT-5.6 and later” generally. What differs between Sol, Terra, and Luna is the base price per token — not the caching multipliers themselves.
Two Break-Even Formulas — And They Answer Different Questions
Most of the confusion around Luna’s caching costs comes from mixing up two separate calculations.
OpenAI’s own formula answers a narrow question: is it worth padding a short, frequently-reused prompt up to the 1,024-token minimum just to make it cacheable? The company’s documentation lays out the math directly — given the minimum cacheable length (M), the original prefix length (L), the read multiplier (r = 0.1), the write multiplier (w = 1.25), and the number of times a prefix will be reused (N), the break-even original length is:
L(break-even) = M × (r + (w − r) / N)
Using OpenAI’s own worked example, with a 1,024-token minimum, that crossover works out to roughly 102.4 + 1,177.6/N tokens. Reuse a prefix ten times, and expanding anything over about 221 tokens up to the minimum becomes worthwhile; reuse it heavily, and the crossover drops toward 102 tokens.
The second question — the one most high-frequency API users are actually asking — is different: what share of my requests can be cache writes before caching stops saving me money at all, compared to not caching? OpenAI hasn’t published an answer to that one directly, so it’s worth deriving from its own numbers. If p is the fraction of requests to a shared prefix that are writes, and (1 − p) the fraction that are reads, the average relative cost compared to paying full price every time is:
p × 1.25 + (1 − p) × 0.1
Setting that equal to 1 (the always-uncached cost) and solving for p gives:
p = (1 − 0.1) / (1.25 − 0.1) = 0.9 / 1.15 ≈ 0.7826, or about 78.3%
That figure has been circulating in developer discussions, and running the algebra against OpenAI’s own published rates confirms it holds up. In plain terms: as long as fewer than roughly 78.3% of the requests to a given cached prefix are fresh writes — equivalently, as long as your cache-hit rate is above about 21.7% — caching comes out cheaper than not caching at all. Cross that threshold, and every additional write pushes your average cost above what you’d have paid with no caching whatsoever. It’s important to be clear that this 78.3% figure is a calculation built from OpenAI’s published multipliers, not a number OpenAI itself has stated — and it’s a simplified model, since real billing tracks token counts rather than a clean write-or-read decision per request.
| Write share | Relative cost vs. uncached | Outcome |
|---|---|---|
| 10% | 0.215× | 78.5% cheaper |
| 30% | 0.445× | 55.5% cheaper |
| 50% | 0.675× | 32.5% cheaper |
| 70% | 0.905× | 9.5% cheaper |
| 78.3% | ~1.00× | Break-even |
| 85% | 1.0775× | 7.75% more expensive |
| 100% | 1.25× | 25% more expensive |
Worked Examples
A few scenarios, using OpenAI’s own multipliers, show how quickly the math moves in either direction.
Write a prefix once and read it back just once — the lightest possible reuse pattern — and you pay 1.25 + 0.1 = 1.35 units of cost, against 2.0 units for processing it twice without caching. That’s a 32.5% saving, and it’s OpenAI’s own published example.
Write it once and read it nine more times across ten total requests, and the cached cost comes to 1.25 + (9 × 0.1) = 2.15 units, against 10 units uncached — a savings of roughly 78.5%. Again, that’s OpenAI’s figure, not an estimate.
Now flip it: imagine a hypothetical workload where the shared context changes so often that 85% of requests are fresh writes and only 15% land on a cache hit. The average relative cost becomes (0.85 × 1.25) + (0.15 × 0.1) = 1.0775 — about 7.75% more expensive than skipping caching entirely. This scenario is illustrative rather than measured. It reflects the same underlying risk that OpenAI’s own documentation warns about in a related context — that caching content which isn’t reused enough can cost more than not caching at all — though OpenAI’s own named “cache-cost trap” specifically addresses short prompts padded up to the minimum cacheable length, not the high-write-share pattern modeled here.
What Could Change the Result
The 78.3% figure is a clean mathematical threshold, but a handful of practical factors can shift it in a real deployment. The 30-minute time-to-live means a prompt reused only occasionally — say, once every 45 minutes — will always miss the cache, no matter how conceptually “reusable” it is. The 1,024-token minimum rules out caching for shorter prompts altogether. And OpenAI notes that cached states live on individual machines; once traffic to a given cache exceeds roughly 15 requests per minute, some requests can overflow to machines without a matching entry, forcing an unplanned write regardless of how consistent your prompts actually are.
No independently measured, large-scale data on real-world Luna cache-hit rates in production was available for this piece. OpenAI’s own documentation offers two example figures — a 70% cache-hit rate for a single-turn evaluation workflow and above 90% for a multi-turn agent — but the company explicitly labels both as hypothetical illustrations rather than measured deployment results.
How Luna Compares to Anthropic and Google on Caching
The three major providers approach cache pricing quite differently, based on independent reporting (none of the figures below come from Anthropic’s or Google’s own pricing pages directly examined for this piece, so treat them as directional rather than exact).
| Provider | Caching mechanism | Write cost | Read discount |
|---|---|---|---|
| OpenAI GPT-5.6 Luna | Per-write fee, fixed 30-minute TTL | 1.25× input rate | 0.1× (90% off) |
| Anthropic Claude (reported) | Per-write fee, choice of TTL | 1.25× (5-min) or 2× (1-hour) | 0.1× (90% off) |
| Google Gemini (reported) | Hourly storage fee (explicit) or no-fee implicit caching | No per-write fee; storage billed hourly | ~90% off reads |
Figures for Anthropic and Google are independently reported and were not verified against each provider’s own pricing pages.
Anthropic’s Claude models reportedly use a structurally similar write-premium approach: a 1.25x multiplier for a 5-minute cache, a 2x multiplier if you opt for a 1-hour cache instead, and the same 0.1x read discount as Luna. The meaningful difference is flexibility — Anthropic offers a choice of cache lifetime, where Luna currently offers only the fixed 30-minute window.
Google’s Gemini models, by contrast, reportedly use a different mechanism entirely for explicit caching: rather than a per-write fee, Google charges a separate hourly storage fee for cached content, on top of a roughly 90% discount on reads. Gemini also offers automatic implicit caching with no write fee or storage charge at all, trading control for simplicity. Because the pricing structures aren’t equivalent — a per-event write fee versus a per-hour storage charge — a direct multiplier-to-multiplier comparison with Luna doesn’t translate cleanly.
What’s Still Unresolved
A few open questions are worth tracking. There’s no independently verified data on how frequently real enterprise RAG or agent workloads actually rewrite their cached context, which is the single biggest input into whether the 78.3% threshold is ever crossed in practice. Separately, a community discussion on Microsoft’s developer Q&A forum reported that Luna specifically was returning zero cached tokens on Azure OpenAI as of mid-2026, while the same tests apparently worked for Sol and Terra — an account that hasn’t been independently confirmed as resolved or ongoing.
Conclusion
GPT-5.6 Luna’s caching fee isn’t a discount you get automatically just by turning caching on — it’s a bet that pays off only if your prompts get reused often enough. The math is straightforward once it’s laid out: below roughly a 78.3% write share, caching saves money, climbing toward a maximum of around 78.5% savings at high reuse rates; above that threshold, it costs more than skipping caching altogether. What remains genuinely uncertain is how often typical production workloads actually land on either side of that line, since no independently measured real-world cache-hit-rate data for Luna was available at the time of writing. Anyone deciding whether to build around Luna’s caching should measure their own cached_tokens and cache_write_tokens from actual traffic rather than assume a number — and should keep an eye on whether OpenAI eventually offers more flexible cache lifetimes, as Anthropic already does.
Frequently Asked Questions
How many times must a prompt be reused to offset GPT-5.6 Luna’s 1.25x cache-write fee? Even a single reuse already saves money: one write plus one read costs 1.35 units against 2.0 units uncached, a 32.5% saving, according to OpenAI’s own example. Savings grow with each additional reuse, approaching about 78.5% at ten total requests (one write, nine reads).
Is GPT-5.6 Luna’s prompt caching automatic, or do I need to enable it via the API? Both modes exist. Implicit caching happens automatically, with OpenAI placing a breakpoint at the end of your latest eligible message. Explicit caching requires you to mark specific breakpoints yourself using prompt_cache_breakpoint, giving more control over exactly what gets written to cache.
Does the 1.25x cache-write fee apply every time the cache expires? Yes — once a cached prefix’s 30-minute window lapses without being reused, the next request that needs that prefix triggers a fresh write at the 1.25x rate. Reusing a cache entry before it expires refreshes the 30-minute timer without an additional write charge.
What is the TTL (Time To Live) for cached tokens in GPT-5.6 Luna? 30 minutes, and currently the only supported value for GPT-5.6 and later, set through prompt_cache_options.ttl: “30m”. OpenAI notes it may retain entries longer in practice, but 30 minutes is the guaranteed minimum.
Are the 1.25x/0.1x caching multipliers specific to Luna, or do they apply across GPT-5.6 Sol and Terra too? OpenAI’s documentation describes these multipliers as standard for “GPT-5.6 and later” as a model generation, not as something unique to Luna. What differs between Sol, Terra, and Luna is the base per-token price, not the caching structure itself.
How does GPT-5.6 Luna’s caching pricing compare to Anthropic’s prompt caching? Based on independent reporting, Anthropic uses a similar write-premium approach — 1.25x for a 5-minute cache or 2x for a 1-hour option, with the same 0.1x read discount — but offers a choice of cache lifetime that Luna currently doesn’t.
What is GPT-5.6 Luna’s current price, and has it changed recently? As of this writing, Luna costs $0.20 per million input tokens, $0.02 per million cached input tokens, and $1.20 per million output tokens. That reflects an 80% price cut OpenAI applied on July 30, 2026, three weeks after the model’s July 9 general-availability launch; the original GA-day price was $1.00 input / $6.00 output.