GPT-5.6 Sol vs Terra vs Luna: pick by task, not by loyalty

The short answer: Terra by default, Sol and Luna at the edges

Use gpt-5.6-terra for almost everything, escalate to gpt-5.6-sol when a task genuinely needs deeper reasoning, and push predictable bulk work down to gpt-5.6-luna. Terra keeps the full 1.05M-token total context window, the 922K maximum input, the 128K output ceiling and the complete reasoning-effort range. At Sol's temporary rates, Terra costs 50% as much for input and 60% for output, which makes it the correct default for coding, production chat and agent loops.

The expensive mistakes sit at both extremes. Running every request on Sol pays flagship rates for work Luna could finish; refusing to leave Luna burns retries on tasks it was never going to complete. Treat the three tiers as one system: Luna drafts the easy volume, Terra does the real work, Sol handles the exceptions.

See also: GPT API pricing: input, cache, output and long context

One family, three meters on the same capabilities

Sol, Terra and Luna are not different products. They share the Responses and Chat Completions surfaces, SSE streaming, text-and-image input with text output, and the same reasoning-effort set — none through xhigh, plus max on the GPT-5.6 line. What changes per tier is capability depth, latency and the meter. All rates below are per 1M tokens; the discounted column is what actually leaves your prepaid balance.

When Sol earns its premium over Terra

Sol is the tier you rent, not the tier you live in. Its premium buys reasoning depth and consistency over long horizons — holding a large diff or a multi-step plan together without drifting. The trigger for escalation should be evidence, not vibes: a failed Terra attempt, a refactor spanning more files than you can hold in your head, or an architecture decision you cannot afford to reverse.

• Multi-file refactors where a missed edge case costs more than the tokens.
• Subtle debugging — race conditions, memory corruption, flaky tests with no obvious cause.
• Architecture and design trade-off analysis, where a bad call dwarfs any token bill.
• A final review pass over Terra-generated diffs before they merge.
• Long autonomous agent runs that must stay coherent across hours of accumulated context.

Because output tokens cost five times input on promotional Sol, the cheapest Sol call is a short one. Feed it a tight, well-scoped prompt — the failing test, the relevant diff, the exact question — rather than an unfiltered codebase dump.

When Luna beats Terra on unit economics

At the temporary Sol rates, Luna costs 5% of Sol input and 6% of Sol output, while remaining a tenth of Terra per token. Any task it completes first try is almost free. Its limits are real, though: depth-sensitive work will fail on Luna and cost you a Terra or Sol retry anyway, which erases the saving. Route to Luna only work that is deterministic, narrow and easy to verify.

• Classification, tagging, routing and intent detection in production traffic.
• Extraction and reformatting — JSON shaping, boilerplate, renames, throwaway scripts.
• Cheap sub-steps inside an agent loop: summarizing a tool result before the main model sees it.
• Latency-sensitive replies where first-token speed matters more than the last points of quality.

Measure the split before committing to it. If more than a small fraction of Luna's output needs a Terra redo, the effective cost of the 'cheap' tier is Luna plus the retry — usually worse than sending the task to Terra directly.

Switching tiers is a one-field change

There is no per-tier signup, plan or endpoint. One apiToken.sale key (it looks like sk-pool-•••) covers Sol, Terra and Luna — plus supported Claude, Gemini and Kimi models — against a single prepaid balance. Routing between tiers is swapping the model ID in the same Responses call:

curl https://router.apitoken.sale/v1/responses \
  -H "Authorization: Bearer $APITOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "input": "Review this diff for regressions."
  }'

Change "gpt-5.6-terra" to "gpt-5.6-sol" or "gpt-5.6-luna" and the same request runs on that tier — same base URL, same Bearer header, same balance. With the official SDK the routing policy is one constructor and a model string:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APITOKEN_API_KEY"],
    base_url="https://router.apitoken.sale/v1",
)

def route(task: str, hard: bool) -> str:
    model = "gpt-5.6-sol" if hard else "gpt-5.6-terra"
    return client.responses.create(model=model, input=task).output_text

The dashboard records settled token usage and the exact discounted charge per request, so you can see what your routing policy actually costs instead of guessing. Confirm the enabled model set any time with GET https://router.apitoken.sale/v1/models — the unified catalog namespaces IDs by provider (anthropic/*, openai/*, google/*).

Full per-model specs and discounted prices →

Caching and the 272K boundary can outweigh the tier choice

Two pricing mechanics move the bill as much as picking the right tier. First, cached input: a repeated prompt prefix bills at the cached rate — $0.40 per 1M on promotional Sol versus $4 fresh, with the same 10% ratio on Terra and Luna — and cache writes bill at 125% of normal input, or $5 per 1M on promotional Sol. In long agent loops that resend the same system prompt and history, a stable prefix compounds into the largest single saving available.

Second, the long-context step: above 272K input tokens the whole request reprices at 2× input and 1.5× output — not just the overflow. At promotional Sol rates, 270K input plus 2K output costs $1.12 official; 273K input plus 2K output costs $2.244. Split oversized contexts or trim history before crossing the boundary, whichever tier you are on.

Reasoning tokens bill as output tokens. Cranking effort to max on promotional Sol means paying $20 per 1M official for deliberate thinking — worth it when the reasoning is the product, waste on mechanical tasks. Match effort to the tier: cheap tiers at high effort are often worse value than a stronger tier at low effort.

A routing policy you can run tomorrow

1. 01Default every workload to gpt-5.6-terra — interactive coding, CI agents and production traffic alike.
2. 02Write down escalation triggers in advance: a failed Terra attempt, a multi-file refactor, or an irreversible design decision goes to gpt-5.6-sol with a tightly scoped prompt.
3. 03Move deterministic high-volume steps — classification, extraction, formatting — to gpt-5.6-luna, and track its redo rate so silent failures do not eat the saving.
4. 04Keep a stable prompt prefix so cached-input rates apply, and keep requests under the 272K long-context boundary.
5. 05Review settled per-request usage in the dashboard weekly and adjust the split by measured cost, not by model-name loyalty.

The flat 50% B2C discount applies identically to all three tiers, so the relative ranking never shifts — Terra is always the cheaper meter than Sol, Luna always cheaper than Terra. There is no subscription and no seat fee: an idle week costs nothing, and a heavy one costs exactly the tokens it consumed at half the official spend.

GPT API pricing: every leg of the bill explained →

OpenAI-compatible quickstart: from curl to the official SDK →

Frequently asked questions

Related guides