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 officialcount_tokens
endpoint. This is authoritative; it is the same count Anthropic bills against.OpenAI (GPT)- counted with OpenAI's documentedo200k_base
tokenizer viatiktoken
. 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 liveusage
token counts, and used a long-minus-short delta to cancel the request framing. All three matchedo200k_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:
| Content (identical bytes) | Old tokenizer (Sonnet 4.6 / Opus 4.6) | New tokenizer (Sonnet 5 / Opus 4.8 / Fable 5) | Change |
|---|---|---|---|
| English prose (2,115 chars) | 476 | 636 | +34% |
| HTML page (3,195 chars) | 1,131 | 1,302 | +15% |
| JavaScript (1,933 chars) | 659 | 794 | +20% |
| Python (2,251 chars) | 831 | 1,022 | +23% |
| TypeScript (2,888 chars) | 898 | 1,178 | +31% |
| Rust (2,924 chars) | 1,019 | 1,312 | +29% |
| JSON tool schema (9,948 chars) | 2,631 | 3,306 | +26% |
| Our rendered agent system prompt (42,661 chars) | 10,761 | 14,953 | +39% |
| Chinese prose (379 chars) | 435 | 433 | ~0% |
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 theusage.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.
| Content (identical bytes) | GPT-5.x o200k (1.00x ruler) | Grok 4.5 | Gemini 3 Flash | Claude (old) | Claude (new) |
|---|---|---|---|---|---|
| TypeScript (2,888 chars) | 1.00x | 1.05x | 1.16x | 1.32x | 1.73x | | Rust (2,924 chars) | 1.00x | 1.05x | 1.19x | 1.22x | 1.58x | | JavaScript (1,933 chars) | 1.00x | 1.11x | 1.23x | 1.26x | 1.52x | | Python (2,251 chars) | 1.00x | 1.09x | 1.20x | 1.22x | 1.50x | | HTML page (3,195 chars) | 1.00x | 1.04x | 1.08x | 1.18x | 1.36x | | English prose (2,115 chars) | 1.00x | 1.00x | 1.01x | 1.05x | 1.40x | | Chinese prose (379 chars) | 1.00x | 0.86x | 0.85x | 1.45x | 1.44x | | Chinese chat (117 chars) | 1.00x | 0.92x | 0.91x | 1.55x | 1.53x |
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: about1.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.
| Model | Public headline in / out ($/Mtok) | Tokenizer (measured) | Divergence | Effective in / out ($/Mtok) |
|---|---|---|---|---|
| GPT-5.1 | $1.25 / $10.00 | OpenAI o200k | 1.00x (ruler) | $1.25 / $10.00 | | GPT-5.5 | $5.00 / $30.00 | OpenAI o200k | 1.00x | $5.00 / $30.00 | | GPT-5.6 Sol | $5.00 / $30.00 | OpenAI o200k (verified) | 1.00x | $5.00 / $30.00 | | Grok 4.5 | $2.00 / $6.00 | xAI count endpoint | 1.03x | $2.06 / $6.18 | | Gemini 3 Flash | $0.50 / $3.00 | Google count endpoint | 1.09x | $0.55 / $3.27 | | Claude Sonnet 4.6 | $3.00 / $15.00 | Anthropic old | 1.14x | $3.42 / $17.10 | Claude Sonnet 5 (intro) | $2.00 / $10.00 | Anthropic new | 1.50x | $3.00 / $15.00 | Claude Sonnet 5 (standard, from Sep 1) | $3.00 / $15.00 | Anthropic new | 1.50x | $4.50 / $22.50 | | Claude Opus 4.6 | $5.00 / $25.00 | Anthropic old | 1.14x | $5.70 / $28.50 | | Claude Opus 4.8 | $5.00 / $25.00 | Anthropic new | 1.50x | $7.50 / $37.50 | | Claude Fable 5 | $10.00 / $50.00 | Anthropic new | 1.50x | $15.00 / $75.00 |
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 Flash stays the cheapest in effect: its tokenizer runs a hair heavier than GPT's (1.09x), but its headline is low enough that it does not matter.
One independent, real-world data point in the same direction: another team, Ploy, published a production migration to GPT-5.6 Sol this week and reported it consumed 1.70M input tokens against Claude Opus 4.8's 2.60M for the same builds - roughly 35% fewer. That is a real bill, not a synthetic probe, and it blends the leaner o200k tokenizer with the model's own verbosity. Different measurement, same direction.
A twist for anyone building an agent #
If you write a chatbot whose content is Chinese, the language-specific gap in Finding 2 is your main event. But if you build a coding agent, most of every request is English: the system prompt, the tool schemas, the code, the JSON. That payload sets the tax. In our blend, Claude's new tokenizer stays about 1.50x GPT whether the user's message is in English or Chinese - because a single chat line is a rounding error next to tens of thousands of tokens of English scaffolding. For agents, the tokenizer's English-and-code behavior is the number that matters, no matter who is typing.
How to actually compare model prices #
Compare on your content, not the sticker. Your language and your file types decide the multiplier. Run a representative sample through each tokenizer before you trust a rate card.A tokenizer change is a silent price change. When a vendor ships a new model at the "same price," check whether the tokenizer moved. Opus 4.6 to 4.8 is a ~32% increase with no line item.Measure in dollars per task, not dollars per token. The unit that survives is "what did this build actually cost," which folds tokenizer and model verbosity together. Token counts from the provider's own usage field are the ground truth.Treat $/Mtok as the opening line, not the answer. It is necessary and genuinely useful - it is just not sufficient, and it is not comparable across tokenizers.
None of this makes one model universally right. GPT-5.x is the token-lean choice on English and code; Gemini 3 Flash is remarkably cheap in effect; Claude's models earn their place on quality even when they cost more tokens to run. The honest read is simply that the price you compare should be the one you actually pay - after the tokenizer, not before it.
Sources (verify the headline prices yourself): Anthropic pricing (anthropic.com/pricing), OpenAI pricing (platform.openai.com/docs/pricing), Google Gemini API pricing (ai.google.dev), and xAI pricing (docs.x.ai). Token counts come from Anthropic's count_tokens
endpoint, OpenAI's o200k_base
(verified against live API usage), and the Google and xAI count endpoints. No text was generated to produce these counts.
Playcode keeps every one of these models one click apart, so you can run the same prompt on two of them and compare the result that matters - the app it builds - instead of arguing about a sticker. Try it at playcode.io.