How to Route API Calls Across GPT-5.6 Sol, Terra, and Luna

Photo by Douglas Lopes on Unsplash

A clean GPT-5.6 API migration takes about an hour if you already run GPT-5.5, because the three new tiers share your existing key, quota, and endpoint. The work is not authentication. It is deciding which of your calls belong on Sol at $30 output, which drop to Terra at $15, and which survive on Luna at $6, because that routing decision is what separates a bill that shrinks from one that quietly doubles.

This guide walks through the model strings, the pricing math, the routing logic, and the one caching setting that flips the economics.

What Actually Changed at the API Layer

The three models went live on July 9, 2026, and Analytics Vidhya reported that the launch was the first commercial model release to require U.S. Commerce Department clearance before general availability. That regulatory step matters for procurement paperwork, not for your code.

The API surface is deliberately boring. QCode's launch guide confirms the three model strings are gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna, and that they run on the same API key and quota as GPT-5.5 with no credential rotation required. All three share a 1.05M-token context window and a 128K max output ceiling, which corrects the 1.5M figure that circulated during the June preview.

One subtlety trips teams up. Sol Ultra is not a separate billed model. It is Sol's high-compute parallel-subagent mode, invoked through Sol itself, and it bills against Sol's rate card rather than a new SKU.

GPT-5.6 Sol Terra Luna Pricing, in the Only Format That Matters

Output is always six times input. That single ratio is the most useful thing to memorize before you route anything, because Finout's pricing breakdown notes that chat and agentic workloads generating long responses are dominated by output cost, which is why tier selection, not prompt engineering, is where the real savings live.

Here is the rate card per 1M tokens, drawn from Analytics Vidhya's launch coverage:

• Sol: $5 input / $30 output
• Terra: $2.50 input / $15 output
• Luna: $1 input / $6 output
• Sol Fast (Cerebras-served speed tier): $12.50 input / $75 output, up to 750 tokens/sec, roughly 15x standard GPU inference

Two pricing rules apply on top of the sticker rates. Cached input reads carry a 90 percent discount across all three tiers, so a Sol call reusing cached context bills at $0.50 per 1M input tokens instead of $5, per QCode. And regional data residency endpoints add a 10 percent uplift on any model released after March 5, 2026, which Finout confirms covers the entire GPT-5.6 family. If you run in a residency region, price every call as if the rate card were 10 percent higher.

The cheaper-than-it-looks path: Sol holds price parity with GPT-5.5 at $5/$30, so teams that need the top tier can migrate with zero cost increase. Teams that shift workloads down to Terra get a full 50 percent cut against GPT-5.5's rate card on the same call. That is the immediate lever if you want to migrate GPT-5.5 to GPT-5.6 with a budget win on day one.

When to Use GPT-5.6 Terra vs Sol

Terra is the default. Sol is the exception. Reverse that assumption from GPT-5.5, where the flagship was the sensible starting point, because Terra now hits 87.4 percent on Terminal-Bench 2.1 against Sol's 88.8 percent in OpenAI's vendor-reported figures compiled by CasaGBIC, at half the output cost.

Route to Sol when the task is one of three shapes:

• Long-horizon coding agents running multi-file refactors or migrations across a sustained context. Analytics Vidhya positions Sol explicitly for this workload alongside security research and deep scientific analysis.
• Structural code changes at scale. BuildFastWithAI's independent test documented Sol completing a 6,000-line FastAPI plus Postgres RAG service migration from sync SQLAlchemy to async in a single pass in under 9 minutes on the Cerebras endpoint, a task that required three attempts on GPT-5.5.
• Anything where a wrong answer is more expensive than the token spread. The output cost gap between Sol and Terra is $15 per 1M tokens. If a bad response triggers a rerun, a human review cycle, or a production incident, Sol is the cheaper call.

Route to Terra for the rest of production: retrieval-augmented chat, structured extraction, classification, mid-complexity code review, and internal tool orchestration. Route to Luna when latency and volume dominate, and per-call accuracy tolerance is loose: autocomplete suggestions, bulk summarization, first-pass moderation, log triage.

One routing pattern that keeps bills predictable is the cascade. Start every call on Luna. If a downstream validator flags low confidence, retry on Terra. If Terra also fails a schema or evaluator check, escalate to Sol. A three-tier cascade run against real production traffic typically resolves 70 to 85 percent of calls on Luna, which means most of your bill is $6-per-million-output work, not $30.

The Benchmark Number Everyone Is Quoting Wrong

Sol's Terminal-Bench 2.1 lead looks decisive on the marketing chart. It is not, and this is the one thing to read carefully before writing a migration memo.

CasaGBIC's coverage notes that METR, the independent evaluator, flagged benchmark-gaming on the GPT-5.6 Sol launch, meaning the real capability lead over GPT-5.5 is smaller than the headline 88.8 versus 85.6 gap implies. The same source points out that OpenAI's own comparison table places Claude Fable 5 and Claude Mythos 5 ahead of Sol on SWE-Bench Pro. This is a strong launch, not a sweep.

BuildFastWithAI documented a specific failure mode that vendor benchmarks miss: on a race-condition debugging task in a websocket handler, Claude Fable 5 identified the root cause while Sol confidently patched a symptom, twice. Sol is stronger at broad multi-file execution than at deep debugging where the model must reject its first hypothesis. If your workload is diagnostic rather than generative, benchmark that specific pattern before you commit routing weights.

Wire It Up Without Rotating a Single Key

The migration itself is a config change. Assuming you already call GPT-5.5 through the standard OpenAI SDK:

1. Replace the model string. Swap gpt-5.5 for gpt-5.6-terra in your default client and deploy behind a feature flag on 5 percent of traffic.
2. Add a Sol client. Instantiate a second client pinned to gpt-5.6-sol for the specific call sites that match Sol's routing profile.
3. Add a Luna client for high-volume, latency-sensitive paths. Same key, model string gpt-5.6-luna.
4. Turn on prompt caching for any prompt over 1,024 tokens that repeats system instructions or tool schemas. The 90 percent discount on cached input, per QCode, is the biggest single lever after tier selection.
5. Add a per-tier spend cap in your billing dashboard. Sol Fast at $75 output can burn a monthly budget in an afternoon if a runaway agent loops.
6. Log the tier used on every call. You cannot tune a cascade you cannot measure.

Credentials do not change. Rate limits are pooled with GPT-5.5. If your app has locked-down agent sandbox permissions from an earlier hardening pass, those controls carry over untouched.

The One Setting That Catches 80% of Migration Regressions

The most common post-migration bug is not a wrong answer. It is a truncated one.

Teams that hardcoded max_tokens=4096 or max_tokens=8192 against GPT-5.5 will see Terra and Luna respond well within that envelope, then hit a wall when Sol starts producing the longer, more structured outputs it is tuned to generate. Sol's 128K output ceiling is the design target, not the exception. If your response schema expects a full multi-file diff or a long structured JSON payload, raise max_tokens on Sol calls to at least 32,768 and let the model finish. Truncated JSON that fails a parser looks identical to a model regression in your logs, and it will be misdiagnosed as one.

The second common failure is silent context bloat. The 1.05M window invites teams to stuff full document corpora into every call. Input at $5 per 1M on Sol is cheap per token and expensive per request when you multiply it by traffic. Cache the static portion of the prompt, and only pass the delta.

Where the ChatGPT UI Differs From the API

This catches product teams building on top of both surfaces. CasaGBIC documents that Terra and Luna do not appear in the standard ChatGPT chat interface. They surface only in Codex, ChatGPT Work, and the API. Sol powers the Medium, High, and Extra High reasoning modes on eligible paid plans.

The implication for anyone benchmarking through the ChatGPT UI: you are testing Sol, not Terra or Luna. If your production routing sends 70 percent of calls to Terra, no amount of ChatGPT-side testing will surface Terra-specific behavior. Test through the API against the exact model string you plan to deploy. BuildFastWithAI confirms all three tiers are distilled from the same base training run, so behavior is directionally consistent, but the capability floor differs enough on edge cases that UI testing is not a substitute.

For teams already routing across multiple vendors, the launch changes the price-to-capability math against open-weight and Chinese alternatives, an angle covered in more detail in our breakdown of why Chinese AI models cost 5-30x less than GPT and Claude. Terra at $2.50 input closes some of that gap without leaving the OpenAI stack. For broader infrastructure planning around these shifts, the AI Infrastructure articles archive tracks the deployment side.

Once the flag hits 100 percent on Terra and the cascade is logging, the next task is tuning the confidence threshold that promotes calls to Sol. Start at a low escalation rate, watch a week of evaluator scores, then tighten.