How to use the GPT-5.6 API: Sol, Terra, and Luna

OpenAI released GPT-5.6 to general availability on July 9, 2026, and API access is self-serve: any API account can call it today, with no waitlist and no plan gating. The limited preview that ran through early July is history. What changed for developers is the shape of the launch itself. Instead of one model, you get three: Sol, Terra, and Luna, each with its own price point, plus six reasoning effort levels and explicit prompt caching controls.

Try Apidog today

That is more decisions than a typical model swap, and the defaults you pick in week one tend to stick. This guide covers model selection, first requests in Python and curl, reasoning effort, caching, the Responses API, and migration from GPT-5.5. For flagship positioning and benchmarks, see the GPT-5.6 Sol overview; this article stays implementation-focused.

By the end, you will have working calls for all three tiers and a repeatable way to compare them using Apidog, so model and cost decisions come from your prompts rather than launch-day claims.

TL;DR

• Use gpt-5.6-sol for deepest reasoning, gpt-5.6-terra for balanced workloads, and gpt-5.6-luna for fast, low-cost tasks. The gpt-5.6 alias routes to Sol.
• API access is self-serve for any OpenAI API account.
• Pricing per 1M tokens: Sol is $5 input / $30 output, Terra is $2.50 / $15, and Luna is $1 / $6.
• Reasoning effort supports none, low, medium, high, xhigh, and max.
• Pro mode is configured with reasoning.mode: "pro" on any tier; it is not a separate model ID.
• Explicit prompt caching uses prompt_cache_options.mode: "explicit" and a ttl. Cache writes cost 1.25x input price, while reads retain a 90% discount.
• When migrating from GPT-5.5, test one reasoning level lower and remove redundant brevity instructions before tuning further.

Choose a model tier

GPT-5.6 uses tier names rather than a single model SKU. Sol, Terra, and Luna are durable capability tiers that will advance independently, as MarkTechPost’s launch coverage describes.

Model ID	Tier	Input / output per 1M tokens	Use it for
gpt-5.6-sol	Flagship	$5 / $30	Deep reasoning, agent orchestration, hard debugging
gpt-5.6-terra	Balanced	$2.50 / $15	Everyday product features and GPT-5.5-class work at lower cost
gpt-5.6-luna	Fast	$1 / $6	Classification, extraction, routing, and first-pass drafting

Sol is the flagship tier. OpenAI reports roughly 53 on Agents’ Last Exam, compared with 46.9 for GPT-5.5. Treat that as a launch-day claim and validate it against your own workload.

Terra is the practical default. OpenAI positions it as competitive with GPT-5.5 at roughly half the cost. Luna is intended for high-volume, latency-sensitive paths where unit economics matter more than deep reasoning.

A useful rollout pattern is:

1. Prototype on Terra.
2. Escalate individual tasks to Sol only when Terra fails measurable quality requirements.
3. Move stable, high-volume tasks to Luna.

For a more detailed cost comparison, see the GPT-5.6 pricing breakdown.

Pin explicit model IDs in production. gpt-5.6 routes to Sol, but gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna make cost and capability choices explicit.

Send your first request

The model IDs below match OpenAI’s developer documentation. You need an OpenAI API key with billing enabled.

Chat Completions

Existing Chat Completions integrations only need a model change:

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {"role": "system", "content": "You are a concise code reviewer."},
        {
            "role": "user",
            "content": "Review this for edge cases: def parse_price(raw): return float(raw.strip('$'))"
        }
    ]
)

print(response.choices[0].message.content)

The same request with curl:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      {
        "role": "user",
        "content": "Explain idempotency keys in one paragraph."
      }
    ]
  }'

Responses API

For new applications, use the Responses API. GPT-5.6 GA features are available there, and reasoning is configured directly in the request:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Summarize the trade-offs between webhooks and polling.",
    reasoning={"effort": "low"}
)

print(response.output_text)

Before committing to a tier, run the same production-shaped prompt through Sol, Terra, and Luna. Compare output quality, response length, latency, and token usage.

Choose a reasoning effort

GPT-5.6 supports six effort levels:

none → low → medium → high → xhigh → max

Use them based on task complexity:

Effort	Recommended tasks
none	Reformatting, deterministic extraction, template filling
low	Simple summaries, routing, straightforward generation
medium	Default for most product features
high	Complex coding, multi-step analysis, difficult debugging
xhigh	High-stakes planning and difficult architectural work
max	Problems where correctness matters more than latency or cost

none disables reasoning. Pairing Luna with none is appropriate for mechanical, high-volume work such as extraction against a clear schema.

Reserve max for tasks where incorrect output is more expensive than slower output, such as subtle concurrency bugs, architecture reviews, or multi-step planning.

Start at medium, then move one level at a time while measuring quality. OpenAI’s migration guidance indicates that many GPT-5.5 workloads can maintain quality one effort level lower on GPT-5.6.

Enable Pro mode

Pro mode is independent of effort. Configure it as:

{
  "reasoning": {
    "mode": "pro"
  }
}

It works across all three tiers and prioritizes answer quality over speed. Use it for quality-first workloads such as legal summaries or incident postmortems.

Set up explicit prompt caching

GPT-5.6 adds explicit cache control. Set prompt_cache_options.mode to "explicit" when a static prompt prefix should be reused:

response = client.responses.create(
    model="gpt-5.6-luna",
    input=[
        {"role": "system", "content": SUPPORT_PLAYBOOK},
        {"role": "user", "content": ticket_text}
    ],
    prompt_cache_options={"mode": "explicit"}
)

Add a ttl field to control how long the cached prefix remains warm. The minimum cache lifetime is 30 minutes. Check OpenAI’s API reference for accepted ttl values and cache breakpoint placement rules.

Calculate whether caching is worth it

Cache economics are:

• Cache writes: 1.25x the normal input-token rate
• Cache reads: 90% discount
• Minimum cache lifetime: 30 minutes

Caching pays off from the second reuse:

• Two uncached prefix passes cost 2.0x.
• One cache write plus one cache read costs 1.35x.

For example, a support bot sending a 40,000-token playbook on every Luna call costs:

• Uncached: $0.04 per call at Luna’s $1 / 1M input tokens
• First cached call: $0.05
• Each cached read: $0.004

Across 100 calls, that static prefix costs $0.45 with caching instead of $4.00 uncached—roughly 89% less.

Use explicit caching for any large static prompt prefix reused at least twice within its TTL.

Use the new Responses API features

Three additions shipped with GPT-5.6 GA in the Responses API:

• Programmatic tool calling: The model writes JavaScript to orchestrate tools rather than emitting one tool call at a time. The code runs in an isolated V8 runtime without network access, allowing loops, branches, and tool-result composition without repeated server round trips.
• Multi-agent, in beta: A request can distribute independent work to subagents in parallel.
• Persisted reasoning: Use reasoning.context to retain reasoning context across turns instead of rebuilding it for every request.

GPT-5.6 also adds original and auto vision-detail settings that preserve original image dimensions. Use OpenAI’s API reference to verify the current request shape for these capabilities.

Migrate from GPT-5.5

Treat migration as a tuning exercise, not only a model ID replacement. If you followed the workflow in the GPT-5.5 API guide, make these changes first.

1. Test one effort level lower

Run each representative GPT-5.5 prompt at its current effort level, then repeat it one level lower on GPT-5.6.

If quality holds, you reduce inference cost without changing application behavior.

2. Remove redundant brevity instructions

GPT-5.6 tends to produce tighter output with fewer generic introductions. Prompts containing instructions such as:

Be concise.
Skip the preamble.
Avoid unnecessary detail.

may overcorrect. Remove them, then test again. Simon Willison’s launch-day write-up provides an independent view of how the family behaves in practice.

3. Benchmark token usage and quality

Track cached-token usage while tuning. Compare a representative task set before moving production traffic.

A useful first target is comparable output quality on Terra at roughly half of GPT-5.5’s cost.

Test GPT-5.6 in Apidog

Curl verifies that an endpoint works. Model selection requires a repeatable comparison setup. Download Apidog and create a small test rig.

1. Create an environment with OPENAI_API_KEY and these model variables:

   MODEL_SOL=gpt-5.6-sol
   MODEL_TERRA=gpt-5.6-terra
   MODEL_LUNA=gpt-5.6-luna

1. Create one POST request to the OpenAI API and reference {{MODEL_SOL}} in the JSON body.

2. Duplicate the request twice and replace the model variable with {{MODEL_TERRA}} and {{MODEL_LUNA}}.

3. Send the same production-shaped prompt through all three requests.

4. Compare output quality side by side and inspect the usage block in each response.

5. Multiply token counts by each tier’s input and output rates to estimate per-request cost using your own prompts.

Use the same saved requests for effort tuning. Change the reasoning.effort value, resend, and track how token counts and output quality change. That produces a practical quality-versus-cost curve for your workload.

FAQ

Is the GPT-5.6 API available to everyone?

Yes. Since July 9, 2026, any OpenAI API account can call all three models self-serve. API access does not depend on a ChatGPT plan. Chat product plans differ: Free and Go users receive Terra, while paid plans unlock the full model picker.

What are GPT-5.6’s context window and knowledge cutoff?

Early documentation coverage reports a 1M-token context window, 128K maximum output, and a February 16, 2026 knowledge cutoff. Confirm these figures against OpenAI’s model page for your account.

What is the difference between Pro mode and Ultra?

Pro mode is an API setting:

{
  "reasoning": {
    "mode": "pro"
  }
}

It works on all three model tiers and trades speed for answer quality.

Ultra is a multi-agent setting that runs four agents in parallel by default. It is available in ChatGPT Work on Pro and Enterprise plans, plus Codex from Plus upward. See the GPT-5.6 Ultra mode breakdown for details.

Should I use Chat Completions or the Responses API?

Existing Chat Completions code continues to work with a model ID swap, so there is no forced rewrite.

For new applications, use the Responses API. Programmatic tool calling, multi-agent support, and persisted reasoning are available there, and OpenAI’s GPT-5.6 documentation centers on it.

Next steps

Start with Terra and one real product prompt at medium effort. Then test the same prompt one effort level lower and compare quality, latency, and token usage.

Enable explicit caching when requests reuse a large static prefix. Then decide whether individual workloads need Sol’s deeper reasoning or Luna’s lower cost and faster responses.

Keep your comparison requests saved. Sol, Terra, and Luna will advance independently, so future evaluations become a rerun of known prompts rather than a new research project. Apidog keeps requests, environments, and token counts together for that workflow.