AIREITEROpenAI’s GPT-6 Sol and GPT-6 Luna make the headline price easy: Sol is $2 per million input tokens and $10 per million output tokens, while Luna is $0.10 and $0.50. The harder choice is what happens after caching, long prompts, reasoning effort, and failed tasks enter the bill. For high-volume extraction and routing, start with Luna; for general API work, Sol is the more balanced default; keep Astra where one failed multi-step run costs more than the token savings.
The answer depends on task cost, not token price
GPT-6 Sol and GPT-6 Luna are commercial API models released on September 22, 2026. OpenAI lists Sol as the stronger general-purpose option and Luna as the efficient model for focused, repeatable work. Both have a 1.05 million-token context window and 128,000-token maximum output according to the GPT-6 model documentation.
The practical split is straightforward:
| Workload | Starting point | Why |
|---|---|---|
| Classification, extraction, routing, summarization | GPT-6 Luna | Lowest published token price and high throughput |
| Coding agents, tool calls, mixed production traffic | GPT-6 Sol | Much cheaper than Astra without dropping to Luna’s quality tier |
| Failure-sensitive, complex multi-step work | GPT-6 Astra | OpenAI’s own charts still place Astra above Sol and Luna on maximum-effort scores |
That is a routing decision, not a claim that the cheapest model is always the cheapest completed task. A model that needs a retry, misses a field, or makes a bad tool call can erase a large token discount.
GPT-6 Sol and Luna API pricing, line by line
The table below uses the standard rates published in OpenAI’s API pricing documentation, per one million tokens.
| Billing line | GPT-6 Sol | GPT-6 Luna |
|---|---|---|
| Input | $2.00 | $0.10 |
| Cached input | $0.20 | $0.01 |
| Cache write | $2.50 | $0.125 |
| Output | $10.00 | $0.50 |
| Input above 272K tokens | $4.00 | $0.20 |
| Output above 272K tokens | $15.00 | $0.75 |
| Batch/Flex input | $1.00 | $0.05 |
| Batch/Flex output | $5.00 | $0.25 |
| Fast-mode input | $4.00 | $0.20 |
| Fast-mode output | $20.00 | $1.00 |
The API model IDs are gpt-6-sol and gpt-6-luna. Both are available through Responses and Chat Completions, with the usual feature differences documented on their model pages. If an application depends on tool calls with reasoning enabled, check the endpoint and effort combination before changing the model ID; compatibility is part of migration cost.
Compared with the listed GPT-5.6 promotional rates, Sol moves from $4/$20 to $2/$10. Luna moves from $0.20/$1.20 to $0.10/$0.50. The input and cached-input halves are exact; Luna’s output reduction is larger than half. OpenAI’s launch comparison describes the new rates as 50% lower than GPT-5.6 promotional pricing, so treat that comparison as a dated reference.
What changes the invoice
The headline rates hide three billing decisions that matter in production.
Long context is usable, but not cheap
Requests above 272,000 input tokens are billed at the higher long-context rates for the request. The context window is 1.05 million tokens, but a large window is not a free allowance. A 300,000-token Sol request with 20,000 output tokens costs roughly $1.20 for input and $0.30 for output, or $1.50 before other adjustments. The same request on Luna is about $0.06 plus $0.015, or $0.075.
Caching pays after the first reuse
A cache write costs more than a normal input token: $2.50 per million on Sol and $0.125 on Luna. A cached read costs 10% of normal input. For a stable system prompt reused across requests, the first write is followed by much cheaper reads. For one-off prompts, caching does not create a saving by itself.
OpenAI also says GPT-6 caching is more tolerant of changes such as reasoning effort and tool configuration. Measure actual cache-hit rates rather than assuming every similar-looking request shares a prefix.
Batch and Fast mode solve opposite problems
Batch and Flex halve the standard input and output rates, making them suitable for offline classification, bulk extraction, and evaluations that do not need immediate responses. Fast mode doubles the standard rates: it is a latency purchase, not a discount.
For example, a batch job with 10 million Luna input tokens and 1 million output tokens costs $0.50 + $0.25 = $0.75. The same standard job costs $1.00 + $0.50 = $1.50. Fast mode would cost $3.00 for those same token volumes.
Choosing between Luna, Sol, and Astra
GPT-6 Luna is the sensible first test for large queues. The launch data summarized by Digital Applied reports Luna’s best scores below Sol’s on OpenAI’s agent benchmarks, but its per-task costs are dramatically lower. Luna at maximum effort reached 66.6% on DeepSWE in that vendor-reported table for $0.22 per task, while Sol reached 68.8% for $2.74. Those are not universal prices—your prompts and retry policy determine your bill—but they show why Luna belongs in routing and background work.
GPT-6 Sol is the safer general API starting point. Capital & Compute reports that Sol and Claude Sonnet 5 have identical published rates of $2 input, $10 output, and $0.20 cached input. Its independent Intelligence Index comparison favored Sol, but the same page warns that an aggregate benchmark does not measure harness fit. Use Sol when tool use, coding, and output completeness matter enough that Luna’s cheaper errors would be expensive.
GPT-6 Astra remains the escalation path. OpenAI’s own maximum-effort table puts Astra ahead of Sol on AutomationBench, Agents’ Last Exam, FrontierCode, DeepSWE, and OSWorld, while reporting a lower factual-error rate. Those are vendor results, not a guarantee for your workload, but they support keeping Astra behind a failure-triggered fallback rather than routing every request to it.
A real-user discussion shows why this fallback matters. In a Reddit thread about Luna 6 versus Luna 5.6, u/AdmiralMcNugget wrote, “It answered the question you asked. Ask the question you want: ‘What items fit this criteria?’” (thread). That is one user’s experience, not a benchmark result, but it identifies a production check worth adding: test whether the model returns the requested list or merely a technically correct summary.
What the early evidence actually supports
The evidence supports a strong cost thesis and a more cautious capability thesis.
OpenAI’s release materials report that Sol and Luna are cheaper than GPT-5.6 and position Astra as the top model. Digital Applied’s analysis of the launch charts found that GPT-5.6 Sol still scored higher than GPT-6 Sol on two cited charts—DeepSWE and OSWorld—although the newer model cost less per task in the reported setup. Capital & Compute likewise cautions that vendor benchmark harnesses and independent benchmark harnesses are not automatically comparable.
Early user feedback is mixed in the cited discussions. Some API users report that the lower price makes Luna better for their use case; others report shorter or less complete answers and more prompting work. The repeated operational question is not “Which model wins?” but “Does a lower token bill survive retries, missing fields, and tool-call failures?”
Run a small holdout evaluation with three measurements: completed-task cost, required follow-up rate, and critical-error rate. Compare Luna at maximum effort and Sol at xhigh or max against your current model. Keep the benchmark fixed; changing prompts and effort settings at the same time makes the result hard to interpret.
GPT-6 Sol and Luna API FAQ
What is GPT-6 Sol’s API price?
GPT-6 Sol costs $2 per million input tokens, $0.20 per million cached input tokens, and $10 per million output tokens. Cache writes cost $2.50 per million tokens.
What is GPT-6 Luna’s API price?
GPT-6 Luna costs $0.10 per million input tokens, $0.01 per million cached input tokens, and $0.50 per million output tokens. Cache writes cost $0.125 per million tokens.
Which is better for coding agents, GPT-6 Sol or Luna?
Start with Sol when coding quality and tool-call reliability matter. Test Luna for background subagents and repetitive tasks where a lower completed-task cost matters more than frontier capability.
Do GPT-6 Sol and Luna have long-context pricing?
Yes. Above 272,000 input tokens, the published rates rise to $4/$15 for Sol input/output and $0.20/$0.75 for Luna input/output. The full request is subject to the long-context pricing rule.
Are Batch and Flex cheaper?
Yes. OpenAI lists half the standard input and output rates for Batch or Flex processing. They are designed for work that can wait rather than interactive requests.
What should I use first?
Use Luna for high-volume, structured work; Sol for most production API traffic; and Astra for tasks where a failed run is more costly than the price difference. Validate that routing with your own completed-task cost, not token price alone.
The practical call
Move predictable, high-volume work to GPT-6 Luna first. Put GPT-6 Sol behind the same interface for coding and tool-heavy traffic, then retain GPT-6 Astra as an escalation route. That three-tier setup captures the price reduction without assuming that a cheaper token is automatically a cheaper result.