GPT-5.6 Sol vs GPT-5.6 Terra: price and performance compared

Quick answer: the price gap is exactly 2x, the value gap usually is not.

GPT-5.6 Sol and GPT-5.6 Terra sit in the same model family, and their catalog prices differ by precisely a factor of two: $4.00 versus $2.00 per million input tokens, $24.00 versus $12.00 per million output tokens. Cache-read pricing scales by the same factor, and both models sit behind an identical 1.05M-token context window, so nothing about capacity changes between tiers, only the model doing the work. That clean 2x ratio is the easy part. The harder question is whether Sol's answer is worth double on your actual workload, and the honest answer depends on what you are asking for. On short, well-specified, testable tasks (structured extraction, routine code backed by a test suite, log parsing) the cheaper tier usually clears the bar just as reliably, which makes Terra the better price-performance pick by default. On tasks with more room for an incomplete or ambiguous answer (open-ended reasoning, multi-step derivations, anything where a subtly wrong result is expensive to catch later) the extra spend on Sol is more often justified. The rest of this page works through the math and gives you a way to test it on your own prompts instead of guessing. There is also a third tier below Terra, GPT-5.6 Luna, priced lower again and useful as a floor for background or low-stakes calls where even Terra's rate is more than the task warrants. Treating the family as a three-step ladder rather than a binary choice usually beats picking one model for an entire product.

Where the extra price goes: the GPT-5.6 tier ladder.

Inside one model family, the price tier stands in for how much compute the model spends per token, not for a different feature set. Sol, Terra, and Luna accept the same request shape and return completions in the same schema; the difference lives entirely in what happens between receiving your prompt and writing the first token back. Cache pricing follows the same ladder. Sol's cache-read rate is $0.40 per million tokens against Terra's $0.20 and Luna's $0.08, so prompt caching narrows the absolute dollar gap between tiers on repeat-heavy workloads, but it does not change the ratio between them, because every cache rate in this family scales by the identical factor as the base input rate. This step-down pattern is common across model families generally: a flagship tier for the hardest work, a mid tier priced well under it for everyday traffic, and a budget tier for high-volume or background jobs. What is unusual here is how exact the Sol-to-Terra step is; most families widen or narrow the ratio at different points on the rate card, while this pair holds it flat on every metric that matters for billing.

• GPT-5.6 Sol: the top tier, catalog price $4.00 input / $24.00 output per million tokens, official list $5.00 / $30.00.
• GPT-5.6 Terra: the mid tier, catalog price $2.00 input / $12.00 output per million tokens, exactly half of Sol on every rate.
• GPT-5.6 Luna: the budget tier, catalog price $0.80 input / $4.80 output per million tokens, for high-volume or low-stakes calls.
• All three share a 1.05M-token context window and the same /v1/chat/completions surface, so switching tiers is a one-line model-name change, not a migration.

A worked cost example: the same workload on three tiers.

Take a monthly workload of 1,000,000 input tokens with no caching, plus 200,000 output tokens, and price it on each tier at catalog rates. Because Terra's rates are exactly half of Sol's and Luna's are exactly a further step down, the totals line up cleanly: pricing scales in lockstep with the tier, whatever the mix of input and output happens to be. Scale the same ratio up to production volume and the relationship holds. A workload of 50,000,000 input tokens and 10,000,000 output tokens a month prices out to $440 on Sol, $220 on Terra, and $88 on Luna, the same 2x and 2.5x steps as the small example, just with more zeros. That predictability is useful for budgeting: once you know which tier a task category needs, the monthly bill scales linearly with traffic, with no separate discount tiers to track by volume.

Why the realized cost gap can still miss 2x.

The takeaway is that the 2x sticker price is a fixed, provable fact about the rate card, not a prediction about your bill. Your actual cost gap is set by how differently the two tiers respond to your specific prompts, not by the pricing structure itself. That drift can run in either direction. A tighter, more concise reply from the cheaper tier on a task it handles comfortably can push its realized share of the bill below the sticker ratio, while a task near the edge of what Terra can do well may need longer explanations, more tool calls, or a follow-up turn, pushing it above 2x. One request tells you almost nothing either way; a few dozen runs per task category, with token counts and pass/fail logged, is what turns this from a guess into a number you can act on.

• Different tiers rarely produce identical-length answers to the same prompt. The moment completion-token counts diverge, the realized cost ratio drifts away from the clean 2x sticker-price ratio, in either direction.
• A wrong or incomplete answer that needs a retry adds a second billed call. Measure cost per accepted answer, not cost per raw request, or a cheaper tier with a higher retry rate can end up costing more in practice.
• Comparing a discounted catalog price for one tier against an official list price for another exaggerates the gap. Always compare like for like.
• Prompt caching changes the absolute bill on repeat-heavy workloads but not the ratio between tiers in this family, since every cache rate scales by the same factor as the base rate.
• Splitting half the input volume into cached reads still holds the ratio: on the workload above, caching half the input drops Sol to about $7.00 and Terra to about $3.50 total, a ratio of exactly 2.0.

Full price comparison: GPT-5.6 Sol, Terra, and Luna.

The table below lists every published rate for the three-tier GPT-5.6 family. Use it to price out your own token mix instead of relying on the round-number example above. Every rate in the table sits 20% below the corresponding official list price, and that discount applies evenly across all three tiers and both token directions, so it does not change any of the ratios discussed above. Cache-read pricing is the rate that applies once a stable prefix, such as a fixed system prompt or a repeated document, has already been cached; it is not a separate tier and does not apply to the first pass through any given prompt.

How to pick a tier without guessing.

None of this requires committing a whole workload up front. The cheapest way to find your own answer is to run the identical prompt through both model IDs on the same endpoint and compare the outputs directly, which is exactly what the next section sets up. A workable rollout looks like this: pick your three or four most common task categories, route each one to Terra by default, log pass rate and cost per accepted answer for a week, then move only the categories that are failing tests or producing incomplete results up to Sol. Revisit the split periodically rather than treating it as a one-time decision, since prompt changes and task mix shift over time.

• Default routine, testable work (structured extraction, log parsing, code backed by a test suite) to Terra or Luna, and measure the pass rate before assuming you need Sol.
• Reserve Sol for tasks where an incomplete or subtly wrong answer is expensive to catch later: multi-step derivations, ambiguous specs, anything without an automated check.
• Build a small local test suite per task type, a reference answer, a set of unit tests, or both, so "correct" gets measured instead of eyeballed.
• Track latency alongside cost. A cheaper call that runs long under load can cost more in wall-clock time than the dollars it saves.
• Keep the system prompt and tool schema stable across turns so caching actually engages; a prompt that changes on every call never earns the cache-read discount.
• Route the whole ladder, Sol, Terra, and Luna, through one OpenAI-compatible endpoint such as APIsRouter so switching tiers stays a one-line model-name change instead of a second integration.

Test it yourself: same prompt, two model IDs, one endpoint.

Both tiers speak the same OpenAI-compatible chat completions format, so an A/B test is a one-line change to the model field, not a second integration. Point your client at https://api.apisrouter.com/v1, send the identical prompt and max_tokens to gpt-5.6-sol and gpt-5.6-terra, and log the usage block from each response to compute your own realized cost ratio. Run each task a handful of times rather than once, since a single request can land on either side of the average. Record the model field from the response itself, not just the one you requested, so a routing or fallback substitution never gets misread as a result from the model you meant to test.

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",
    base_url="https://api.apisrouter.com/v1",
)

prompt = "YOUR_TEST_PROMPT"

for model in ("gpt-5.6-sol", "gpt-5.6-terra"):
    r = client.chat.completions.create(
        model=model,
        temperature=0.2,
        max_tokens=1200,
        messages=[{"role": "user", "content": prompt}],
    )
    u = r.usage
    print(model, r.choices[0].finish_reason, u.prompt_tokens, u.completion_tokens)

FAQ