GPT-5.6 pricing: what Sol, Terra, and Luna cost and how to keep the bill down

OpenAI shipped GPT-5.6 to general availability on July 9, 2026. For the first time, a flagship GPT release arrived as three models with separate prices: Sol for the hardest reasoning at $5 per million input tokens and $30 per million output tokens, Terra at $2.50 and $15, and Luna for high-volume work at $1 and $6. That 5x spread makes model selection one of the biggest levers on your API bill.

Try Apidog today

The naming has a costly trap: the bare gpt-5.6 alias routes to Sol, the flagship reasoning tier. If you copy a quickstart and leave the model ID unchanged, every production request uses flagship pricing—even when Luna would handle the task for one-fifth of the cost.

This guide covers the rate card, request-level cost calculations, cache economics, reasoning-effort costs, and practical routing patterns.

TL;DR

• GPT-5.6 pricing per 1M tokens: Sol $5 input / $30 output, Terra $2.50 / $15, Luna $1 / $6.
• The bare gpt-5.6 alias routes to Sol. Pin gpt-5.6-terra or gpt-5.6-luna unless you explicitly need flagship reasoning.
• OpenAI positions Terra as competitive with GPT-5.5 at roughly half the price, making it the natural migration candidate.
• Prompt-cache writes cost 1.25x the input rate; reads receive a 90% discount. A repeated prefix pays for caching from the second request.
• Higher reasoning effort produces more billable output tokens. Ultra runs four agents in parallel, intentionally multiplying token spend.
• ChatGPT Free and Go plans get Terra; Plus and above can choose among all three models.
• Compare tiers and inspect per-request token usage in Apidog before committing a model ID to production.

The GPT-5.6 rate card

Here is the per-million-token pricing, including derived cache pricing. Cached reads cost 10% of the normal input rate, while cache writes cost 125%.

Model	Input / 1M	Output / 1M	Cached input read / 1M	Cache write / 1M
gpt-5.6-sol (alias: gpt-5.6)	$5.00	$30.00	$0.50	$6.25
gpt-5.6-terra	$2.50	$15.00	$0.25	$3.13
gpt-5.6-luna	$1.00	$6.00	$0.10	$1.25

The model IDs are listed in OpenAI’s developer docs. API access is self-serve for API accounts; there is no API plan gating.

Implementation rule: never use the bare alias

Treat gpt-5.6 as a banned production default unless Sol is intentional. Use the full tier-specific ID in code and environment configuration:

const model = process.env.OPENAI_MODEL ?? "gpt-5.6-terra";

# .env
OPENAI_MODEL=gpt-5.6-terra

Make the tier choice visible in code review:

// Use Luna for high-volume ticket classification.
const model = "gpt-5.6-luna";

What the tiers mean

The number is the generation; Sol, Terra, and Luna are capability tiers that can advance independently.

• Terra is the price-performance default. OpenAI positions it as competitive with GPT-5.5 at roughly 2x lower cost. If you currently run GPT-5.5, start your migration evaluation with Terra. Compare your existing spend with this GPT-5.5 pricing breakdown before migrating.
• Luna is the volume tier. Use it for classification, extraction, routing, structured transformations, and first-pass drafts where request frequency matters most.
• Sol is for tasks that fail on lower tiers. It is the deepest-reasoning option and the most expensive. Simon Willison’s launch-day review provides a practitioner perspective on where the flagship premium is useful.

All three reportedly share a 1M-token context window and 128K maximum output, according to early documentation coverage. Routing down a tier is therefore a reasoning-depth and price tradeoff, not a context-capacity tradeoff.

What requests cost in practice

Per-million-token rates become useful when you apply them to your own request shape.

For a typical RAG request with:

• 10,000 input tokens: system prompt, retrieved context, and user question
• 1,000 output tokens

the cost is:

Model	Input cost	Output cost	Total per request
Sol	$0.050	$0.030	$0.080
Terra	$0.025	$0.015	$0.040
Luna	$0.010	$0.006	$0.016

At low volume, each request looks inexpensive. At scale, routing errors become visible.

For a classification workload with 1 million requests per month, 500 input tokens, and 50 output tokens per request:

• Monthly input: 500M tokens
• Monthly output: 50M tokens

Model	Input	Output	Monthly total
Luna	$500	$300	$800
Terra	$1,250	$750	$2,000
Sol	$2,500	$1,500	$4,000

Running that workload through the bare gpt-5.6 alias costs $4,000 per month. Luna costs $800 for the same token volume. That is a $3,200 monthly difference caused by a model string.

Caching economics, with real math

GPT-5.6 uses explicit cache breakpoints. Enable caching with prompt_cache_options.mode: "explicit" and set a ttl.

{
  "model": "gpt-5.6-terra",
  "input": [
    {
      "role": "system",
      "content": "You are a support triage assistant. Classify each ticket..."
    },
    {
      "role": "user",
      "content": "Ticket #4821: webhook retries firing twice after 502s"
    }
  ],
  "prompt_cache_options": {
    "mode": "explicit",
    "ttl": "30m"
  }
}

Three values determine whether caching helps:

1. Cache writes cost 1.25x the normal input rate.
2. Cache reads receive a 90% discount.
3. The minimum cache lifetime is 30 minutes.

Worked example

Assume a 5,000-token system prompt is reused across 100 requests in the cache window on Sol.

Without caching:

100 requests × 5,000 tokens = 500,000 input tokens
500,000 × $5 / 1M = $2.50

With caching:

One cache write:
5,000 × $6.25 / 1M = $0.031

99 cache reads:
495,000 × $0.50 / 1M = $0.248

Total = about $0.28

That is roughly 89% off the repeated-prefix portion of the bill.

What to cache

Put stable content before the cache breakpoint:

• System prompts
• Tool definitions
• Few-shot examples
• Long policy or product documentation that is reused

Keep volatile content after the breakpoint:

• User input
• Per-request retrieved documents
• Session-specific state
• Data that changes on every call

Caching is useful for chat assistants and support pipelines that reuse a large prefix within 30 minutes. It is usually not useful for nightly batch jobs with no repeated prefix inside the cache window, because every cold start pays the cache-write premium.

Reasoning effort, pro mode, and ultra

GPT-5.6 exposes six reasoning effort levels:

none, low, medium, high, xhigh, max

Reasoning effort is a cost control, not only a quality control. Higher settings produce more output-side tokens, and output is the expensive direction:

• Sol: $30 per million output tokens
• Terra: $15 per million output tokens
• Luna: $6 per million output tokens

Two requests with the same prompt can cost several times more solely because of the effort setting.

Tune effort with an evaluation set

Do not migrate by changing only the model slug. Test your current setting and one lower setting against representative production tasks.

For example:

const testCases = [
  "Classify this support ticket",
  "Extract fields from this invoice",
  "Diagnose this failing API integration",
  "Generate a migration plan from this schema"
];

const efforts = ["medium", "low"];

Measure:

• Task success rate
• Output-token usage
• Latency
• Cost per successful result

If quality holds at the lower setting, keep it. The savings apply to every request.

Pro mode

Pro mode uses reasoning.mode: "pro" and is available on all three models. It is not a separate model SKU. Per-token rates stay the same, but the model can spend more tokens reasoning, so budget for higher output usage on quality-first workloads.

Ultra mode

Ultra runs four agents in parallel by default. It intentionally increases token spend in exchange for faster wall-clock results and higher quality. According to OpenAI, it raises Sol’s Terminal-Bench 2.1 score from 88.8% to 91.9%.

As a starting estimate, budget around four times the tokens of a single-agent run. Reserve Ultra for tasks where time-to-answer and quality matter more than cost per answer. See the GPT-5.6 ultra mode explainer for a deeper breakdown.

Ultra ships in ChatGPT Work on Pro and Enterprise plans, and in Codex from Plus upward.

What ChatGPT plans get

For conversational usage, a ChatGPT subscription may be more economical than API billing. OpenAI’s plan-access documentation maps access as follows:

Plan	GPT-5.6 access
Free / Go	Terra
Plus	Sol, Terra, Luna; per-model effort control, with Sol at medium effort and above
Pro / Business / Enterprise	All three, plus Sol Pro
ChatGPT Work (Pro / Enterprise)	Adds Ultra

Free and Go users defaulting to Terra is notable because it is the tier OpenAI benchmarks against GPT-5.5.

For coding teams comparing Codex seats with raw API spend, Ultra is included with Codex from Plus upward. The Codex pricing breakdown covers that comparison.

Patterns that keep the bill down

The biggest savings usually come from routing discipline, not prompt micro-optimizations.

1. Route by task

Start with a tier policy:

Task type	Recommended model
Classification, extraction, routing	gpt-5.6-luna
General assistant and default production workflows	gpt-5.6-terra
Hard reasoning tasks that fail evaluation on Terra	gpt-5.6-sol

A simple router can begin as explicit application logic:

function selectModel(task: "classify" | "extract" | "general" | "hard-reasoning") {
  switch (task) {
    case "classify":
    case "extract":
      return "gpt-5.6-luna";
    case "hard-reasoning":
      return "gpt-5.6-sol";
    default:
      return "gpt-5.6-terra";
  }
}

Only move work to Sol after your evaluation data shows Terra is insufficient.

2. Pin full model IDs

Do not allow this in production code:

const model = "gpt-5.6";

Use this instead:

const model = "gpt-5.6-terra";

Make model IDs environment variables when you need to test or roll back tiers without redeploying:

OPENAI_MODEL_CLASSIFICATION=gpt-5.6-luna
OPENAI_MODEL_DEFAULT=gpt-5.6-terra
OPENAI_MODEL_REASONING=gpt-5.6-sol

3. Cache long, stable prefixes

If a prefix is several thousand tokens and repeats within 30 minutes, add an explicit cache breakpoint. Caching is already cheaper on the second use of the prefix.

4. Test one lower effort level

For every current effort setting, benchmark the next lower level before shipping. If task quality is unchanged, reduce the setting.

5. Avoid redundant verbosity instructions

GPT-5.6 reportedly produces shorter responses with fewer generic introductions than earlier generations. If your old prompts include repeated instructions such as “be concise” to correct older behavior, verify that they still improve results. Unnecessary boilerplate adds input tokens to every request.

6. Measure with your real prompts

Save each model ID as an environment variable in Apidog, send the same request to each tier, and compare response token-usage fields side by side.

Your actual system prompts, retrieval payloads, tools, and expected output lengths matter more than generic estimates.

FAQ

Is GPT-5.6 cheaper than GPT-5.5?

Terra is the relevant comparison. OpenAI positions it as competitive with GPT-5.5 at roughly 2x lower cost: $2.50 per million input tokens and $15 per million output tokens.

Sol costs more, but it is intended for deeper reasoning. Run your own evaluations before moving quality-sensitive workloads, but Terra halves the GPT-5.5 rate card on price alone.

What does the bare gpt-5.6 model ID cost?

The gpt-5.6 alias routes to Sol:

• $5 per million input tokens
• $30 per million output tokens

Pin gpt-5.6-terra or gpt-5.6-luna explicitly when the task does not require flagship reasoning.

Do reasoning tokens count against output pricing?

Yes. Higher reasoning effort produces more output-side tokens, billed at the output rate. That is $30 per million output tokens on Sol and $6 on Luna.

Benchmark your workload at the current effort setting and one level lower before locking in a default.

What is the cheapest way to start testing GPT-5.6?

Start with gpt-5.6-luna. A request with 10K input tokens and 1K output tokens costs about $0.016.

For setup details, see this guide to using the GPT-5.6 API, which covers authentication, the Responses API request shape, and tier selection.

Where this leaves you

Use Terra as your default model, route high-volume work to Luna, and reserve Sol for tasks that earn its higher output price. Add explicit caching for prefixes reused within 30 minutes, and test one reasoning-effort level lower than your current default.

Before deploying, validate those decisions with your own prompts. Download Apidog, save the three model IDs as environment variables, send identical requests through each tier, and compare token usage in the responses.