For the same number and type of tokens, GPT-6 Luna costs one-twentieth as much as GPT-6 Sol on OpenAI's direct API Standard price list. That ratio also holds for the listed long-context rates, but it does not establish which model costs less per completed task. If you use Codex, start with its separate credit rates instead of treating API dollars as your Codex bill. All prices below are the published rates checked on September 23, 2026; confirm the current API table or Codex rate table before budgeting.
API prices: compare the same billing category
These are direct OpenAI API Standard, short-context prices in US dollars per million tokens. “Cached input” is a cache read, while “cache write” has its own rate. Each Luna rate is 5% of the matching Sol rate in the official API pricing table.
| Billed token category | GPT-6 Sol | GPT-6 Luna | Sol ÷ Luna |
|---|---|---|---|
| Input | $2.00 | $0.10 | 20× |
| Cached input | $0.20 | $0.01 | 20× |
| Cache write | $2.50 | $0.125 | 20× |
| Output | $10.00 | $0.50 | 20× |
For a request with 100,000 fresh input tokens and 10,000 output tokens, no cached tokens, and no other charges, the calculation is:
| Model | Input calculation | Output calculation | Request total |
|---|---|---|---|
| Sol | 0.1 × $2.00 = $0.20 | 0.01 × $10.00 = $0.10 | $0.30 |
| Luna | 0.1 × $0.10 = $0.01 | 0.01 × $0.50 = $0.005 | $0.015 |
Use your own input, cached input, cache-write and output counts in the same formula: tokens in each category ÷ 1,000,000 × that category's rate, then add the results. This example compares identical token counts; it is a price-list calculation, not a measured cost for equally good answers.
What changes above 272,000 input tokens?
When a request has more than 272,000 input tokens, the long-context rates apply to the whole request, not just the tokens beyond that threshold. Under Standard pricing, the model notes for Sol and Luna and the price table list:
| Long-context category, per 1M tokens | Sol | Luna |
|---|---|---|
| Input | $4.00 | $0.20 |
| Cached input | $0.40 | $0.02 |
| Cache write | $5.00 | $0.25 |
| Output | $15.00 | $0.75 |
The matched-model ratio remains 20× in each category, but your estimate must use one applicable context tier for the entire request. Do not price the first 272,000 input tokens at short-context rates and only the remainder at long-context rates. Both models list a 1,050,000-token context window; that shared limit does not imply that they produce equivalent results on a long prompt. The Sol and Luna model pages provide the limits and positioning.
Processing mode matters too. The published API rates for Batch and Flex are half the corresponding Standard rates, while Fast is twice Standard. Keep the mode the same on both sides of a comparison, and check that the mode is available for your account and use case on the official model pages.
Codex uses credits, not the API dollar table
If your work happens in Codex, use the Codex Standard token-credit table. Its listed rates per million tokens are:
| Codex Standard category | Sol credits | Luna credits |
|---|---|---|
| Input | 50 | 2.5 |
| Cached input | 5 | 0.25 |
| Output | 250 | 12.5 |
For 100,000 fresh input and 10,000 output tokens, that is 7.5 Sol credits or 0.375 Luna credits using those rates. For a separate example in which all 100,000 input tokens are cached reads, it is 3 Sol credits or 0.15 Luna credits. Neither credit calculation is a dollar quote or a statement about how many requests a subscription includes. Plan allowances and actual model access depend on your plan and account; use your Codex plan's current terms to interpret the result.
Choose by cost per accepted task
The cheaper token rate is a useful starting point for focused, high-volume work. OpenAI positions Luna for that kind of task and Sol for more complex coding and agent work. Those descriptions are product positioning, not a head-to-head quality result. We have not run a controlled comparison showing which model completes your tasks more reliably.
To decide for your own workload, record the same task set and acceptance criteria for both models. Count all billed input categories and output across retries and follow-up turns, plus relevant tool charges or human correction time. Then divide total cost by the number of accepted results. A task that needs many extra Luna attempts may erase its lower per-token price; a task both models finish equally well with similar tokens will favor Luna on the listed model-token rates. This is a decision rule to test, not a claim that either outcome occurs in your workload.
If you are budgeting API usage, take a representative request, classify its tokens, check the 272,000-input threshold and processing mode, and calculate each model with the matching USD rates. If you are budgeting Codex, repeat the exercise with credits and your plan terms. That keeps the comparison tied to the product you actually use.
