Claude Sonnet 5.5 vs GPT-6 Luna: 20x per Token, 5–50x per Task

As of October 26, 2026, start with GPT-6 Luna (gpt-6-luna) for short, high-volume calls you can check automatically and for reading long documents, and pay for Claude Sonnet 5.5 (claude-sonnet-5-5) when the work needs more than Luna can reach. That limit is concrete: on Artificial Analysis's Intelligence Index, Luna's best score is 38 at max effort, below Sonnet's 41 at medium, and on terminal-style agentic coding (Terminal-Bench 4.0) Sonnet scores 20.7–63.6% against Luna's 12.6% at most. For mixed traffic, send everything to Luna first and escalate to Sonnet only when a check fails.

The "20x" is the per-token list price: $2 input and $10 output per million tokens for Sonnet against $0.10 and $0.50 for Luna. What you actually pay moves with the workload. Sonnet counts about 1.5 times as many tokens for the same English text, so input costs closer to 30x; above Luna's 272K-token line the gap shrinks to about 10x; and per benchmark task it runs from about 5x, when Sonnet low is matched against Luna's top settings, to 50x when each model runs at its API default. If you switch either way, set Sonnet's thinking and effort explicitly, and move Luna to the Responses API if you use function calling.

The measurements below come from a same-prompt run on October 26, 2026 through one gateway: nine small tasks with hidden tests, a token count of the same article on both models, and a cost recompute at list prices. Direct Anthropic and OpenAI endpoints, tool use and other effort levels are outside that run, so every quality comparison comes from Artificial Analysis.

Claude Sonnet 5.5 and GPT-6 Luna API prices as of October 26, 2026

Claude Sonnet 5.5 charges one flat rate across its full 1M-token context, while GPT-6 Luna has two price bands split at 272,000 input tokens. The table shows USD list prices per million tokens on the standard tier, from Anthropic's Claude API pricing page and OpenAI's API pricing page.

Luna's long-context band isn't a surcharge on the extra tokens. The GPT-6 Luna model page says prompts above 272K input tokens "are priced at 2x input and cache rates and 1.5x output for the full request." Anthropic's page states the opposite rule for Sonnet: "A 900k-token request is billed at the same per-token rate as a 9k-token request." Sonnet's $0.10 cache read took effect on October 7, 2026, replacing $0.20, so comparisons written before then overstate cached workloads; Claude Sonnet 5.5 Cache Read Price Cut to $0.10: What You Save works through that change.

Two smaller multipliers apply on both sides. Anthropic charges 1.1x on all token categories for US-only inference, and OpenAI adds 10% for regional data-residency endpoints. Luna also has a Fast mode at 2x Standard; Anthropic's fast mode covers Opus models only, not Sonnet. Amazon Bedrock, Google Cloud and Microsoft Foundry set their own Claude prices.

Is Claude Sonnet 5.5 worth 20x GPT-6 Luna? The real gap is 5x to 50x

Sonnet 5.5 is worth its premium only for work Luna can't do well enough at any effort level, and the premium you pay for that work is rarely exactly 20x. The multiple changes with what you count: tokens, text, or finished tasks.

Read the last row first. If Luna at xhigh or max clears your quality bar, Sonnet costs about 5–8x more for a similar Artificial Analysis score, and in exchange it finishes each task in a fraction of the time. If your bar sits above 38, no ratio applies, because Luna can't get there at any setting and the real choice is which Sonnet effort level to run. The 50x figure is what you get by leaving both models at their API defaults, and it compares two different quality levels, 47 against 30.

Every effort level: Luna's best score is 38, Sonnet's lowest is 36

Luna's ceiling sits below most of Sonnet's range. On Artificial Analysis's Sonnet 5.5 vs GPT-6 Luna comparison, which runs both models through the same 10 evaluations of Intelligence Index v4.3.2 at every effort level, Luna scores 18 to 38 and Sonnet 36 to 56. Sorted by score, the two ranges overlap only between Sonnet low and Luna's top two settings.

The matched pair is where the comparison gets honest. Sonnet low scores 36 for $0.35 in 85 seconds; Luna xhigh scores 35 for $0.0422 in 215 seconds, and Luna max scores 38 for $0.0678 in 364 seconds. So Luna is 5.2–8.3x cheaper at a similar score, while Sonnet low finishes in 2.5–4.3x less time. At the top, the ratio grows past the price gap because Sonnet max writes 197.4K output tokens per task against Luna's 50.0K, which is how a 20x price becomes an 81x cost.

"Default" also means different things. Sonnet's default effort is high on the Claude API but medium in Claude Code and the Claude apps, while Luna defaults to medium everywhere, so a default-vs-default comparison puts a 47 against a 30. Artificial Analysis's per-task costs for Sonnet fell after the October 7 cache-read cut, from $1.12 to $0.88 at high and from $7.67 to $5.46 at max; older figures near $7.67 predate it.

Sub-benchmarks: Sonnet leads on agents, Luna ties on long context

The headline score hides two opposite results. Sonnet's lead is widest on agentic terminal work and factual recall, while Luna reads long documents as well as Sonnet does at the same effort label. These are Artificial Analysis's numbers from the same comparison page, with low on the left and max on the right.

Terminal-Bench is the clearest split. Luna at max (12.6%) scores below Sonnet at low (20.7%), so for an agent that runs commands and edits files, raising Luna's effort doesn't close the gap. Long-context reasoning goes the other way: from medium up, Luna matches or beats Sonnet at the same label (78.3% vs 76.3% at medium, 83.3% vs 82.7% at max), which makes it the cheaper reader for long documents rather than a weaker one.

AA-Omniscience matters if your application answers factual questions from the model's own memory. Luna's scores run from −22 with reasoning off to 1 at max, meaning it's more likely to give a wrong answer than to abstain, while Sonnet stays between 19 and 32. If you route that kind of work to Luna, give it the source text or a search tool instead of relying on recall.

October 26 test: both models passed 9 of 9, Sonnet cost 25x more

On October 26, 2026, the same nine prompts went to both models through the LaoZhang gateway, and both solved all nine when Sonnet ran with thinking turned on. Sonnet was called in the Anthropic Messages format (/v1/messages) and Luna through Chat Completions (/v1/chat/completions). The tasks were small and well specified, each with tests written before any answer was read: a pricing word problem, merge_intervals, a duration parser, a word counter, a five-bullet summary of a 6,723-word article, an expression evaluator, a CSV line parser, a digit-sum count and SemVer precedence. Each ran once, with no system prompt and no tools, and costs are computed from the token usage each API returned at the list prices above. Total spend was $0.21.

Because both models passed essentially everything, this result shows what the same accepted work costs, not which model is smarter. Sonnet's bill for the nine tasks was 25.4 times Luna's. Luna didn't win by writing less: at medium it produced 6,545 output tokens, 60% of them reasoning, close to Sonnet's 7,802.

The one failure is the reason to set thinking explicitly. Through this gateway, requests that left out thinking and effort came back with no thinking blocks on any of the nine tasks, and in that mode Sonnet read "touching" intervals as integer-adjacent and merged (1, 2) with (3, 4), which the hidden test keeps apart. With thinking: {"type": "adaptive"} and output_config: {"effort": "high"}, thinking blocks came back on 7 of 9 tasks, output rose from 4,896 to 7,802 tokens, and the same task passed. Anthropic's extended thinking docs say that omitting thinking on Sonnet 5.5 already means adaptive thinking at high. The direct API wasn't part of this run, so treat the difference as a reason to send both fields whenever you call Sonnet through a proxy or gateway.

The long article doubled as a tokenizer check. The 6,723-word English text plus a one-line instruction counted 15,335 input tokens on Sonnet 5.5 and 10,106 on Luna, 1.52 times as many; across all nine prompts the ratio was 1.51x. At a 20x per-token price, that puts Sonnet's input bill for the same English text at about 20 × 1.52 ≈ 30x Luna's. Only English was measured, and code or other languages may split differently.

LaoZhang lists both models at the same list prices as Anthropic and OpenAI, and one key reached both in this test; its Claude route caps a single output at 32,768 tokens and has no Message Batches API.

Which is faster: Luna at low effort, Sonnet at matched scores

Neither model is faster across the board, because speed depends on effort and on the route. On Artificial Analysis's measurements against the vendors' own APIs, both stream at similar rates once they start, Luna at 92–140 output tokens per second depending on effort and Sonnet at 105–134. The difference is how long each thinks before and during the answer. Luna low finishes an index task in 18 seconds, faster than any Sonnet setting, but scores 22. At comparable scores Sonnet is quicker: Sonnet low takes 85 seconds per task with 0.98 seconds to first token, against 215 seconds and 19.84 seconds for Luna xhigh.

The route can reverse the picture. Through the same gateway on October 26, Luna was slower on every one of the nine tasks, 128 seconds in total against 71 for Sonnet with thinking, and 33.2 against 13.0 seconds on the expression evaluator. OpenRouter reports its own medians of 106 tokens per second for Sonnet 5.5 and 42 for Luna on its routes, measured differently from Artificial Analysis. If latency is a hard requirement, time both models on the endpoint you'll actually deploy.

What your workload will cost: five cases at list price

For most workload shapes the ratio stays at 20x per token; it drops for long prompts and cached loops and rises once you account for Sonnet's tokenizer. Each figure below is tokens in millions times the rate from the price table, billed in each vendor's own tokens.

You can recompute any row. For case B, Sonnet costs 0.3 × $2 + 0.005 × $10 = $0.65, while Luna, now above 272K, bills the whole request at 0.3 × $0.20 + 0.005 × $0.75 = $0.0638. Case C writes the 100K prefix to cache once, then each of 50 turns reads it and adds 2K new input and 1K output: Sonnet costs 0.1 × $2.50 + 50 × (0.1 × $0.10 + 0.002 × $2 + 0.001 × $10) = $1.45, and Luna 0.1 × $0.125 + 50 × (0.1 × $0.01 + 0.002 × $0.10 + 0.001 × $0.50) = $0.0975. Case D applies both vendors' 50% batch rate.

The token counts are assumptions, not measurements. Only the two tokenizer rows adjust for Sonnet counting the same English text as 1.52x the tokens; output isn't adjusted, because how much each model writes depends on effort and task, and on the nine-task test it was similar. Case C also assumes each turn arrives before the cache expires, which is 5 minutes for Sonnet's cheaper write and 30 minutes for Luna's. The 272K line moves the answer most: a document that stays at 250K keeps the full 20x gap, and one at 300K halves it.

Which to use: Luna for volume and documents, Sonnet for agents

Pick by the shape of the work and the cost of a wrong answer, not by the price ratio alone. Luna is the default wherever a cheap check can catch its mistakes; Sonnet is the default wherever a mistake is expensive to detect or the task needs a score Luna can't reach.

For mixed traffic, routing beats choosing. Send each request to Luna, run the check you would run anyway (tests, schema validation, a grader), and resend failures to Sonnet. At the 25x ratio from the nine-task test, the routed bill is about (1/25 + f) of an all-Sonnet bill, where f is the share you escalate, so escalating 20% costs roughly 24% of sending everything to Sonnet, before the cost of the check and the extra wait on escalated requests. Routing only works when failures are detectable. For agentic coding, where a plausible but broken change can pass a shallow check, start with Sonnet.

If Luna falls short but you'd rather stay with OpenAI, GPT-6 Sol vs Terra vs Luna vs Astra: Which Model Should You Use? covers the larger GPT-6 models and their IDs.

What breaks when you move traffic between Sonnet 5.5 and Luna

Swapping the model ID isn't enough in either direction, because the two APIs handle reasoning and tool calls differently. The contract details below come from the GPT-6 Luna model page and Anthropic's extended thinking docs.

Moving from Sonnet to Luna, the common break is tool calls. Chat Completions accepts Luna's function calling only with reasoning_effort: "none", which also drops its score to 18, so agent code should move to the Responses API, where Luna also gets built-in tools such as web_search, file_search and code_interpreter. Moving from Luna to Sonnet, code that sends a "reasoning off" switch or forces a specific tool fails with a 400. Use between_tools instead of disabled, and use tool_choice: {"type": "auto"} with strict tool use or structured outputs where you used to force the call. Through any proxy, send thinking and output_config.effort on every Sonnet request rather than relying on the documented default.

How to run a cost-per-accepted-task trial before switching

A trial on your own requests answers what no benchmark can: how much each model costs per answer you'd actually keep. It doesn't need to be large, but it does need a pass rule fixed in advance.

1. Pull a sample of real requests, including the ones that fail today and the longest or most tool-heavy ones, and write the pass rule before reading any output: tests pass, extracted fields match checked records, or a grader rubric scores above a set line.
2. Pin every parameter: Luna's reasoning.effort, Sonnet's thinking: {"type": "adaptive"} with output_config.effort, the same output limit and the same tools for both.
3. Run more than one level per model, at least Luna medium, high and xhigh and Sonnet low and medium, because the matched-score pairing is where the price gap is smallest.
4. Log each response's usage (input, cached input, output and reasoning tokens) and wall time, and price it at list rates or your contract rate, retries included.
5. Divide total spend by passing answers to get cost per accepted task for each configuration, then decide between all Luna, all Sonnet, or Luna first with escalation. For routing, measure the share that fails Luna's check and confirm that Luna's cost plus that share of Sonnet's stays well below Sonnet alone.

Claude Sonnet 5.5 vs GPT-6 Luna: other questions

Is there a GPT-6 Luna Pro or a GPT-6.1 Luna?

No. As of October 26, 2026, OpenAI's models index and pricing page list only gpt-6-luna. Forum threads that compare Sonnet 5.5 with "GPT-6 Luna Pro" quote Luna's own price and 1,050K context, so they're describing the same model under another label. The only GPT-6.1 model OpenAI has released is GPT-6.1 Sol.

Which model do free ChatGPT and Claude users get?

ChatGPT's Free and Go plans have run on GPT-6 Luna since October 8, 2026, as covered in Is GPT-6 Free in ChatGPT? Yes, as GPT-6 Luna, Not Sol or Astra. Claude's Free plan includes Sonnet, which is currently Sonnet 5.5, though the plan table doesn't name the version; in the Claude apps it defaults to medium effort and thinking can't be turned off. App plans are billed by subscription, so none of the API ratios above apply to them.

Is there a cheaper Claude model closer to Luna's price?

Claude Haiku 5.5 lists at the same per-token price as Luna for prompts up to 100K tokens, then charges 5x for the whole request, and costs 2.7x Luna per task at defaults; Claude Haiku 5.5 vs GPT-6 Luna: Same Price, 2.7x Cost per Task compares them directly. The same 20x list gap that separates Sonnet from Luna also separates Sonnet from Haiku, which Claude Haiku 5.5 vs Sonnet 5.5: When the 20x Price Gap Pays Off breaks down.