GPT-5.6 Pricing: Sol, Terra, Luna, Cache
GPT-5.6 pricing guide for Sol, Terra, Luna, prompt caching, cache writes, cached inputs, and API cost planning.
I usually do the pricing pass after the model registry pass. Model names are easy to copy. Bills are where the mistakes show up. For GPT-5.6 pricing, the useful question is not “which one is cheapest.” It is: which tasks deserve Sol, which can run on Terra or Luna, and how many tokens are being written to cache before any savings appear.
As of publication date, July 10, 2026, OpenAI’s OpenAI pricing page lists GPT-5.6 Sol, Terra, and Luna prices across Standard, Batch, Flex, Priority, short context, long context, cached input, cache writes, and output. Recheck this page before publishing or sending a customer quote. Pricing pages age fast.
GPT-5.6 Pricing Snapshot
Sol, Terra, and Luna standard pricing
As of July 10, 2026, standard short-context prices are listed per 1M tokens:
| Model | Input | Cached input | Cache writes | Output |
|---|---|---|---|---|
gpt-5.6-sol | $5.00 | $0.50 | $6.25 | $30.00 |
gpt-5.6-terra | $2.50 | $0.25 | $3.13 | $15.00 |
gpt-5.6-luna | $1.00 | $0.10 | $1.25 | $6.00 |
This is the first pricing layer I would put in a builder-facing cost model. It keeps the decision clean:
- Sol is the expensive default for complex, high-value work.
- Terra is the middle route when quality matters but cost still has to behave.
- Luna is the low-cost route for repeatable, high-volume work.
GPT-5.6 Sol pricing is easy to underestimate because output costs move quickly. A long answer on Sol can cost more than a much larger prompt on Luna. That sounds obvious until the first retry loop ships.
Long-context standard prices are higher:
| Model | Long input | Long cached input | Long cache writes | Long output |
|---|---|---|---|---|
gpt-5.6-sol | $10.00 | $1.00 | $12.50 | $45.00 |
gpt-5.6-terra | $5.00 | $0.50 | $6.25 | $22.50 |
gpt-5.6-luna | $2.00 | $0.20 | $2.50 | $9.00 |
The pattern is plain. Long-context input and cache-write prices double. Output prices rise by 50%. If a workflow stuffs every document, tool schema, policy block, and conversation history into every call, the model choice is only half the bill. Context discipline is the other half.
Batch, Flex, Priority, and long-context differences
Batch pricing is lower than Standard. OpenAI’s Batch API guide describes async batches as using 50% lower costs, separate higher rate limits, and a 24-hour turnaround. That makes Batch a good fit for evals, offline classification, enrichment, and other jobs that do not need immediate responses.
For GPT-5.6, Batch short-context prices are:
| Model | Batch input | Batch cached input | Batch cache writes | Batch output |
|---|---|---|---|---|
| Sol | $2.50 | $0.25 | $3.13 | $15.00 |
| Terra | $1.25 | $0.13 | $1.56 | $7.50 |
| Luna | $0.50 | $0.05 | $0.63 | $3.00 |
Flex currently tracks the same listed token prices as Batch for GPT-5.6. OpenAI’s Flex processing guide says Flex trades slower response times and occasional resource unavailability for lower costs. I would not use it for a blocking checkout flow, live support assistant, or anything where latency is part of the product promise.
Priority goes the other way. OpenAI’s Priority processing guide describes it as lower and more consistent latency at premium pricing. As of publication date, the pricing page lists short-context Priority prices for GPT-5.6:
| Model | Priority input | Priority cached input | Priority cache writes | Priority output |
|---|---|---|---|---|
| Sol | $10.00 | $1.00 | $12.50 | $60.00 |
| Terra | $5.00 | $0.50 | $6.25 | $30.00 |
| Luna | $2.00 | $0.20 | $2.50 | $12.00 |
I paused here. Priority can make sense for high-value user-facing work. It is a poor fit for evals, ETL, and bursty offline jobs. Those belong in Batch or Flex unless the product has a very specific latency reason.
Prompt Caching Costs
Cache writes and cached input reads
Prompt caching used to feel like a simple discount line. GPT-5.6 makes it more explicit. OpenAI’s prompt caching guide says cache writes for GPT-5.6 models and later families cost 1.25x the uncached input token rate. Reads are reported in cached_tokens. Writes are reported in cache_write_tokens.
That means a cache miss can cost more than a normal input pass if the prefix is written to cache. The write is not bad by itself. It is only bad when nothing later reads from it.
For standard short-context pricing, the cache math looks like this:
| Model | Uncached input | Cache write | Cached read |
|---|---|---|---|
| Sol | $5.00 | $6.25 | $0.50 |
| Terra | $2.50 | $3.13 | $0.25 |
| Luna | $1.00 | $1.25 | $0.10 |
The shape is consistent. Write at 1.25x. Read at 0.1x. The first write is a bet that the same prefix will be reused.
Why cache hit rate changes real cost
A pricing table does not show cache health. Logs do.
If a stable prefix is written once and then read many times, the economics improve quickly. If every request changes the first part of the prompt, the system keeps missing. Then cache writes become a tax.
The prompt caching guide gives two practical constraints that matter for builders:
- caching is available for prompts containing 1,024 tokens or more
- GPT-5.6 models can use
prompt_cache_keyand explicit cache breakpoints for more reliable matching
The order of prompt content matters. Static instructions, examples, tool definitions, schemas, and reusable policy text should appear before dynamic user content. If user-specific data appears first, cache matching gets worse. Found the pattern on the third try. It is usually prompt structure, not the model, that breaks the cache plan.
A useful internal metric is:
cache reads value - cache write cost
Do not report “we use caching” as a savings claim. Report cache write tokens, cached read tokens, cache hit rate, model route, and the before/after cost per completed task.
Cost Planning for API Builders
Route by task value and expected output cost
A simple GPT-5.6 API routing policy can start like this:
| Task type | Default route | Reason |
|---|---|---|
| Complex coding, ambiguous analysis, executive-grade synthesis | Sol | High value, high judgment cost |
| Product assistant, structured reasoning, business workflows | Terra | Balance of quality and cost |
| Classification, extraction, routing, high-volume summaries | Luna | Cost-sensitive and repeatable |
| Offline evals or enrichment | Batch or Flex | Lower cost, slower acceptable |
| Latency-sensitive paid user flow | Priority, usually Terra or Sol | Latency matters enough to pay |
Expected output cost deserves its own estimate. A short prompt with a long answer can be more expensive than a long prompt with a short answer. If the task naturally produces long responses, model routing should look at output tokens first.
For customer-facing tools, I would also separate “attempt cost” from “successful task cost.” Retries, refusals, validation failures, timeout recovery, and follow-up turns all belong in the real unit cost. The model invoice will not explain that for you.
Monitor cache writes, reads, latency, and retries
The minimum cost dashboard should include:
- model ID
- service tier
- input tokens
- output tokens
- cached tokens
- cache write tokens
- retry count
- timeout count
- latency percentile
- cost per successful task
Do not average everything together. Sol support tickets, Luna classifiers, and Batch evals should not live in one blended number. That hides the only thing pricing work is supposed to reveal: which workflow is expensive and why.
For launch planning, I would set three thresholds:
| Signal | Why it matters |
|---|---|
| Output tokens per task jump by 25% | Prompt or product behavior changed |
| Cache write tokens rise without cached reads | Cache strategy is wasting money |
| Retry cost exceeds planned margin | Reliability problem has become pricing problem |
Good enough. That is the most honest assessment I can give: GPT-5.6 cost planning is less about memorizing the table and more about watching where the table gets applied.
FAQ
Who should approve pricing snapshots before launch?
The product owner, engineering owner, and finance or RevOps owner should approve the snapshot. If the product is customer-facing, support should also see the numbers. They will get the first confused ticket when a customer asks why a “cheap” feature is suddenly gated.
What price change should trigger customer notice?
Any change that affects quoted customer economics should trigger review. That includes OpenAI pricing changes, service-tier changes, long-context usage changes, route changes from Luna to Terra or Sol, and cache behavior changes that increase real cost.
For public pricing or enterprise commitments, I would also trigger notice when projected cost per successful task moves beyond the margin buffer set before launch. The exact threshold is business-specific. The rule is not.
How should teams audit cache savings claims?
Start with raw usage fields. Compare cache_write_tokens with cached_tokens, by model and route. Then calculate cost per successful task with and without cached reads.
A valid claim sounds like this: “For this workflow, after the first cache write, repeated calls read 82% of the static prefix from cache and reduced input-token cost by X over the sample period.”
A weak claim sounds like this: “Caching makes GPT-5.6 cheaper.”
The second one is not an audit. It is a hope with a dashboard nearby.
Bottom line: GPT-5.6 pricing should be treated as a dated snapshot. As of July 10, 2026, Sol, Terra, and Luna have clear Standard, Batch, Flex, Priority, cached input, and cache-write prices. The real bill depends on routing, output length, long-context use, cache hit rate, retries, and latency tier. Recheck the OpenAI pricing page before publishing. Then recheck your logs after launch.
Previous posts:
