OpenAI Cut the Cost. Anthropic Answered. Here’s What GPT-6 and Claude Opus 5.5 Really Cost

Current Price Snapshot and Generation Changes

Yesterday's model-cost spreadsheet may already be stale. OpenAI launched GPT-6 Sol and Luna below their GPT-5.6 predecessors' promotional rates. Anthropic answered the same day with Claude Opus 5.5, lower list prices, and a claim that typical workloads cost about 40% less than on Opus 5. The price floor moved again—and the headlines don't show what output, caching, long context, and faster processing will do to your bill.

This is a cross-generation comparison: GPT-5.6 Sol to GPT-6 Sol, GPT-5.6 Luna to GPT-6 Luna, and Claude Opus 5 to Claude Opus 5.5. OpenAI did not cut GPT-5.6 Sol itself to $2; that rate belongs to its successor. The distinction matters for migration tests and cost history.

Rates were checked September 24, 2026 against OpenAI API pricing table and Anthropic's official pricing documentation. Compare more models in the Model Pricing Comparison, or use the September 2026 OpenAI API pricing update for OpenAI-only workload math.

Need one model's full rate card, with batch, cache-write and Fast-mode rates plus price history? See Claude Opus 5.5 API pricing, GPT-6 Sol API pricing and GPT-6 Luna API pricing.

OpenAI's ‘50% cheaper’ headline is only part of the story

OpenAI says Sol and Luna carry 50% lower API prices than GPT-5.6 promotional pricing. That is a fair summary of the generation change, not a promise that every line item moved by exactly half. Sol is tidy: Standard short-context input falls from $4 to $2, cached input from $0.40 to $0.20, cache writes from $5 to $2.50, and output from $20 to $10.

Luna breaks the neat headline. Input falls from $0.20 to $0.10, but output falls from $1.20 to $0.50. The output reduction is ($1.20 - $0.50) / $1.20 = 58.3%. That difference is material for generation-heavy workloads. A monthly job with 20 million input tokens and 100 million output tokens falls from $124 on GPT-5.6 Luna to $52 on GPT-6 Luna—a 58.1% blended reduction under the stated assumptions.

The comparison baseline is GPT-5.6 promotional pricing, not a rewrite of the old model. Read the OpenAI developer announcement and audit the current records on AICostBudget's OpenAI API pricing page.

GPT-6 Sol: the serious price cut is at the generation boundary

GPT-6 Sol's Standard short-context rate is $2 input and $10 output per million tokens, with cached input at $0.20 and cache writes at $2.50. Batch and Flex are half of applicable Standard rates; Fast is twice those rates. The multipliers also apply to long context, so a processing mode without its context tier is not a complete quote.

The boundary is more consequential than the base sticker. OpenAI says prompts with more than 272,000 input tokens bill the entire request at twice the input and cache rates and 1.5 times the output rate. For Sol that means $4 input, $0.40 cached input, $5 cache write, and $15 output under Standard processing. It is not ‘the first 272K at the cheap rate and only the excess at the higher rate.’ Nor is it a total input-plus-output threshold.

The exact threshold and multipliers are stated on the GPT-6 Sol model page. Before migrating, test representative requests on both sides of the boundary instead of multiplying a 100K-token estimate five times and calling it a 500K forecast.

GPT-6 Luna: this is where the price floor really moved

At $0.10 input and $0.50 output per million tokens, Luna shrinks raw token cost for high-volume workloads. Cached input is $0.01 and a cache write is $0.125. Batch or Flex halves those rates; Fast doubles them. Cheap does not mean universally suitable, and a price card cannot prove accuracy or cost per successful task.

Luna has the same >272K input boundary as Sol. Its Standard long-context rates become $0.20 input, $0.02 cached input, $0.25 cache write, and $0.75 output. Even at those rates it is inexpensive by current closed-model standards, but the whole-request jump can double the input side of a large RAG call. Log prompt input before routing; don't infer it from the advertised 1.05M context window.

OpenAI publishes the current limits and tier rule on the GPT-6 Luna model page. Treat Luna as a candidate to evaluate, not as an automatic replacement chosen from price alone.

Claude Opus 5.5: lower list prices, and a bigger workload claim

Claude Opus 5.5 lists at $4 per million input tokens and $20 per million output tokens, down from Opus 5's $5 and $25. That is a 20% list-price reduction on input and 20% on output. Cache reads fall from $0.50 to $0.20, a 60% reduction. Five-minute cache writes cost $5 instead of $6.25, 20% lower; the one-hour Opus 5.5 write costs $8. First-party Fast mode is a separate $8 input / $40 output tier, not a cache charge and not a free latency upgrade.

Anthropic's roughly 40% lower-cost statement describes typical workloads. Its launch post attributes that result to lower token prices plus lower token use, and reports 40–50% lower cost on its agentic coding tasks. It does not say every token category is 40% cheaper. Both facts can be true: the rate card can fall 20% while a model that finishes a task with fewer turns and output tokens cuts the workload bill further.

Anthropic separates those claims in the Claude Opus 5.5 launch post and lists component prices in the Opus 5.5 model documentation. AICostBudget's Anthropic API pricing page keeps the current records and source dates together.

What these prices look like on real monthly workloads

The examples below use Standard, global, short-context API rates. Every OpenAI request is assumed to stay at or below 272K input tokens. They exclude regional uplifts, Batch, Flex, Fast, provider tools, retries, negotiated discounts, and taxes. Each old/new pair holds token volume constant to isolate the published rate change; it does not assume equal model quality or equal tokens per successful task.

*The cache-heavy case uses 10M fresh input tokens, 10M five-minute cache-write tokens, 80M cache-read tokens, and 20M output tokens. It assumes every written prefix is reused as stated. A miss moves tokens back to the uncached category; a rewritten prefix can create another paid write. Opus uses the five-minute write rate in both generations so the comparison does not mix cache lifetimes.

monthly_cost = (fresh_input_M × input_rate)
  + (cache_write_M × cache_write_rate)
  + (cache_read_M × cache_read_rate)
  + (output_M × output_rate)

savings_percent = (old_cost - new_cost) / old_cost × 100

Replace the round examples with your own token and request volume in the AI API Cost Calculator. For a direct old-model/new-model migration, the switch calculator linked below is the faster path.

Cache changes can matter more than the headline

A RAG system, coding agent, or support assistant may resend a large stable prefix: system instructions, tool schemas, repository context, or a knowledge bundle. On GPT-6, an eligible write costs 1.25 times fresh input and a later read costs one tenth. One write plus one full read therefore costs 1.35 times ordinary input, versus twice the input cost for processing the same prefix uncached twice. The saving grows only if the prefix remains stable and requests actually reach a reusable entry.

Anthropic's largest component reduction is the Opus cache read, from $0.50 to $0.20 per million tokens. That can move a repeated-context bill by more than the input/output cut, as the cache-heavy example shows. But five-minute and one-hour writes are distinct products. Paying for a longer write when no request arrives after minute five buys nothing; repeatedly missing a five-minute window can make the one-hour option cheaper. Use timestamps and provider usage fields, not a guessed hit rate.

Implementation details change the result. Check OpenAI's prompt caching guide and Anthropic's prompt caching guide, then compare cache-write tokens, cache-read tokens, misses, and inter-call gaps in production traces.

The 272K trap: GPT-6 costs more when input context gets very large

A 1.05M-token context window is a capability limit, not a promise of one flat rate. Once a GPT-6 Sol or Luna request exceeds 272K input tokens, OpenAI prices the whole request at the long-context tier. Sol input and cache double while output rises from $10 to $15. Luna input and cache double while output rises from $0.50 to $0.75. The same proportional rule follows through the applicable Batch, Flex, and Fast modes.

Suppose a Sol request has 300M fresh input tokens and 20M output tokens across a month, with each request individually above the threshold. Pricing that workload at short rates produces $800. Correct long-context Standard pricing produces $1,500: 300 × $4 plus 20 × $15. That gap is why prompt-token telemetry belongs in a cost forecast. Aggregate monthly volume alone cannot tell you which tier each request used.

• Record input tokens per request, not only a monthly aggregate.
• Include cached prompt tokens in the input-token threshold logic used by the current pricing record.
• Alert before 272K so tokenization variance does not surprise the router.
• Test retrieval and compaction against the same acceptance criteria; a cheaper prompt that causes retries may cost more overall.

So should you switch?

The new rates justify a migration test, not an automatic migration. Price per token is not cost per successful task. A cheaper successor can lose through extra reasoning, tool turns, cache misses, retries, or fallbacks. A pricier model can win with fewer attempts. The rate card starts the comparison; your traces finish it.

• Token mix: separate fresh input, cache writes, cache reads, reasoning, and visible output.
• Output ratio: Luna's 58.3% output reduction matters more to generation-heavy apps than to short classifiers.
• Context size: count requests on each side of the 272K GPT-6 boundary.
• Processing mode: compare Standard with Batch, Flex, or Fast only when latency and availability requirements permit it.
• Quality and task success: run the same representative tasks, tools, effort policy, and acceptance tests.
• Operational fit: check model availability, regional processing, data residency, and fallback behavior.

Track the next price change

September 22 was not a same-model discount event. It brought successor launches with new price records. Preserving that distinction keeps dashboards from rewriting the historical cost of GPT-5.6 Sol, GPT-5.6 Luna, or Claude Opus 5.

Use the Model Price Monitor to follow model additions, successor transitions, lifecycle changes, and verified price updates. If you want to compare a wider shortlist before choosing the two models to test, open the Model Pricing Comparison.

Anthropic says Claude Sonnet 5.5 and Claude Haiku 5.5 will follow in the coming weeks. They are not treated here as released, API-live, or priced models. When those facts change, use published records rather than extrapolating from Opus 5.5.

FAQ