GPT-5.6 Sol vs Terra vs Luna: Choose by Accepted-Output Cost

The practical starting point is simple:

• Choose GPT-5.6 Luna when accepted output is inexpensive to verify and volume dominates.
• Choose GPT-5.6 Terra when both capability and token cost materially affect the workload.
• Choose GPT-5.6 Sol when a failed reasoning or coding result costs more than the model premium.

Those are starting hypotheses, not benchmark verdicts. They follow OpenAI's current positioning of the three models, and your workload can overturn them. Prices and model details in this guide were checked on August 10, 2026; every token price below is an OpenAI direct-API rate in USD per one million tokens.

The real goal is not to find one universally “best” model for speed and accuracy. It is to find the least expensive model that clears your quality threshold once retries and human repair are counted.

Use explicit model IDs before comparing results

An API model ID is not a ChatGPT plan or a label in the ChatGPT interface. This comparison covers only three general-purpose API models: gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna. According to the latest-model guide, the gpt-5.6 alias currently routes to gpt-5.6-sol.

That alias is convenient for exploration, but its target is volatile. Use the explicit ID in a production evaluation, saved test, or deployment where the same name must keep meaning the same tier. Record the returned model identifier as well as the requested one.

This page is deliberately not a full OpenAI model directory. If your primary task is image generation, audio, Realtime, embeddings, or another specialist workload, use the relevant official model catalog instead. It also does not compare ChatGPT subscriptions or Codex credits.

What actually differs among Sol, Terra, and Luna

OpenAI describes Sol as the option for complex reasoning and coding, Terra as the intelligence-cost balance, and Luna as the cost-sensitive, high-volume option. That description suggests where to begin; it does not prove which model will meet your accuracy target.

The three models share large headline limits. The official pages for GPT-5.6 Sol, GPT-5.6 Terra, and GPT-5.6 Luna each list a 1,050,000-token context window, 922,000 maximum input, 128,000 maximum output, a February 16, 2026 knowledge cutoff, text and image input, and text output. Shared limits do not imply equal quality, latency, or throughput.

The compact comparison below uses the official model comparison for context, output, and API support, plus OpenAI's API pricing for the Standard short-context rates. Every price column is USD per one million tokens; the conditions behind those rates are unpacked in the next section.

The tenfold step from Luna to Terra and 2.5-fold step from Terra to Sol apply to each short-context Standard token category in this table. They do not tell you whether a cheaper model will need more attempts or more cleanup.

Calculate the API bill before judging the cheaper model

The current OpenAI API pricing page separates uncached input, cached input, cache write, and output. All four are billed differently. Cache write is 1.25 times the model's uncached input rate, while a cache hit uses the much lower cached-input rate.

A useful per-request calculation is:

text
token cost =
  uncached input tokens × input rate
  + cached input tokens × cached-input rate
  + cache-write tokens × cache-write rate
  + output tokens × output rate

Divide token counts by 1,000,000 before multiplying by the table rates. Add tool charges separately when your request uses a billed tool; the token table is not necessarily your all-in invoice.

The model-price ladder and the service-tier multiplier answer different questions. The 272K long-context rule is separate from both.

The 272K threshold reprices the whole request

When input exceeds 272,000 tokens, long-context pricing applies to the entire request, not only the tokens above 272K. The pricing rules set input at 2 times the short-context rate and output at 1.5 times the short-context rate.

Consider an illustrative Standard request with no cache use, 300,000 input tokens, and 20,000 output tokens:

These numbers show price arithmetic, not expected quality. A request at 270,000 input tokens follows the short-context rates; one at 300,000 input tokens uses the higher rates across all 300,000 input tokens. Measure the actual token categories returned by the API rather than estimating from file size.

Batch, Flex, Standard, and Fast change the rate again

For these models, Batch and Flex token rates are 0.5 times Standard, while Fast is 2 times Standard. Eligible regional processing can add 10% for qualifying models. Availability, queue behavior, latency, and regional eligibility depend on the project and endpoint, so verify them for the environment you will deploy.

On July 30, 2026, OpenAI renamed the public Priority Processing product to Fast. The backward-compatible request value priority may still appear, and an effective response may still report priority. Treat “Fast” as the current public product name; do not assume every response field was renamed with it.

Match the first trial to the cost of failure

The best initial choice depends on what happens when an answer is wrong, incomplete, or too expensive—not on the model name alone.

Start with Luna when verification is cheap

Luna is the sensible first trial for a large classification or extraction queue when most outputs can be checked by schema validation, deterministic rules, or inexpensive sampling. Examples include routing support messages into a stable taxonomy or extracting a short, well-defined field set.

Move up to Terra if the acceptance rate drops enough that retries erase the token savings, or if reviewers repeatedly repair the same semantic mistake. Do not call Luna “faster” without measuring end-to-end latency in your own service tier and region.

Start with Terra when the workload mixes judgment and scale

Terra is a useful first hypothesis for a production assistant or retrieval workflow that needs more judgment than rigid extraction but still runs often enough for token cost to matter. It should not be treated as an automatic default or middle-tier winner.

Move down to Luna if both models clear the same acceptance threshold and Luna's latency is acceptable. Move up to Sol if recurring reasoning failures, poor synthesis, or repair time make Terra more expensive per accepted result.

Start with Sol when failure is the expensive part

Sol is the appropriate first trial for a difficult code migration, multi-step debugging task, or reasoning workflow where an apparently plausible failure creates substantial engineer time or operational risk. Its higher token rate can be rational when it prevents enough retries or repair.

Move down to Terra if it achieves the same acceptance rate and repair burden on representative tasks. Sol's positioning does not guarantee a better result, and paying the premium without measuring task success is not evidence.

Send the same trial through the Responses API

OpenAI's latest-model guidance recommends the Responses API for GPT-5.6 reasoning, tool-calling, and multi-turn workflows, and recommends selecting a model with representative evaluations. Keep the prompt, available context, tool configuration, and acceptance rule fixed while changing only the explicit model ID.

Service tier is a separate control from model tier. After choosing a model ID, you can request Fast with service_tier. The Responses create reference accepts fast or the backward-compatible priority; inspect the effective response because it may still report priority.

bash
curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "service_tier": "fast",
    "input": "Apply our production acceptance criteria to this representative task: ..."
  }'

For a clean model comparison, begin with the same service tier for all three runs. Save the response usage fields, effective service tier, model identifier, wall-clock duration, and your acceptance result. Change gpt-5.6-terra to each explicit ID in turn; avoid the floating gpt-5.6 alias in the comparison.

Decide with cost per accepted task

Per-token price is an input. Accepted-output cost is the decision metric: the total cost of producing results that meet the workload's real quality bar.

Keep, retry, or switch tiers only after token cost and repair effort are attached to accepted results.

Build a small task set from work your system actually receives. It should include common cases, high-cost failures, and boundary cases that distinguish a merely fluent answer from an acceptable one. Define the acceptance rule before running the models so the standard does not drift toward whichever output looks nicest.

For each explicit model ID, record:

• accepted results and rejected results;
• retries required to obtain an accepted result;
• uncached input, cached input, cache-write, and output tokens;
• the effective service tier and total API charge, including applicable tools;
• end-to-end latency, preferably with more than an average;
• human repair minutes needed before the output is usable.

Then calculate:

text
cost per accepted task =
  (all API charges + repair minutes × your labor cost per minute)
  ÷ accepted tasks

Retries already add token charges, while rejected tasks reduce the denominator. That is why a model with a higher listed rate can be cheaper in practice—and why Luna can remain the right choice when its outputs are reliably machine-checkable. Track latency alongside cost rather than assigning a guaranteed speed to any model name. If latency has a business cost, model that cost explicitly instead of hiding it inside a subjective quality score.

Stop once a model clears the predeclared quality threshold across the important task classes and another tier cannot justify its extra accepted-output cost. Choose the lowest-cost model that passes, not the cheapest model before evaluation and not the most expensive model by default.

The next action is concrete: open the official Playground or send the same representative requests through the Responses API using gpt-5.6-luna, gpt-5.6-terra, and gpt-5.6-sol. Record acceptance, retries, token categories, latency, and repair time. The resulting cost per accepted task—not a generic ranking—should decide which GPT-5.6 tier ships.