GPT-5.6 Pricing Breakdown: What the API Really Costs to Run
OpenAI lists GPT-5.6 at $5/$30 for Sol, $2.50/$15 for Terra, and $1/$6 for Luna per million tokens — but almost nobody running production should pay list. Prompt caching cuts repeated input to a tenth of sticker and Batch mode halves the rest, dropping a realistic workload roughly 48% below the naive bill. Once discounts are in play, the fight with Claude Sonnet 5's $2/$10 intro pricing and Gemini 3.1 Pro's $2/$12 is closer than the stickers suggest. For PMs, the takeaway is that model cost is now an architecture decision, not a procurement one.
Your model bill is now something you engineer, not something you negotiate. The gap between list and effective GPT-5.6 pricing — roughly 48% in the worked example — comes entirely from decisions your team controls: prompt structure, tier routing, batch share, and output caps. Nobody at OpenAI makes those decisions for you, and your finance team can't see them. They just see the invoice. Your concrete move this week: pull your last 30 days of API usage and split spend into four buckets — fresh input, cacheable input, output, and traffic that could tolerate batch latency. Most teams discover the majority of their input tokens are a repeated prefix they never structured for caching, plus a nightly job or two running on Sol's real-time rates for no reason. Restructure prompts so static content leads, move latency-tolerant work to Batch, and check whether the bare gpt-5.6 alias quietly defaulted you onto Sol. To be fair to OpenAI, they've made the discounts automatic where they can: cache pricing applies to repeated prefixes without configuration, and there's no cache storage fee per their docs. But automatic pricing isn't automatic savings — the prefix has to actually repeat, and that's on you. The urgency is the calendar. Claude Sonnet 5's intro pricing ends August 31, 2026, and every vendor is watching who blinks next. Teams that build cost discipline now enter the next price cycle negotiating from strength. Teams that don't just absorb whatever comes.
GPT-5.6 lists at $5/$30 for Sol, $2.50/$15 for Terra, and $1/$6 for Luna per million tokens as of July 2026, per OpenAI's pricing page.
OpenAI's pricing page says GPT-5.6 Sol costs $5 per million input tokens and $30 per million out. That's true, and it's also the least useful way to think about GPT-5.6 pricing. Between prompt caching, the Batch API, and two cheaper tiers sharing the same 1.05M-token context window, a well-routed production workload lands 40-50% below sticker, and I'll show you the arithmetic.
My read: the list price is a starting bid, and teams that treat it as the final number are quietly subsidizing the teams that don't.
If you want the strategy behind the three-tier family, the hub has it. This piece is just about the money.
The list prices, and one expensive default
As of July 2026, per OpenAI's pricing page, the family runs three tiers per million tokens: Sol at $5 in / $30 out, Terra at $2.50 / $15, and Luna at $1 / $6. All three get the same 1.05M context, 128K max output, and the full tool stack. The tiers differ on capability, not plumbing.
Here's the trap that isn't in the launch post: the bare gpt-5.6 alias routes to Sol. If you upgraded from GPT-5.5 by swapping the model string — the path the migration spoke walks through — you defaulted into the most expensive tier without ever deciding to. Whether your workload actually needs Sol is a real question, and the tier guide spoke exists to answer it.
The math below works the same on any tier.
Caching and Batch set the real bill
Two mechanisms move your number more than the tier decision does.
Prompt caching. Cache writes bill at 1.25× the uncached input rate, and cache reads get a 90% discount — $0.50 per million on Sol, $0.25 on Terra, $0.10 on Luna, per OpenAI's docs. If your requests share a long prefix (system prompt, tool definitions, retrieved context), the bulk of your input tokens bill at a tenth of list. The discount applies automatically to repeated prefixes; there's no cache to provision or manage.
Batch and Flex. Anything that doesn't need an answer in seconds — evals, nightly classification, content pipelines — gets 50% off standard short-context rates, and cached input inside those modes bills at 10% of standard input automatically.
Here's what that does to effective rates:
| Tier | List (in / out) | Cached input read | Batch/Flex (in / out) |
|---|---|---|---|
| Sol | $5 / $30 | $0.50 | $2.50 / $15 |
| Terra | $2.50 / $15 | $0.25 | $1.25 / $7.50 |
| Luna | $1 / $6 | $0.10 | $0.50 / $3 |
Think of the pricing page as a hotel's rack rate: it's what you pay walking in at midnight with no reservation. Book ahead — cache ahead, batch ahead — and you pay a different number for the same room.
To be fair to OpenAI, this is a builder-friendly setup. The cache discount kicks in without TTL management or storage fees, 90% off reads sits at the generous end of the market, and a flat 50% batch discount is easy to reason about. The complexity lives in your architecture, not the price sheet.
A realistic month, with the arithmetic shown
Take a plausible mid-size deployment: a support copilot on Sol pushing 100M input and 20M output tokens a month, plus a nightly classification job at 50M in / 5M out.
The naive bill — everything on Sol, no caching, no batching:
- Copilot: 100M × $5 + 20M × $30 = $500 + $600 = $1,100
- Nightly job: 50M × $5 + 5M × $30 = $250 + $150 = $400
- Total: $1,500 a month
The tuned bill. The copilot's requests share a fat prefix, so say 80M of that input lands as cache reads, 1M as cache writes, and 19M stays fresh:
- Cache reads: 80M × $0.50 = $40
- Cache writes: 1M × $6.25 = $6.25
- Fresh input: 19M × $5 = $95
- Output, unchanged: $600
- Copilot total: about $741
The nightly job needs neither Sol nor real-time. On Luna through Batch: (50M × $1 + 5M × $6) × 50% = $40.
Tuned total: roughly $781 a month, 48% below the naive bill, same family, same context window. Run your own volumes through the cost calculator, and if you don't know what your prompts weigh, the token counter will tell you per request.
Notice what never got cheaper: output. At $30 per million on Sol, completions are the stubborn line item. Caching does nothing for them and only Batch touches them.
That hands you the four levers you actually control: prefix design (your cache hit rate), tier routing, the share of traffic you can batch, and output length. Teams that cap max output and enforce terse response formats are pulling the lever everyone else forgets exists.
Where it lands against Claude and Gemini
Against rival list prices, as of July 2026: Anthropic's Claude Sonnet 5 runs $2 in / $10 out on intro pricing through August 31, 2026, then steps up to $3 / $15, per Anthropic's pricing page. Google's Gemini 3.1 Pro is $2 / $12, with a step-up to $4 / $18 above 200K input tokens — a surcharge that quietly bites long-context workloads. Terra at $2.50 / $15 sits squarely in that fight; Sol competes a class up, closer to Claude Opus 4.8 at $5 / $25.
Live numbers move, so check the model tracker before you commit a roadmap to any of them.
One nuance the price table won't show you: Anthropic documents that cache reads don't count against Claude's input rate limits at all, while OpenAI advances accounts through usage tiers 1-5 based on cumulative spend and account age. If you're throughput-constrained rather than budget-constrained, that difference matters more than a dollar per million either way.
Watch for August 31. When Sonnet 5's intro window closes, the mid-tier fight resets, and whether OpenAI answers with a Terra cut will tell you how much pricing pressure they actually feel. But the harder question for your team isn't which model is cheapest this quarter.
It's whether you're building the caching and routing discipline that keeps you cheap after every vendor's intro price expires — because the sticker war is ending, and the discount war is where the next two years of margin live.
Get this in your inbox. AI Rundown Daily delivers original briefings every morning — free. Subscribe →
Frequently Asked Questions
It's an illustration, not a guarantee, and it's sensitive to one assumption: that 80% of the copilot's input tokens hit the cache. That's realistic for assistants with heavy system prompts, tool definitions, and shared retrieved context, but a workload of short, diverse, one-off prompts will cache far less. Output-heavy workloads also save less, because caching never touches the $30-per-million output rate on Sol. The honest move is to run your own traffic mix through a calculator before promising finance anything.
For caching, structurally very little: per OpenAI's docs the discount applies automatically to repeated prompt prefixes, with no cache to provision. The real work is prompt architecture — static content (system prompt, tool definitions, reference docs) must lead the prompt, because any dynamic content placed early breaks the prefix match for everything after it. Batch requires routing latency-tolerant traffic through the Batch API and tolerating delayed completion, which usually means separating real-time and offline workloads in your pipeline. Also audit your model strings: the bare gpt-5.6 alias routes to Sol, the most expensive tier.
The discounts are pricing policy, not contract terms — OpenAI can change the 90% read discount or the 50% batch rate at any point, and predecessor models like GPT-5.5 carried long-context surcharges that show rate structures do shift. Cache writes bill at 1.25× standard input, so a workload whose prefixes rarely repeat can pay slightly more than list, not less. Batch trades latency for money, which is unusable for interactive features. And rate limits scale with OpenAI's usage tiers 1-5, so a spend-optimized account can hit throughput ceilings before budget ceilings.
