GPT-6 Sol and GPT-6 Luna API Guide: Pricing, Integration, and Migration from GPT-5.6

GPT-6 Sol and GPT-6 Luna are the mid-tier and value-tier models in OpenAI's GPT-6 family. They launched on September 22, 2026, at 18:00 UTC — 19 days after GPT-6 Astra. Sol costs $2 per million input tokens and $10 output. Luna costs $0.10 input and $0.50 output. Both represent a 50%+ price cut from their GPT-5.6 predecessors, both support a 1,050,000-token context window with reasoning effort from none to max, and both are available immediately in the API under model IDs gpt-6-sol and gpt-6-luna.

If you are running GPT-5.6 Sol or Luna in production, the migration is a model-name swap with one behavioral difference worth testing: GPT-6 models default to medium reasoning effort and will ask clarifying questions more often than GPT-5.6 did. Everything below — pricing tables, SDK code, caching changes, routing configurations — is sourced from OpenAI's pricing page and model documentation as of September 22, 2026.

One thing to know before you touch a gateway config: TheRouter's catalog does not list openai/gpt-6-sol or openai/gpt-6-luna yet. The routing section below uses only ids the catalog serves today.

GPT-6 Sol and Luna at a Glance

Sources: OpenAI Pricing (retrieved 2026-09-22), Using GPT-6 (retrieved 2026-09-22).

Pricing Deep-Dive: What Changed from GPT-5.6

The headline is simple: 50% off across the board, measured against GPT-5.6's promotional rates.

GPT-5.6 Sol's $4/$20 pricing was already a promotional rate (original launch was higher). GPT-6 Sol at $2/$10 is the new permanent price — not promotional. GPT-5.6 Sol's promotional pricing remains available through at least November 21, 2026, for users who have not yet migrated.

Batch pricing halves the standard rate again: Sol drops to $1.00/$5.00, Luna to $0.05/$0.25. For high-volume offline workloads — classification, extraction, summarization — Luna batch at $0.05 input is effectively free compared to any frontier model.

Long-context pricing kicks in above 272K input tokens: 2x input price, 1.5x output price. Sol long-context input is $4.00 (matching GPT-5.6 Sol's standard rate), and Luna long-context input is $0.20 (matching GPT-5.6 Luna's standard rate). If your prompts routinely exceed 272K tokens, the effective per-token cost is the same as GPT-5.6 at standard pricing — but you get GPT-6 quality.

Model IDs and API Access

Both models are available through the standard OpenAI Responses API and Chat Completions API.

from openai import OpenAI

client = OpenAI()  # uses OPENAI_API_KEY env var

# GPT-6 Sol — strong reasoning for coding, analysis, multi-step tasks
response = client.responses.create(
    model="gpt-6-sol",
    input="Explain how to implement exponential backoff with jitter for API rate limiting.",
)
print(response.output_text)

# GPT-6 Luna — cost-efficient for extraction, classification, summarization
response = client.responses.create(
    model="gpt-6-luna",
    input="Extract the company name, revenue, and YoY growth from this earnings report.",
)
print(response.output_text)

// Node.js / TypeScript
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-sol",
  input: "Write a Python function that implements a circuit breaker pattern.",
});
console.log(response.output_text);

Availability: API access is immediate for all API tiers. ChatGPT Work and Codex are available on Plus, Pro, Business, Enterprise, and Edu plans. Free and Go users get Luna in the desktop app. The models are not yet available in Chat (the web interface).

Reasoning Effort: Tuning Cost and Quality

GPT-6 Sol and Luna both support the full none to max reasoning effort range (Astra does not support none). The default is medium.

# Low-effort call for simple extraction — faster, cheaper
response = client.responses.create(
    model="gpt-6-luna",
    input="Classify this support ticket as billing, technical, or general.",
    reasoning={"effort": "low"},
)

# High-effort call for complex analysis
response = client.responses.create(
    model="gpt-6-sol",
    input="Review this pull request for security vulnerabilities and suggest fixes.",
    reasoning={"effort": "high"},
)

Setting effort to none disables extended thinking entirely — the model responds in a single pass. This is useful for latency-critical tasks where you want deterministic, fast responses without reasoning overhead.

Mid-conversation effort changes are new in GPT-6: you can increase effort for a difficult follow-up question without rewriting your prompt prefix, and the cache stays intact. Add a configuration_update input item to switch effort mid-conversation.

Caching: What Improved in GPT-6

GPT-6 introduces three caching improvements that directly affect cost:

1. Higher default hit rates. OpenAI states that GPT-6 caching yields higher hit rates by default compared to GPT-5.6.
2. Reasoning/tool changes no longer break the cache. In GPT-5.6, changing reasoning_effort or tool definitions could invalidate your cached prefix. GPT-6 preserves the cache across these changes.
3. Explicit cache breakpoints. You can now tell the model where a cached prefix ends, giving you fine-grained control over what gets cached vs. what varies per request.

Cached input pricing is 10% of the standard input price on both Sol and Luna — $0.20 per million tokens on Sol and $0.01 on Luna.

When to Use Sol vs Luna vs Astra

The GPT-6 family maps cleanly to workload complexity:

GPT-6 Astra ($10/$50) — Frontier reasoning. Multi-day software projects, complex agentic workflows, tasks where getting the answer wrong costs more than the token spend. Use when quality is the only constraint.

GPT-6 Sol ($2/$10) — The everyday workhorse. Strong coding, analysis, tool calling, and multi-step reasoning. Sol scores within 1.1 percentage points of Claude Fable 5's highest score on DeepSWE v1.1, at a fraction of the cost. Use for production workloads that need reliable reasoning without frontier pricing.

GPT-6 Luna ($0.10/$0.50) — High-volume, cost-sensitive work. Classification, extraction, summarization, structured output generation, and simple tool calls. Luna scores 66.6% on DeepSWE v1.1 at 93% lower cost per task than Claude Opus 5. Use when you need to process thousands of requests per hour without worrying about cost.

Decision shortcut: If the task would take a senior engineer more than 30 minutes to do manually, start with Sol. If it is a task a junior engineer could do in 5 minutes, start with Luna. If it involves coordinating across multiple tools, browsers, or codebases for hours, use Astra.

Migrating from GPT-5.6

The migration is straightforward: change the model name. The API surface is identical.

- model="gpt-5.6-sol"
+ model="gpt-6-sol"

- model="gpt-5.6-luna"
+ model="gpt-6-luna"

Behavioral differences to test:

1. GPT-6 asks more questions. Astra's "initiative and follow-through" behavior — asking for clarification instead of assuming — carries over to Sol and Luna. If your prompts rely on the model making assumptions, you may need to add explicit instructions like "infer the user's intent and carry the task to completion without asking for clarification."

2. Default reasoning effort is medium. GPT-5.6 also defaulted to medium, so no change here. But GPT-6 at medium effort is more capable than GPT-5.6 at medium effort — you may find that tasks that previously needed high effort now work fine at medium, saving tokens.

3. Knowledge cutoff moved forward. Sol's cutoff is April 20, 2026 (vs February 16 for GPT-5.6 Sol). Luna's cutoff is May 18, 2026. If your prompts reference events between February and May 2026, the model will now have that context built in.

4. Caching is more resilient. If you were careful about not changing reasoning effort or tools mid-conversation to preserve cache hits, you can relax that constraint with GPT-6.

Rollback path: GPT-5.6 Sol and Luna remain available in the API. GPT-5.6 Sol's promotional pricing ($4/$20) runs through at least November 21, 2026. You can run both models in parallel during migration — route a percentage of traffic to GPT-6, compare results, and cut over when confident.

OpenAI-compatible means a provider exposes a chat-completions endpoint whose request and response shape matches the OpenAI API contract closely enough that an unmodified OpenAI SDK call works against it after swapping three values: API key, base URL, and model name. The minimum surface in practice is POST /v1/chat/completions with messages, model, and an OpenAI-shaped streaming response.

Routing Through TheRouter: What the Catalog Serves Today

TheRouter resolves model ids strictly against its catalog: a request for an id that is not listed is rejected with a 404 model_not_found instead of being silently mapped to a different model. As of this update the catalog lists one GPT-6 SKU and both GPT-5.6 tiers this guide migrates from — but not GPT-6 Sol or GPT-6 Luna:

Long-context surcharges above 272K input tokens apply on all three; TheRouter's own rate for each id is on its catalog page (GPT-6 Astra, GPT-5.6 Sol, GPT-5.6 Luna).

So a three-tier stack on TheRouter today is Astra / 5.6 Sol / 5.6 Luna. Point the OpenAI SDK at TheRouter and pick the tier per request:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.therouter.ai/v1",
    api_key="your-therouter-key",
)

TIERS = {
    "frontier": "openai/gpt-6-astra",   # multi-tool, computer-use, hardest tasks
    "workhorse": "openai/gpt-5.6-sol",  # coding, analysis, tool calling
    "value": "openai/gpt-5.6-luna",     # extraction, classification, summarization
}


def ask(tier: str, prompt: str) -> str:
    response = client.chat.completions.create(
        model=TIERS[tier],
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

When openai/gpt-6-sol and openai/gpt-6-luna appear in the model catalog, swapping them in is the same one-line model-name change this guide describes for the direct API. Until then, do not put the GPT-6 Sol or Luna ids in a TheRouter config — they will fail on every request.

Cross-Provider Routing: Sol vs Claude Sonnet 5

GPT-6 Sol at $2/$10 matches Claude Sonnet 5 at exactly $2/$10. At identical pricing, the routing decision comes down to workload fit:

The comparison above is between the two vendors' direct APIs. On TheRouter, the Anthropic side is available as anthropic/claude-sonnet-5 ($2/$10 list, 1M context, 128K max output); the OpenAI side at the same endpoint is openai/gpt-5.6-sol ($4/$20) or openai/gpt-6-astra ($10/$50), because GPT-6 Sol is not in the catalog. Cross-provider fallback is therefore not a zero-cost-delta swap today: pair openai/gpt-5.6-sol with anthropic/claude-sonnet-5 and the fallback leg is the cheaper one. The fallback routing guide shows the ordered-list pattern in SDK code.

Cost Savings: Before and After

Consider a team running 100M input tokens and 20M output tokens per day on GPT-5.6 Sol:

Switch the Luna workloads separately — a team processing 500M input tokens per day on GPT-5.6 Luna:

Batch savings stack: If those Luna workloads can tolerate async processing, batch pricing drops the cost another 50% — to $1,500/month total.

Production Checklist

Before switching production traffic to GPT-6 Sol or Luna:

• Update model IDs in configuration: gpt-5.6-sol to gpt-6-sol, gpt-5.6-luna to gpt-6-luna
• Test with your actual prompts — GPT-6 may ask clarifying questions where GPT-5.6 assumed
• Add "infer the user's intent and carry the task to completion" to system prompts if autonomous behavior is required
• Verify long-context pricing impact if prompts exceed 272K tokens (2x input, 1.5x output)
• Check caching behavior — reasoning effort changes no longer break the cache
• Set up fallback routing: Sol to Luna, or Sol to Claude Sonnet 5 for cross-provider resilience — on TheRouter use catalog ids only (openai/gpt-5.6-sol → anthropic/claude-sonnet-5); openai/gpt-6-sol and openai/gpt-6-luna are not served yet
• Monitor output quality for 24–48 hours before cutting over 100% of traffic
• Keep GPT-5.6 model IDs as rollback targets — they remain available through at least November 2026

FAQ

What are the model IDs for GPT-6 Sol and Luna? Use gpt-6-sol and gpt-6-luna in the model parameter of any OpenAI API request.

Is GPT-6 Sol better than GPT-5.6 Sol? Yes. GPT-6 Sol scores higher on AutomationBench, DeepSWE, and Agents' Last Exam while costing 50% less. The knowledge cutoff is also more recent (April 2026 vs February 2026).

What is the cheapest OpenAI model? GPT-6 Luna at $0.10/$0.50 per million tokens is the cheapest model in the GPT-6 family and the cheapest current-generation OpenAI model. Batch pricing drops this to $0.05/$0.25.

Can I use GPT-6 Sol and Luna with the OpenAI Python SDK? Yes. Install openai >= 1.0.0 and set model="gpt-6-sol" or model="gpt-6-luna". No SDK changes are needed.

When will GPT-5.6 Sol and Luna be deprecated? OpenAI has not announced deprecation dates. GPT-5.6 Sol's promotional pricing runs through at least November 21, 2026. Both models remain available in the API.

Does GPT-6 Luna support reasoning effort? Yes. Luna supports the full none to max range, unlike Astra which does not support none. The default is medium.

Is GPT-6 Sol the same price as Claude Sonnet 5? Yes. Both are $2/$10 per million tokens. At identical pricing, the choice comes down to workload fit and provider reliability.

What is the context window for GPT-6 Sol and Luna? 1,050,000 tokens total, with 922,000 max input and 128,000 max output. Prompts over 272K input tokens incur long-context pricing (2x input, 1.5x output).

Can I route GPT-6 Sol through TheRouter? Not yet. openai/gpt-6-sol and openai/gpt-6-luna are not in TheRouter's catalog, and the gateway rejects unlisted ids with a 404 model_not_found rather than substituting another model. The GPT-6 SKU it serves is openai/gpt-6-astra; the GPT-5.6 tiers are openai/gpt-5.6-sol and openai/gpt-5.6-luna. Check the model catalog for the current list, and see fallback routing for pairing an OpenAI id with anthropic/claude-sonnet-5 through configured providers.

What is new in the GPT-6 API compared to GPT-5.6? Async tool calling (continue reasoning while tools execute), mid-turn steering (send corrections while the model works), configuration updates mid-conversation (change reasoning effort without breaking cache), and improved default cache hit rates.