GPT-5.6 Pricing Tier Guide: Luna, Terra, Sol
Published 19 July 2026
OpenAI released GPT-5.6 on July 10 with three distinct pricing tiers: Luna at $1/$6 per 1M tokens, Terra at $2.50/$15, and Sol at $5/$30. This is not a simple speed/quality tradeoff; each tier is positioned for a different class of workload. The question isn't "which is best" — it's "which is right for this task?" This guide maps tasks to tiers, walks through cost-per-task examples, and shows you how to cascade intelligently when a cheaper tier isn't confident enough.
- Luna ($1/$6): classification, simple extraction, high-volume routing
- Terra ($2.50/$15): balanced reasoning, agent loops, multi-turn conversations
- Sol ($5/$30): frontier reasoning, code generation, hard research
- Cache reads save 90%; cache writes cost 1.25× input — break-even at 5+ hits in 30 min
- Batch API adds 50% discount on top of tier pricing for non-interactive work
1. The Three Tiers: Speed, Cost, and Capability
| Tier | Input $/1M | Output $/1M | Cached Read $/1M | Context | Typical Latency |
|---|---|---|---|---|---|
| Luna | $1.00 | $6.00 | $0.10 | 128K | 80–200 ms |
| Terra | $2.50 | $15.00 | $0.25 | 128K | 150–400 ms |
| Sol | $5.00 | $30.00 | $0.50 | 128K | 300–800 ms |
Latency matters: Luna is fastest because it is optimized for streaming, real-time classification, and throughput. Sol is slowest because it performs more internal reasoning. For interactive user-facing workloads, Luna is also cheaper and faster — but only if it's capable enough for your task. This is the key routing decision.
2. Task-Type Routing Table
This table maps common LLM tasks to the tier that minimizes cost-per-successful-response:
| Task Type | Example | Recommended Tier | Success Rate at Tier | Est. Cost/1K Tasks |
|---|---|---|---|---|
| Classification | Spam / not-spam; sentiment (pos/neg/neutral) | Luna | 95–98% | $1.20–$1.50 |
| Structured extraction | Pull name, email, phone from text | Luna | 92–96% | $1.80–$2.40 |
| Categorization (many classes) | Assign one of 50+ product categories | Luna | 88–94% | $2.40–$3.20 |
| Summarization | Condense article or chat log | Luna | 92–97% | $1.50–$2.00 |
| Agent loops (tool use) | Multi-turn: search, reason, refine | Terra | 85–92% | $8.00–$12.00 |
| Multi-turn conversation | Customer support, advisory bots | Terra | 88–94% | $6.00–$10.00 |
| Code generation (simple) | SQL query, Bash snippet, regex | Terra | 80–90% | $10.00–$15.00 |
| Code generation (complex) | Full endpoint, state machine, DSL compiler | Sol | 75–88% | $25.00–$40.00 |
| Research + synthesis | Analyze 10+ papers, synthesize consensus | Sol | 80–90% | $30.00–$50.00 |
| Hard reasoning (novel problem) | Proof verification, novel algorithm design | Sol | 70–85% | $40.00–$70.00 |
Key insight: Cost per task is not just API cost — it is (API cost) / (success rate). A Luna classification with 95% success costs ~$1.26 per successful response. If you route the same task to Sol at 98% success, you pay ~$5.10 per response — but you've solved 3% more of your workload, which may or may not be worth the 4× cost.
3. Cost-Per-Task Worked Examples
Example 1: Spam Classification (Luna)
Task: Classify email as spam (binary yes/no).
Typical token profile: 400 input (email) + 50 output (classification + confidence) = 450 tokens.
Luna cost: (400 × $1/1M) + (50 × $6/1M) = $0.00043/request.
If 96% succeed first attempt: $0.00043 / 0.96 = $0.00045 per successful classification.
At 1M emails/month: $450/month (plus cache discount if you reuse system prompts).
If wrongly routed to Sol: (400 × $5 + 50 × $30) / 1M = $0.0025 per request. At 98% success: $0.00255/successful = $2,550/month (5.7× more).
Example 2: Customer Support Agent (Terra)
Task: Multi-turn support conversation with tool use (ticket lookup, policy search, escalation decision).
Typical token profile per turn: 2,000 input (context + history) + 400 output (response + tool calls) = 2,400 tokens. Average 3 turns to resolve = 7,200 tokens total per ticket.
Terra cost: (2,000 × $2.50/1M) + (400 × $15/1M) = $0.0080/turn or $0.0240 per ticket.
If 90% resolved without escalation: $0.0240 / 0.90 = $0.0267 per successful ticket.
At 10K tickets/month: $267/month.
If used Luna instead: (2,000 × $1 + 400 × $6) / 1M = $0.0044 per turn = $0.0132/ticket. But Luna's agent loop success drops to 65% (tool calls misfire, reasoning is shallow). Cost per successful: $0.0132 / 0.65 = $0.0203. Net savings: $29/month, but 25% of tickets still fail and escalate, raising support cost $400+. Luna doesn't work here.
Example 3: Code Generation (Terra vs Sol)
Task: Generate a Python function from a requirement string.
Typical token profile: 1,500 input (spec + examples) + 600 output (code + explanation) = 2,100 tokens.
Terra cost: (1,500 × $2.50 + 600 × $15) / 1M = $0.0134 per request. At 85% first-pass success (code compiles + passes basic tests): $0.0158 per working function.
Sol cost: (1,500 × $5 + 600 × $30) / 1M = $0.0255 per request. At 90% first-pass success: $0.0283 per working function.
Savings with Terra: 44% cheaper per working result. Use Sol only if the 5% difference in success rate and code quality measurably reduces downstream debugging cost.
4. Cascade & Fallback Routing Pattern
Most FinOps teams shouldn't use a single tier for all work. Instead, implement a cascade pattern: start with the cheapest tier, measure confidence, escalate on low confidence.
| Step | Model | Confidence Threshold | Action if Threshold Not Met |
|---|---|---|---|
| 1 | Luna | Confidence > 85% | Return result |
| 2 | Terra | Confidence > 75% | Return result (escalated) |
| 3 | Sol | Confidence > 60% | Return result or fail explicitly |
| 4 | Human review | — | Escalate to human |
Real scenario: You're doing document classification for invoices (classify by vendor). Luna will return high-confidence results (~94% success) and cost ~$1.20 per 1K. For the 6% of ambiguous invoices where Luna returns confidence < 85%, escalate to Terra (~94% success for hard cases), costing ~$3.75 per 1K escalations. If 6% of 10K documents escalate: 600 × $3.75 = $2.25 extra, total $12 + $2.25 = $14.25/10K. Pure Terra would cost ~$37.50. Cascade saves 62% while improving accuracy on edge cases.
5. Prompt Caching Economics
GPT-5.6 changed caching costs: cache writes now cost 1.25× the uncached input rate (not free), and cache reads cost 10% of input.
| Scenario | Prefix Size | Write Cost | Read Cost (per hit) | Break-Even Hits | Savings @ 10 hits/month |
|---|---|---|---|---|---|
| Luna cached retrieval context | 100K tokens | $0.125 | $0.010 | 15 hits | -$0.025 (loss) |
| Luna cached system prompt + docs | 50K tokens | $0.063 | $0.005 | 8 hits | $0.032 |
| Terra cached agent context | 80K tokens | $0.250 | $0.020 | 14 hits | $0.030 |
| Sol cached reasoning context | 100K tokens | $0.625 | $0.050 | 13 hits | $0.025 |
When to cache: If your prompt includes a stable prefix (system instructions, documentation, few-shot examples) that is reused more than 5–10 times in a 30-minute window, caching usually saves money. Batch API (50% discount) now competes with caching on cost — if you batch classify documents, batch discount beats caching overhead.
6. Comparison with Claude Sonnet 5, Gemini 3.1 Pro, and DeepSeek V4
| Model | Input $/1M | Output $/1M | Speed | Reasoning Capability | When to Pick |
|---|---|---|---|---|---|
| GPT-5.6 Luna | $1.00 | $6.00 | Fast | Instruction following, routing | Classification, extraction, throughput |
| GPT-5.6 Terra | $2.50 | $15.00 | Medium | Moderate reasoning, tool use | Agents, multi-turn, medium code |
| GPT-5.6 Sol | $5.00 | $30.00 | Slow | Frontier reasoning, research | Complex code, hard reasoning, novel problems |
| Claude Sonnet 5 | $2.00–$3.00 | $10.00–$15.00 | Medium–Fast | Strong reasoning, long reasoning tokens | Reasoning, coding (competitive with Sol) |
| Gemini 3.1 Pro | $2.00 | $12.00 | Medium | Multimodal, research capability | Multimodal tasks, competitive with Terra |
| DeepSeek V4 Flash | $0.14 | $0.28 | Very Fast | Basic reasoning, cached input focus | High-volume routing, cache-heavy workloads (7–35× cheaper) |
Cost arbitrage: For simple classification and extraction, DeepSeek V4 Flash is 7–20× cheaper than Luna. Benchmark it against your data — if it hits 90%+ accuracy, use it and pocket the difference. Claude Sonnet 5 is 2× more expensive than Terra but delivers stronger reasoning per model capability claim; use it if your Terra benchmark shows insufficient quality. Gemini 3.1 Pro lands between Luna and Terra — useful if you need multimodal input or are already in the Vertex AI ecosystem.
7. Migration from GPT-5/5.5 & Deprecation Status
OpenAI continues to offer GPT-5.5 ($5/$30, same as Sol) and GPT-5.4 ($2.50/$15, same as Terra) alongside GPT-5.6. There is no deprecation pressure on older models — you can keep using GPT-5.5 if your code targets it. However, GPT-5.6 claims performance parity (or better) at the same tier, so migrate to 5.6 for new deployments.
ChatGPT interface continues to retire older models on a rolling basis (GPT-4o mini, GPT-4 turbo are now read-only); API access is stable. If you build against the API, plan annual reviews of model deprecation status but don't expect urgency.
Cost Measurement Framework
Step 1: Establish baseline by tier
Run a week of traffic and log which tier handled each request. This gives you baseline distribution and cost.
Step 2: Measure confidence scores and fallback rates
For each tier, log returned confidence. Calculate: what % of Luna calls have confidence > 85%? What % cascade to Terra? This tells you if your cascade is balanced.
Step 3: Audit success/failure by tier
Compare model output against ground truth for one week. Which tier underperforms on your data? Adjust thresholds or tier selection based on real accuracy, not OpenAI claims.
Step 4: Calculate true cost per successful response
True cost = (tier_cost) / (success_rate). If Luna costs $1.20 per 1K with 94% success, cost per working response is $1.28. This is the metric to optimize.
Quick Tier Selection Checklist
- Is this a classification, extraction, or routing task? → Luna unless accuracy is critical.
- Does the task involve tool use or multi-turn reasoning? → Terra.
- Is this novel reasoning, complex code, or multi-hop analysis? → Sol (or benchmark Claude Sonnet 5 first).
- Can you implement a cascade (Luna → Terra → Sol)? → Yes, this is usually optimal.
- Is there a stable prefix (system prompt, docs) reused 10+ times/month? → Cache it, measure ROI at break-even (5–15 hits).
- Is this batch or interactive? → Batch work qualifies for 50% discount; recalculate ROI with batch API.
- Have you benchmarked alternatives (Claude, DeepSeek, Gemini)? → Do it on your data, not marketing claims.
Tier selection is a classification problem: match workload properties to tier economics. The ideal is cascade routing — route to Luna first, measure confidence, escalate on uncertainty. This minimizes cost while maintaining quality. FinOps LLM can run a cost audit on your LLM traffic and show you where tier mismatch is leaving money on the table. Book a free audit.
See also: How Much Does GPT-5 Cost? for the full GPT pricing landscape and Hidden LLM Costs for infrastructure and fallback overhead beyond per-token fees.