Disclosure: this guide is compiled from OpenAI’s model documentation, Artificial Analysis benchmark snapshots and third-party reporting. We have not run GPT-6 Luna in a long production deployment. Figures are attributed in the text.
GPT-6 Luna is OpenAI’s small model for the GPT-6 generation, released on September 22, 2026, alongside GPT-6 Sol. OpenAI describes it as its most efficient model for focused, high-volume tasks. At $0.10 per million input tokens and $0.50 per million output tokens, it is also one of the cheapest capable models you can call from a major lab.
Here is the honest summary. GPT-6 Luna is excellent at being cheap and fast at simple things: classification, routing, extraction, summarisation. It is not a coding model, and it is not a reasoning model in any serious sense. Use it as a worker under a bigger model and it will save you real money. Use it as your only model and you will spend the savings on retries.
Table of Contents
- What GPT-6 Luna Is
- GPT-6 Luna Pricing and the 272K Cliff
- Effort Levels, Including None
- GPT-6 Luna Benchmarks by Effort
- GPT-6 Luna vs Haiku 5.5, DeepSeek and Gemini Flash
- The Decisions API
- Seven Smart Ways to Use GPT-6 Luna
- Where GPT-6 Luna Falls Down
- Building a Two-Tier Pipeline With GPT-6 Luna
- What the Price War Means
- Who Should Use What
- FAQ
- Verdict
- Sources and Further Reading

What GPT-6 Luna Is
The GPT-6 lineup has three tiers. GPT-6 Astra is the flagship, GPT-6 Sol is the mid tier, and GPT-6 Luna is the small model. There is no separate Luna Pro; OpenAI offers a Pro mode that spends more per answer instead. The model string is gpt-6-luna.
GPT-6 Luna accepts text and images and returns text. Its knowledge cutoff is May 18, 2026. Several endpoints are not supported: Realtime, Assistants, fine-tuning, embeddings, audio and image generation. If your product depends on any of those, Luna is not a drop-in replacement.
The context window is large for a small model: 1,050,000 tokens in total, with a maximum input of 922,000 and a maximum output of 128,000. The output allowance comes out of the shared window, so in practice you should size prompts against the 922,000 figure, not the headline million.
It is also the named replacement for the GPT-4o and GPT-4.1 snapshots that OpenAI is retiring on January 14, 2027. If you still have legacy traffic on those models, GPT-6 Luna is the migration path OpenAI expects you to take, and you have about two months.
GPT-6 Luna Pricing and the 272K Cliff
GPT-6 Luna pricing is simple at the base and has a few sharp edges above it.
| Item | Per 1M tokens |
|---|---|
| Input (up to 272K) | $0.10 |
| Cached input | $0.01 |
| Output | $0.50 |
| Cache writes, 30-minute | $0.125 |
| Cache writes, 12-hour (added October 20) | $0.25 |
| Batch and Flex | Half of standard |
| Fast mode | Double standard |
| Prompts over 272K tokens | $0.20 input, $0.02 cached, $0.75 output |
The cliff works the same way as Anthropic’s: cross 272,000 input tokens and the higher rate applies to the whole request, not only the excess. The difference is where the line sits. Claude Haiku 5.5 jumps at 100,000 tokens and by five times; GPT-6 Luna jumps at 272,000 and roughly doubles on input. For long documents, that is a big structural advantage.
The cached input price is the other standout. One cent per million tokens means a long, stable system prompt is close to free on repeat calls, and the 12-hour cache option added on October 20 lets that reuse span a working day. Regional data-residency endpoints add 10%.
Against its predecessor, GPT-5.6 Luna, input fell from $0.20 to $0.10 and output from $1.20 to $0.50, cuts of 50% and 58%. Cached input halved too. Context limits and effort levels did not change.
Effort Levels, Including None
GPT-6 Luna supports six effort levels: none, low, medium, high, xhigh and max. Medium is the default. The interesting one is none, which runs Luna as a non-reasoning model. GPT-6 Astra does not accept none, and GPT-6.1 Sol dropped it, so this is a Luna-specific feature.
There is a technical wrinkle with tools. Function calling through the Chat Completions API works only at effort none. Through the Responses API, it works at any effort level. If you are building an agent on Luna with tool calls and reasoning, use Responses.
Effort dramatically changes speed. Artificial Analysis’s late-October snapshot measured time to first chunk at about 0.9 seconds at none, 3.1 seconds at low, 17 seconds at high and around 94 seconds at max. A 94-second wait is fine for a nightly batch and useless for a chat box.
GPT-6 Luna Benchmarks by Effort
Codersera compiled Artificial Analysis Intelligence Index v4.3.2 figures from a snapshot dated October 26, 2026. They show how much the effort dial matters.
| Effort | AA Index | Cost per task | Time to first chunk |
|---|---|---|---|
| max | 38 | $0.07 | about 94 s |
| xhigh | 35 | $0.04 | about 28 s |
| high | 33 | $0.03 | about 17 s |
| medium | 30 | $0.02 | not listed |
| low | 22 | $0.0045 | about 3.1 s |
| none | 18 | $0.011 | about 0.9 s |
Output speed sits around 120 to 129 tokens per second at most levels. The blended price, using Artificial Analysis’s standard mix of cache hits, input and output, works out to $0.08 per million tokens. That is very low.
For perspective, GPT-6.1 Sol scores 52 on the same index at max effort. A 14-point gap is large. Luna at max is a capable model for its price, but it is a different class of tool.
GPT-6 Luna vs Haiku 5.5, DeepSeek and Gemini Flash
| Model (effort) | AA Index | Cost per task | Notes |
|---|---|---|---|
| GPT-6 Luna (max) | 38 | $0.07 | Cliff at 272K, 12-hour cache |
| Claude Haiku 5.5 (max) | 43 | $0.21 | Cliff at 100K, 1-hour cache |
| Claude Haiku 5.5 (high) | 38 | $0.08 | First chunk about 26 s |
| DeepSeek V4.1 Flash (max) | 45 | $0.26 | Open weights, about 169 tok/s |
| GLM-5.3-Flash | 42 | $0.28 | About 75 tok/s |
| Gemini 3.8 Flash (high) | 41 | $3.49 | Cost figure changed during checks |
All figures come from Codersera’s compilation of Artificial Analysis data. The takeaway is that GPT-6 Luna is the cheapest per task in this group by a wide margin, and the least capable at its best setting. Haiku 5.5 at high effort matches Luna’s max-effort score at almost the same cost and much faster, which is a real point in Anthropic’s favour.
DeepSeek V4.1 Flash is the most capable model here and has open weights, so you can self-host it. It costs nearly four times as much per task as Luna at max. Gemini 3.8 Flash’s cost figure is the outlier, and Codersera notes it moved during their checks, so treat it as unreliable.
The Decisions API
The most interesting thing OpenAI shipped alongside GPT-6 Luna is not the model but the Decisions API. It entered public beta on October 6 and reached general availability on October 22, and Luna is the only model it supports.
Instead of free text, the Decisions API returns typed answers: predicate probabilities, choices from a list, or scores. At general availability it accepts up to 400 questions per request. OpenAI claims it is ten times faster than the Responses API for this kind of work. That is a vendor claim with no independent benchmark yet, so test it yourself.
The use case is obvious once you see it. Classification, moderation, scoring and routing do not need prose. They need a label and a confidence. Asking a chat model for JSON and then parsing it is a workaround; the Decisions API makes the workaround unnecessary.
Seven Smart Ways to Use GPT-6 Luna
- Classification and routing. Use the Decisions API, or effort none with structured outputs. Ticket triage, intent detection, spam filtering.
- Extraction from long documents. The 922,000-token input ceiling and the 272K cliff make Luna one of the cheapest ways to pull fields from big files. Stay under 272K to keep the base rate.
- High-volume summarisation. Cap output length; output is five times the input price.
- Cheap worker in an agent loop. Let a larger model plan and judge, and let Luna read files, summarise logs and reformat data.
- Reusing long stable prompts. At $0.01 per million cached tokens, a large fixed preamble costs almost nothing on repeat.
- Batch overnight jobs. Batch and Flex are half price. If latency does not matter, there is no reason to pay full rate.
- Replacing legacy GPT-4o calls. Before January 14, 2027, move those workloads over and pocket the difference.
Where GPT-6 Luna Falls Down
Codersera is blunt about the weaknesses and I agree with all of them. Luna is weak at serious coding. It is not built for hard reasoning; that is what Astra is for. And high effort introduces long latency.
The deeper problem is compounding error in multi-step work. A step that succeeds 90% of the time succeeds only about 35% of the time across ten chained steps. Small models make more per-step mistakes, so agent loops built entirely on Luna degrade fast as tasks get longer. Keep its steps short and independent, or keep a larger model in the loop to check results.
There are also availability gaps. Reports say a rollout to ChatGPT Free and Go users began on October 8, but that comes from a third-party report Codersera could not confirm against OpenAI’s announcement. On Google Cloud, GPT-6 Luna is in private preview for select enterprise customers since October 21, with no general availability date or per-token pricing published.
One more operational change: OpenAI cut its API usage tiers from five to three on October 6. If your rate limits looked different after that date, that is why.
Building a Two-Tier Pipeline With GPT-6 Luna
The most effective way to use GPT-6 Luna is not alone but as the bottom layer of a two-tier system. A larger model handles judgment. Luna handles everything else. The economics only work if you are disciplined about which is which.
Start by listing every model call your product makes and tagging each one with what it actually needs. Most lists split cleanly. A minority of calls require reasoning across many facts, writing that will be read by a customer, or code that must work. The majority are lookups, labels, short summaries and format conversions. That majority is Luna’s territory.
Then measure the escalation boundary. Run a sample of the borderline tasks through both models, and see where Luna’s answers start to diverge. That boundary is where you draw the routing line. Revisit it every time a new model ships, because the line moves.
Keep Luna’s prompts short and specific. Small models degrade faster than large ones when instructions are vague or overloaded. One task per call, an explicit output format and a single worked example usually beat a long list of rules. If you find yourself writing paragraphs of caveats to keep Luna on track, that task probably belongs to the bigger model.
Finally, log cost per task type rather than per model. A dashboard that shows summarisation costing a fraction of a cent and code review costing a dollar tells you exactly where the next saving is. A single monthly total tells you nothing.
What the Small-Model Price War Means for Buyers
Three of the biggest labs now sell a small model at exactly $0.10 per million input tokens and $0.50 per million output. That is not a coincidence. It is a price point the market has settled on, and it tells you something about where competition has moved.
When list prices converge, the real differences hide in the terms. Where does the long-context surcharge kick in, and how much is it? How long does the cache last? Which endpoints are supported? Does the tokenizer count the same text as more or fewer tokens than last year’s model? These details now decide the bill far more than the headline rate.
For buyers, this is good news with a catch. The good news is that switching costs between providers have fallen. Most of these models speak compatible APIs, and a thin wrapper lets you route each task to whichever is cheapest for it this month. The catch is that comparing them properly takes work. A spreadsheet of list prices is useless; you need cost per completed task on your own traffic.
The other shift is that capability per dollar at the small end has improved faster than at the top. A model scoring in the high thirties on Artificial Analysis’s index for a few cents per task would have been a mid-tier model eighteen months ago. That pushes more work down the stack. Jobs that once needed a flagship can now run on a small model, and jobs that once needed a small model can sometimes be replaced by a rule or a regular expression.
It is also a reminder not to sign long commitments at today’s prices. Prices at this tier have fallen by half or more with each generation. A contract that locks in a rate for two years is likely to look expensive within six months.
Who Should Use What
| If you are | Start with | Why | Link |
|---|---|---|---|
| Classifying or scoring at scale | GPT-6 Luna with the Decisions API | Typed answers, lowest cost per task | Read the guide |
| Needing a fast small model for chat | Claude Haiku 5.5 at high | Same score as Luna max, much quicker | See Haiku 5.5 |
| Wanting to self-host | DeepSeek V4.1 Flash | Open weights, higher capability | See specs |
| Doing real coding work | GPT-6.1 Sol | Much higher index score | See Sol |
Related on this site: for more context, see Claude Haiku 5.5, GPT-6.1 Sol and DeepSeek V4.1 Flash.
Frequently Asked Questions About GPT-6 Luna
How much does GPT-6 Luna cost?
$0.10 per million input tokens, $0.01 cached and $0.50 output, for prompts up to 272,000 tokens. Above that, the whole request is billed at $0.20, $0.02 and $0.75.
When was GPT-6 Luna released?
September 22, 2026, alongside GPT-6 Sol. GPT-6 Astra, the flagship, came out earlier in September.
What is the context window?
1,050,000 tokens in total, with up to 922,000 input and 128,000 output. Size your prompts against the input limit, since output shares the window.
Is GPT-6 Luna good at coding?
Not really. It scores 38 on Artificial Analysis’s index at max effort against 52 for GPT-6.1 Sol. Use it for small chores around code, not for writing the code.
What is the Decisions API?
A GPT-6 Luna-only API that returns typed answers such as probabilities, choices or scores instead of free text, with up to 400 questions per request. It became generally available on October 22.
Should I pick Luna or Haiku 5.5?
Luna is cheaper per task and handles long prompts better thanks to the later price cliff. Haiku is smarter per effort level and faster at similar quality. Test both on your real tasks.
Verdict
Use GPT-6 Luna for the large, boring majority of your model calls: labels, routes, extractions and summaries. With $0.01 cached input, a 272K cliff and the Decisions API, it is the cheapest sensible way to run high-volume work from a major lab right now.
The caveat is capability. Luna is the least capable model in its peer group at its best setting, its coding is weak, and its long effort levels are slow. Most of the benchmark figures here come from one independent tester’s snapshot, and several availability claims are unconfirmed.
Next step: move one classification job to the Decisions API, measure cost and accuracy for a week against your current model, and expand from there. If you still have GPT-4o traffic, schedule that migration before January.
Sources and Further Reading
- Codersera: GPT-6 Luna complete guide, for pricing, effort levels and benchmark tables.
- DataCamp: GPT-6.1 Sol, for the mid-tier comparison.
- The New Stack: Haiku 5.5, for the main Anthropic rival.
- DataCamp: DeepSeek V4.1 Flash, for the open-weight alternative.
- Artificial Analysis, for how the Intelligence Index is built.
On this site: read our take on the flagship in GPT-6 Astra, lower spend with LLM API cost optimization, see another small model in GLM-5.3 Flash, and compare the field in AI models compared.


[…] Related on this site: for more context, see GPT-6.1 Sol and GPT-6 Luna. […]
[…] on this site: for more context, see Claude Haiku 5.5, GPT-6 Luna and Copilot AI Credits […]
[…] this site: compare the Decisions API in GPT-6 Luna, see a fast small LLM in Claude Haiku 5.5, cut costs with LLM API cost optimization, and build […]