The real prices of frontier models. Tokens * Price, right?

The real prices of frontier models. Tokens * Price, right?

Comments

Every model's pricing page shows one number you are meant to compare: dollars per million tokens. Put two side by side and one looks cheaper. That comparison is broken - and if you build with an AI coding agent, it is broken in the most expensive direction.

The price is per token, but a "token" is not a fixed amount of text: each model's tokenizer cuts the same file into a different number of pieces, and you pay per piece. Here is the number that lands on your invoice.

The exact same TypeScript file is 681 tokens on GPT-5.x and 1,178 tokens on Claude's newest tokenizer - 1.73x more, and +31% over Claude's own previous tokenizer, before a cent of price difference. Your real workload as a builder is basically TypeScript, and TypeScript is exactly where the gap is widest. (English prose is a milder ~1.4x - more on why below.)

The number the pricing page hides

A model's bill is two numbers multiplied together:

cost = (tokens your content becomes) x (price per token)

The pricing page shows you the second number and treats the first as a constant. It is not a constant. It is a property of the model's tokenizer - the component that chops your text into the units the model actually charges for.

Two models can advertise the exact same "$5.00 / 1M input tokens" and still hand you different bills for the same paragraph, because one turns that paragraph into more tokens than the other. Nobody prints the tokens-per-content number, so nobody compares it. That is the whole illusion. To see the real price you have to measure the tokenizer, then multiply it back in.

Two floors the rate card hides

The rate card shows one price and hides two layers of cost beneath it. Both are measured below, both land on your invoice, and neither appears anywhere on a pricing page. Keep the two baselines straight, because they are different comparisons and the numbers only reconcile if you do.

Floor one - the same-sticker stealth hike. This is Anthropic's new tokenizer measured against its own previous one - a like-for-like, same-vendor comparison. Claude Opus 4.6 and Opus 4.8 carry the identical $5.00 / $25.00 rate card, but 4.8 ships the newer tokenizer, and it turns the same code into about 29-32% more tokens: +31% on TypeScript (898 to 1,178), +29% on Rust (1,019 to 1,312). "Same price, new model" quietly costs you roughly 30% more, and that increase is never printed as a line item.

Floor two - it is worst on the language you actually write. That ~30% is the average. Now measure the new Claude tokenizer against the leanest one on the market - GPT's o200k - on TypeScript, which is the bulk of what an AI coding agent produces. The gap is 73% (1,178 vs 681 = 1.73x). This is a cross-vendor comparison, and Anthropic never claimed token parity with GPT - so read it as the amplifier, not the accusation: it is what turns an abstract "$/Mtok" into the real damage on your specific workload.

The rate card cannot show you either floor.

How we measured it

We took 16 real fixtures - English prose, an HTML page, JavaScript, Python, TypeScript and Rust files, JSON tool schemas and tool results, Chinese chat and prose, a block of symbol-heavy text, and our own live agent system prompt - and counted each one, byte for byte, under every model's real tokenizer. No generation, no billing estimates: just token counts.

• Anthropic (Claude) - counted on Anthropic's official count_tokens endpoint. This is authoritative; it is the same count Anthropic bills against.
• OpenAI (GPT) - counted with OpenAI's documented o200k_base tokenizer via tiktoken. We did not take that on faith for the newest models: we made real minimal API calls to GPT-5.1, GPT-5.5 and GPT-5.6 Sol, read the live usage token counts, and used a long-minus-short delta to cancel the request framing. All three matched o200k_base exactly (ratio 1.0000). The tokenizer is verified, not assumed.
• Google (Gemini) and xAI (Grok) - counted on each provider's own token-count endpoint.

We use GPT's o200k as the 1.00x reference, and every cross-vendor ratio reads as "tokens vs o200k." It is the right ruler precisely because it does not move: o200k has been frozen and publicly documented for a long time, so it is a stable, checkable yardstick - Claude's tokenizer is the part that keeps changing.

Two models we deliberately keep out of the comparison tables: DeepSeek and GLM. We only have a rough characters-over-four estimate for those two, not a real tokenizer, and a made-up number is exactly the kind of thing this post exists to call out. They are noted as estimates or not at all.

Finding 1: the first floor, a same-sticker stealth hike

Floor one in full, and this is the cleanest case in the dataset because nothing on the rate card moves - only the tokenizer. Claude Opus 4.6 and Opus 4.8 share the identical $5.00 / $25.00 sticker; 4.8 simply ships the newer tokenizer and quietly bills more for the same code.

Here is the new tokenizer against the old one across every fixture - same bytes in every row, same-vendor, measured on Anthropic's own count_tokens endpoint:

Blend those the way a real agent turn is composed - mostly English system prompt, tool schemas, code, and JSON - and the new tokenizer runs about +32% on the whole request. Notice the last row: on Chinese, the new tokenizer changed almost nothing. The +32% is an English-and-code effect.

This reframes a headline that looked like a price cut. Claude Sonnet 5 launched at $2.00 / $10.00 - below Sonnet 4.6's $3.00 / $15.00. But that intro price runs only through August 31, 2026, after which it reverts to the standard $3.00 / $15.00. During the intro window the lower sticker slightly more than covers the inflation: Sonnet 5 makes about 32% more tokens than 4.6, but at $2.00 it charges a third less per token, so it lands a hair cheaper overall. The day the intro ends, the sticker snaps back to $3.00 while the +32% token inflation stays - so the same code costs about 32% more on Sonnet 5 than on 4.6, at an identical $3.00 sticker. The discount was the transition cushion, not a durable cut.

We read the actual bills, including the priciest model

A token counter is only a promise until you are billed. So we did not stop at count_tokens - we fired real, billed requests (max_tokens: 1) and read the usage.input_tokens the provider actually charged. For identical content, Opus 4.6 billed 2,541 input tokens and Opus 4.8 billed 3,191 - each matching its count_tokens prediction to the exact token. The same-sticker hike is not an artifact of the estimator; it is on the invoice, about a quarter more tokens here for the very same bytes.

We spent the extra call on the most expensive model on purpose, because "same tokenizer, nothing special" is exactly the kind of claim this post distrusts. Fable 5 billed 3,191 input tokens for that content - identical to Opus 4.8 and Sonnet 5 - so Fable uses the same new tokenizer and bills its exact count, with no hidden per-token surcharge. Fable is expensive by its sticker ($10 / $50), not by a secret token tax. The whole verification cost about $0.08: the counter is honest, the inflation is real, and even the priciest model plays it straight.

Finding 2: the floor under the floor, worst on the code you write

This is the cross-vendor comparison, and here GPT's o200k is the 1.00x ruler. Every cell is that model's tokens as a multiple of GPT's for the identical file - so 1.20x means 20% more tokens than GPT. We show Claude's old and new tokenizers side by side, so both floors sit in one view: how far Claude already stood above GPT, and how much the new tokenizer piled on top. The code rows separate cleanly from everything else.

You do not ship prose - you ship code, and every code fixture lands well above it. TypeScript is the widest at 1.73x, and it is not alone: Rust 1.58x, JavaScript 1.52x, Python 1.50x - all far above English prose at 1.40x. GPT sets the 1.00x floor on every code row; even Claude's old tokenizer already sat 1.22x to 1.32x above it, and the new one widens that to 1.50x-1.73x.

So this is not a TypeScript fluke: it is the whole code category, with TypeScript on top - and code is what an AI coding agent produces all day, so this is the band that maps to your bill, not the gentle 1.4x of an English paragraph.

Why TypeScript specifically?

Because GPT's o200k is unusually efficient on it - about 4.24 characters per token, the fingerprint of a tokenizer trained heavily on web JavaScript and TypeScript, where camelCase identifiers and JSX patterns collapse into single tokens. That efficiency slips on Rust (about 3.51 characters per token), while Claude's tokenizer stays comparatively dense on both. So TypeScript is the outlier because one vendor tuned its tokenizer for exactly the language you write and the other did not - not merely because code is compact. The gap is widest right where GPT is strongest.

The shape shifts once more on non-Latin scripts. On Chinese, Claude sits about 1.4-1.5x above GPT - but this is true of both the old and new Claude tokenizers. The old tokenizer put Chinese prose at 435 tokens against GPT's 300; the new one lands at 433 - the same ~1.45x either way. Here the tax is not the new release, it is a long-standing Claude-family disadvantage on CJK that the new tokenizer did not fix. (Gemini actually edges GPT on Chinese - 256 tokens to GPT's 300.)

The lesson is not "one model is always cheapest." It is that which tokenizer taxes you, and how hard, depends entirely on what you write.

The honest size of the effect: 1.4x to 1.73x, not 2-4x

You will see people claim Claude uses "2x to 4x" the tokens of GPT. Our measurements do not support that, and overstating it would undercut the real point. Claude's new tokenizer against GPT's o200k, by content type:

• English prose, HTML, JSON: about 1.36x to 1.42x.
• Code - Python, JavaScript, Rust, TypeScript: about 1.50x to 1.73x, TypeScript the widest.
• Chinese and symbol-heavy text: about 1.44x to 1.53x.

Real, consequential, and worth pricing in - but bounded. TypeScript at 1.73x is the widest gap we found on a real tokenizer, not a floor you should assume everywhere - the rest of the code sits between 1.50x and 1.58x, and English prose stays around 1.4x.

We put the TypeScript figure up front for one honest reason: it is the top of the range and it is what an AI coding agent processes all day, so it is the number that maps to a real bill. That is featuring your actual workload, not cherry-picking - "Claude is 1.73x on everything" would be false, and we are not claiming it. Precision is the point: if the honest number for prose is 1.4x, calling it 3x makes the whole argument easy to dismiss.

What the price actually is

Multiply the public headline price by the measured tokenizer divergence and you get the effective price per unit of real content - what you actually pay to process the same work. Divergence below is the blended multiplier for a realistic English coding turn, normalized to GPT's o200k (1.00x) - the fixed ruler from earlier - so the GPT rows price out at their sticker and everyone else is scaled by how many more (or fewer) tokens they make of the same content. Headline prices are the providers' own public list prices; sources are linked below.

Read a few rows. GPT is the ruler, so its rows price out at the sticker. Opus 4.8 and Opus 4.6 share a $5.00 / $25.00 headline but differ by ~32% in effective price - the same-sticker floor, now in dollars. GPT-5.5 and GPT-5.6 Sol carry the same $5.00 / $30.00 headline and the same effective price, because they share the verified o200k tokenizer - the two GPT tiers differ by capability and speed, not by a hidden tokenizer tax. Gemini 3