Beyond Token Pricing: The True Cost of Opus 5, Fable 5 and GPT-5.6 Sol in 2026

Three frontier models, three headline prices: Claude Opus 5 at $5 per million input tokens and $25 per million output, Claude Fable 5 at $10 and $50, and GPT-5.6 Sol at $5 and $30. Read those numbers and Opus 5 — released on 24 July 2026 at exactly Opus 4.8’s prices — looks like the obvious value pick. Fable 5 costs exactly double Opus 5 on both sides of the ledger, and double Sol on input — though on output the gap narrows to 1.67x.

Then the invoice arrives and it does not match. The sticker price is the smallest variable in the equation. What actually decides your bill is how much reasoning the model does before answering, whether your prompt was in cache and which kind of cache, how big your requests are, and how many tokens your tools quietly add to every call. This piece walks the mechanics with the vendors’ own published rates. All prices checked 24 July 2026.

What do Opus 5, Fable 5 and GPT-5.6 Sol cost per token?

Here are the published list rates, side by side. Everything below is what these numbers leave out.

Three things that table hides, before we get to the mechanics.

The Sol column is the short-context one. Every Sol figure above applies to requests of 272,000 input tokens or fewer. Past that line OpenAI publishes a second set — input $10, cached input $1, cache write $12.50, output $45, and batch $5 / $22.50 — and applies it to the whole request. More on that below; for now, read the Sol column as conditional.

The context windows are not directly comparable either. Claude’s 1M counts everything in the request and the answer Claude generates, thinking included. Sol’s 1.05M works the same way. So a 4,000-token answer leaves room for 996,000 input tokens on Claude and about 1,046,000 on Sol — a real difference that a “1M vs 1.05M” row understates.

And on capability, price is the live question. Our earlier GPT-5.6 Sol and Claude Fable 5 benchmark comparison found the two a single point apart on the composite index that measures them the same way — a gap too small to read as a ranking, and one where the Claude score included a fallback to Opus 4.8 on a share of tasks. Other harnesses compare them too, on their own methodologies. We could not find a public, reproducible like-for-like task success rate for all three, which is why this piece stays on the side of the ledger that is actually knowable.

Why doesn’t the sticker price predict the bill?

Because four things sit between the rate card and the invoice, and not one of them appears on the rate card:

1. Reasoning tokens, which bill at the output rate and are mostly invisible to you.
2. Cache state, which changes what one input token costs by up to 20x.
3. Request size, which on Sol triggers a repricing cliff at 272,000 input tokens.
4. Fixed overhead — tool definitions, server-side tool fees, session runtime — that never appears in a price-per-token comparison at all.

How much of the output bill is reasoning you never see?

Enough to be worth measuring before you compare prices: in the worked example below it is two-thirds of the output tokens and about a third of the entire bill. On all three models the tokens spent thinking are billed as output tokens, at the output rate, the most expensive line on the card. Neither vendor returns the raw reasoning text.

Anthropic is unusually direct about the consequence: the billed output token count does not match the thinking text visible in the response. You are billed for the full reasoning the model generated internally, not for the summary you get back. Set the display option to omit thinking and the field comes back empty, but the charge is identical.

Both vendors expose the split, under nearly the same path but a different leaf name — usage.output_tokens_details.thinking_tokens on Claude, and usage.output_tokens_details.reasoning_tokens on GPT-5.6 through the Responses API (usage.completion_tokens_details.reasoning_tokens if you are still on Chat Completions). It is the most useful number in the billing object and the one almost nobody reads.

The defaults matter here more than the prices. On Opus 5 thinking is on by default — a change from Opus 4.8, where omitting the parameter meant no thinking — and the effort parameter defaults to high on the Claude API. On Fable 5 adaptive thinking is always on and cannot be turned off at all. So on two of these three models, a request written with no thinking configuration whatsoever arrives with thinking switched on. That is not the same as thinking every time: Claude decides per request, and a simple lookup can come back with no thinking block at all. You are billed for what it actually generates — which is the argument for measuring rather than assuming, in either direction.

Work one agent task through and the shape is stark. Twelve requests, a 30,000-token prefix cached once and read eleven times, 2,500 fresh input tokens per request, 1,800 output tokens per request split 1,200 reasoning to 600 visible:

Read that table for its shape, not its totals. The prices are official; the token mix is our assumption, and the 2:1 reasoning-to-visible ratio in particular is a number we chose, not a property of any of these models. Segments are rounded to the cent and totals computed from unrounded figures, so the columns will not always sum by eye.

What the assumption buys you is a worked demonstration, not a law. Under it, reasoning is the largest single line item on all three models at 34–38% of the bill — roughly twice what the answer the user actually reads costs. Change the ratio and that ranking changes with it, which is exactly why the number to go and get is your own. Reasoning is also the line item you can move, by lowering effort.

Does a cheaper token mean a cheaper answer?

Not necessarily, because a token is not a fixed amount of text.

Anthropic documents that models from the Claude 4.7 generation onward use a newer tokenizer that produces roughly 30% more tokens for the same input than earlier Claude models — a note it repeats in the Fable 5 specification. That has nothing to do with the rate card and everything to do with the bill: if your cost model was calibrated on an older Claude model, the same documents now cost meaningfully more to send at an unchanged per-token price.

The cross-vendor version is measurable but not general. Both vendors ship a token-counting endpoint, so you can take your own corpus and get an exact token count from each — and you should, before you trust any comparison table. What does not exist is a published conversion ratio that holds across content types, so “$5 per million” on Opus 5 and “$5 per million” on Sol are not automatically the same price for the same paragraph. Measure yours; do not assume a constant.

Anthropic’s own launch framing for Opus 5 switches units in the same direction. Its benchmark claims are per task, not per token: within 0.5% of Fable 5’s peak on one coding benchmark at half the cost per task, and past Fable 5’s best result on an agentic desktop benchmark at just over a third of the cost. Those are vendor figures on vendor-chosen benchmarks and should be read as such — but the unit is the right one. Cost per finished task is what you pay. Cost per token is what you are quoted.

The launch post’s much-quoted 26% fewer tokens figure needs more care than it usually gets. It is a customer testimonial from an early-access legal-AI team, not an Anthropic benchmark, and the comparison is not like for like: it describes Opus 5 holding quality at lower reasoning levels against Opus 4.8 running at max reasoning. That is a real and useful observation about effort tuning. It is not evidence that Opus 5 emits 26% fewer tokens than Opus 4.8 on the same settings, and it should not be carried into a budget as if it were.

What does prompt caching actually cost?

More than “90% off”, and less, depending on which end of it you are standing.

Caching is normally sold as the read discount, and the read discount is genuine: a cache hit costs a tenth of base input on all three models. But writing to the cache costs more than not caching at all — 1.25x base input for a five-minute entry, 2x for a one-hour entry on the Claude models.

Those write rows are not like for like, and the difference is worth more than it looks. Anthropic sells two tiers priced by how long the entry lives: 1.25x for a five-minute entry, 2x for a one-hour one. OpenAI sells one tier at 1.25x for GPT-5.6, and its cached prefixes stay eligible for reuse for at least 30 minutes. So Sol’s single write buys six times the five-minute window at the same multiplier — on bursty traffic that repeats every ten or twenty minutes, that is a genuine structural advantage that no per-token table shows.

The break-even arithmetic on the Claude side is simple and routinely missed. A five-minute entry pays for itself after one read (1.25x + 0.1x beats 2x uncached); a one-hour entry needs two (2x + 0.2x beats 3x). Reach for the one-hour TTL on traffic that does not actually repeat within the hour and you have doubled your input cost to buy nothing.

Three more caching details with money attached:

• Short prompts silently do not cache, and the threshold differs by vendor. The minimum cacheable prefix is 512 tokens on Opus 5 and Fable 5 — half of Opus 4.8’s 1,024 — but 1,024 tokens on GPT-5.6. Below it the request is processed without caching and no error is returned.
• Read the two usage fields together, not just the read. A cold first call on Claude is not silent: an eligible prefix reports a non-zero cache_creation_input_tokens with a zero read, and an invalidated prefix looks the same — that pair is how you tell a fresh write from a hit. On GPT-5.6 the equivalent cache_write_tokens is softer, because implicit caching is documented as something the API may do rather than a guarantee; use an explicit breakpoint if you need the behaviour to be deterministic. Both fields at zero means no caching happened. Why differs by vendor: on Claude, caching is opt-in, so the usual causes are a missing cache_control, no eligible breakpoint, or a prefix under 512 tokens. GPT-5.6 caches prefixes implicitly, with no opt-in required, so there the usual cause is simply a prompt under 1,024 tokens or a prefix that did not repeat.
• On Claude, changing effort invalidates cache. The resolved effort value is rendered into the prompt, so a request that lowers effort to save money can end up re-writing at 1.25x what it would have read at 0.1x. How much gets re-written depends on where your breakpoint sits: a thinking-configuration change invalidates from the messages level, and whether tools and system are hit too varies by model. Anthropic’s documentation demonstrates the messages case with a runnable example: a prefix that read cleanly from cache on the second request comes back billed as fresh cache-creation tokens on the third, with the effort level as the only change. OpenAI’s caching documentation makes no equivalent statement about its reasoning controls, so do not assume the behaviour transfers; measure it.
• Steer per message, not per parameter. Guidance appended to the newest user message shifts thinking behaviour while leaving earlier cache breakpoints intact. A configuration change does not.

What happens when a request crosses 272,000 tokens?

On GPT-5.6 Sol, the price of the entire request changes. Anthropic charges one flat rate across its full 1M-token context; OpenAI applies 2x input and 1.5x output once a request exceeds 272,000 input tokens, and applies it to the whole request rather than to the tokens above the line.

The step is sharp. Take a request with a fixed 4,000-token output and no caching. Read that output figure as total billed output — reasoning included, per the section above — not as 4,000 visible words:

The table stops at 996,000 because that is where Claude stops: its 1M window has to hold the 4,000-token answer as well as the prompt. Sol’s 1.05M window would carry roughly 1,046,000 input tokens at the same output length.

One extra token adds 96% to that request. That percentage belongs to this example, not to the rule: a larger output share softens it, because output rises only 1.5x while input doubles. And past the line, the model that is half Fable 5’s price below it lands two cents under Fable 5 — while Opus 5, unchanged, costs half of both. The doubling hits the cache rates too: above 272K a Sol cache read costs $1 rather than $0.50, so the workaround for expensive input gets more expensive at exactly the point you need it. Long-document work, whole-repository context and unpruned agent histories all drift across 272K without anyone deciding to, which makes this the one threshold worth putting a hard guard on in code.

Which costs are not token costs at all?

The ones that never appear in a price-per-token comparison. Both vendors publish them; almost nobody adds them up.

Anthropic’s schedule — the closest thing to a hidden-fee list in the industry, and worth reading before you architect anything:

OpenAI’s, for the same shape of workload:

The two lists are not row-for-row equivalent, and that is the point: you cannot settle this from either vendor’s rate card alone.

Add the first three Anthropic rows together and an Opus 5 agent with bash and the text editor enabled carries roughly 1,311 tokens of fixed definition on every single call — an estimate, not an official Opus 5 figure, because only the 286-token tool-use prompt and the 325-token bash definition are published against Opus 5 by name; the 700 for the text editor is the Claude 4.x number used as a proxy. At 500 calls a day that is about 19.7 million input tokens a month — roughly $98 on Opus 5 if none of it is cached. Put the tool block behind a cache breakpoint and the reads come to about $10, plus a write each time the entry expires and has to be laid down again. It is the clearest example of why the two sections above are the same problem: the overhead is not large, but whether you pay 1x or 0.1x for it is a design decision nobody is prompted to make. Worth noting in the other direction, Opus 5’s tool-use system prompt costs 286 tokens where Opus 4.7’s cost 675, so some of this overhead is genuinely shrinking.

So which model is actually cheapest for your workload?

There is no single answer, and anyone giving you one is quoting the rate card. But the mechanics above collapse into four decisions that matter more than the model choice:

• Set effort explicitly. It defaults to high on Opus 5 on the Claude API — the middle of five levels (low, medium, high, xhigh, max), with two above it that typically spend more tokens. Effort does not change the rate you pay — only how much the model generates at it. Anthropic’s own migration guidance for Opus 5 is to sweep downward, because low and medium perform unusually well on this model.
• Measure your reasoning share before you compare prices, using thinking_tokens on Claude or reasoning_tokens on GPT-5.6. Then size the lever honestly: in the worked example above, reasoning is about 35% of the bill, so cutting it 20% saves roughly 7% overall — real money, but less than the 9% that moving from Sol to Opus 5 saves at the same token mix, and far less than the ~50% from moving off Fable 5. Effort tuning and model choice are complementary levers, not substitutes.
• Pick the cache TTL from your actual repeat rate, not from optimism, and check your prefix clears the minimum — 512 tokens on Opus 5 and Fable 5, 1,024 on GPT-5.6.
• Put a hard guard at 272K input tokens if you are on Sol — it doubles the cache rates as well as the base ones — and remember that a Claude request at 900K costs the same per token as one at 9K, but has to fit the answer inside the same 1M window.

Then compare. For a pure price-per-token starting point across the current field, our LLM API cost calculator runs your own monthly volumes against the official rates, and the three-way Kimi K3, Fable 5 and GPT-5.6 Sol price comparison covers where the cheaper end of the market sits. Neither replaces measuring your own token mix — which, as the numbers above show, is where the money was hiding all along.

Prices in this piece are the published list rates on 24 July 2026 and change frequently. Re-check them before they drive a budget.