OpenAI’s GPT-5.6 family reached general availability on July 9, 2026, and it ships as three models with three prices: Sol, the flagship; Terra, the workhorse; and Luna, the volume tier. All three share a 1-million-token context window and a February 2026 knowledge cutoff. The only real question for anyone building on the API is the routing question: which requests deserve which tier?
We have been running all three since the June preview. Here is the pricing, what each tier is actually for, and the routing mistakes we made so you don’t have to. All figures verified as of 2026-07-17 against the official pricing page.
The pricing table
Per million tokens, standard API rates:
- Sol — $5 input / $30 output. The deepest reasoning, the highest price, and OpenAI’s new state of the art on its agentic coding benchmark.
- Terra — $2.50 input / $15 output. OpenAI positions it as competitive with GPT-5.5 at half the cost, and it is the intended default for production workloads.
- Luna — $1 input / $6 output. The fastest and cheapest, aimed at high-volume, latency-sensitive jobs where flagship reasoning is overkill.
Caching changed with this generation, and it matters for agents: for GPT-5.6 and later, cache writes are billed at 1.25x the model’s uncached input rate, while cache reads keep the 90% discount. Long-running agent loops that re-send stable context benefit enormously from the read discount — but a workload that writes fresh context constantly and rarely re-reads it now pays a premium it did not pay before. Check your cache hit rate before assuming caching saves you money.
Sol: pay for judgment, not for typing
The mistake people make with a flagship model is using it as a better autocomplete. At $30 per million output tokens, Sol is a poor value for producing large volumes of routine text — that is Terra’s job at half the price, or Luna’s at a fifth.
Sol earns its price on requests where being wrong is expensive relative to the tokens involved: architectural decisions, subtle debugging, security-sensitive code, analysis where a shallow answer sends a team down a two-day dead end. These requests tend to be short on output and heavy on thinking, which is exactly the shape that keeps a $30 output rate affordable. A hundred hard questions a day at a few thousand tokens each costs single-digit dollars; the value of getting ten of them right instead of eight is much larger than that.
The corollary: if you cannot articulate why a request needs Sol, it probably doesn’t. “Use the strongest model to be safe” is how API bills triple without output quality moving in any way you can measure.
Terra: the default, and deliberately so
Terra is the tier OpenAI wants you to standardize on, and for once the vendor’s preference matches the user’s interest. Half of Sol’s price is the smaller half of the story; the larger half is that GPT-5.5-class performance was, as recently as this spring, the frontier — and it is now the mid-tier rate.
In our running, Terra handles the broad middle of real work: implementing well-scoped features, summarizing and transforming documents, standard data extraction, most conversational products, code review of ordinary changes. The pattern to notice is specifiability: when you can describe the task precisely, Terra executes it reliably, and Sol’s extra depth mostly buys you nothing.
Terra is also the right starting point when you genuinely do not know which tier a workload needs. Start there, then move individual request types up or down based on observed failures — not on vibes. Moving up because you measured failures is engineering; moving up because the demo felt smarter is budget leakage.
Luna: cheap is a feature, if you gate it
Luna’s numbers — $1 in, $6 out — make whole categories of product economically viable that were marginal a year ago: classification over every incoming ticket, per-item enrichment across large catalogs, first-pass triage of logs, autocomplete-adjacent UX where latency matters more than depth.
The discipline Luna demands is a verification gate. At this tier you will see more shallow misses on anything requiring multi-step reasoning, so the workloads that succeed on Luna share a property: their outputs are cheap to check mechanically. A classifier whose labels feed a human queue, an extractor whose output is validated against a schema, a summarizer whose product is skimmed rather than trusted — all fine. A Luna-powered agent making unreviewed changes is a false economy; you save cents on tokens and pay in cleanup.
Our rule of thumb: route to Luna when a wrong answer costs less than a re-run, and never when a wrong answer costs a customer.
A routing recipe you can copy
- Default everything to Terra. Ship, and log which request types fail or need retries.
- Demote by evidence. Any request type with mechanically checkable output and a low failure cost moves to Luna. Add the check before you move it, not after.
- Promote by evidence. Request types where Terra’s failures are expensive — wrong plans, missed edge cases in critical code — move to Sol. Keep the set small and re-audit it monthly; model updates regularly make yesterday’s Sol-only task a Terra task.
- Mind the cache economics. Structure prompts so stable context (system instructions, reference documents) stays byte-identical across calls to earn the 90% read discount, and watch the 1.25x write rate if your context churns.
- Re-verify prices quarterly. This generation’s rates arrived unchanged from the June 25 preview, but this market reprices constantly. The numbers in this article were checked on 2026-07-17; the official OpenAI pricing announcement and your billing dashboard are the source of truth, not any article — including this one.
A worked example
Numbers make the routing argument concrete. Take a support product handling 10,000 requests a day, averaging 2,000 input and 500 output tokens per request. On Sol, that is $100 for input and $150 for output — $250 a day, roughly $7,500 a month. The same traffic on Terra costs $125 a day, about $3,750 a month. On Luna, $50 a day, about $1,500 a month.
Now apply routing instead of loyalty. Suppose measurement shows 70% of requests are routine (Luna), 25% need the workhorse (Terra), and 5% genuinely need the flagship (Sol). The blended cost lands near $79 a day — roughly $2,360 a month, a third of the all-Terra bill and less than a third of the all-Sol bill, while the hard 5% actually gets better treatment than a single mid-tier model would give it. That last point deserves emphasis: routing is not only a cost play. Sending everything to one model means your hardest requests are underserved and your easiest ones are overserved, and both errors cost you.
When to skip the family entirely
Routing across tiers assumes the API is the right layer at all. Two cases where it is not: if your monthly spend is under about $50, engineering a routing table costs more attention than it returns — pick Terra and move on. And if your workload runs inside a subscription product anyway, flat-rate plans can beat metered pricing for heavy interactive use; do that arithmetic before building billing infrastructure.
The honest bottom line
The GPT-5.6 family is less a product choice than a budgeting instrument: OpenAI has priced the tiers so that routing discipline, not model loyalty, determines your cost curve. Teams that treat “which tier” as a per-request-type engineering decision are seeing meaningfully lower bills than teams that picked one model and moved on. The three-tier structure rewards exactly one habit — measure, then route — and it punishes exactly one habit, which is paying flagship prices for workhorse tasks. Build the routing table once, revisit it monthly, and the family serves you well. For current tier availability on the subscription side, check the official ChatGPT plan pages before assuming API access is the only path.