Every model's pricing page shows one number: dollars per million tokens. That number is not comparable across vendors, because 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. We counted identical bytes under every frontier tokenizer. The same TypeScript file is 681 tokens on GPT-5.x and 1,178 tokens on Claude's newest tokenizer - 1.73x more, before any price difference. And Claude's new tokenizer produces about 31% more tokens than Claude's own previous one, at the same sticker price. If you build with an AI coding agent, your workload is mostly code - exactly where the gap is widest.
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 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 you are billed for. Two models can advertise the same "$5.00 / 1M input tokens" and 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. So we measured it. Two findings:
- Same vendor: Anthropic's new tokenizer produces ~30% more tokens than its previous one for the same code, at the same list price. A silent price increase.
- Across vendors: on code, Claude's new tokenizer produces 1.50x to 1.73x the tokens of GPT's - and TypeScript, the language coding agents write most, is the worst case.
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, symbol-heavy text, and our own live agent system prompt. We counted each one, byte for byte, under every model's real tokenizer. No generation, no estimates - just token counts:
- Anthropic (Claude) - Anthropic's official
count_tokensendpoint. Authoritative: it is the same count Anthropic bills against. - OpenAI (GPT) - the documented
o200k_basetokenizer viatiktoken. We did not take it on faith for the newest models: we made real API calls to GPT-5.1, GPT-5.5, and GPT-5.6 Sol and read the liveusagecounts, using a long-minus-short delta to cancel the request framing. All three matchedo200k_baseexactly (ratio 1.0000). - Google (Gemini) and xAI (Grok) - each provider's own token-count endpoint.
Throughout this post, GPT's o200k is the 1.00x reference ruler. It is the right ruler because it does not move: o200k has been frozen and publicly documented for a long time. Claude's tokenizer is the part that keeps changing. Two models are deliberately excluded: DeepSeek and GLM. For those we only have a rough characters-divided-by-four estimate, not a real tokenizer, and a made-up number is exactly what this post exists to call out.
Finding 1: same sticker price, ~30% more tokens
This is the cleanest case in the dataset, because nothing on the rate card moves. Claude Opus 4.6 and Opus 4.8 share the identical $5.00 / $25.00 price. The only change is the tokenizer: the old one ships in Sonnet 4.6 and Opus 4.6, the new one in Sonnet 5, Opus 4.8, and Fable 5. Same bytes in every row, same vendor, counted on Anthropic's own endpoint:
| Content | Old tokenizer | New tokenizer | 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 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 request is composed - mostly English system prompt, tool schemas, code, and JSON - and the new tokenizer runs about +32% per request. Note the last row: on Chinese, almost nothing changed. The inflation is an English-and-code effect.
The "price cut" that isn't
This reframes a headline that looked like good news. Claude Sonnet 5 launched at $2.00 / $10.00, below Sonnet 4.6's $3.00 / $15.00. But that is an intro price, and it ends August 31, 2026. During the intro window the math roughly cancels: Sonnet 5 makes ~32% more tokens but charges a third less per token, so it lands slightly cheaper overall. On September 1 the sticker snaps back to $3.00 / $15.00 - and the +32% token inflation stays. From that day, the same code costs about 32% more on Sonnet 5 than it did on Sonnet 4.6, at an identical list price. The discount was a transition cushion, not a price cut.
We verified against real bills
A token counter is only a promise until you are billed, so we also fired real, paid requests (max_tokens: 1) and read the usage.input_tokens each provider actually charged. For identical content: Opus 4.6 billed 2,541 input tokens, Opus 4.8 billed 3,191 - each matching its count_tokens prediction to the exact token. The inflation is on the invoice, not just in the estimator.
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 the same content - identical to Opus 4.8 - so Fable runs the same new tokenizer and bills its exact count. No hidden per-token surcharge: Fable is expensive by its sticker ($10 / $50), not by a secret token tax. Total cost of this verification: about $0.08.
Finding 2: the gap is widest on code
Now the cross-vendor view. Every number below is a multiple of GPT's token count for the identical file - GPT's o200k is the 1.00x ruler, so 1.20x means "20% more tokens than GPT". Claude's new and old tokenizers sit side by side, so you can see both how much the new tokenizer added and how far Claude already stood above GPT:
| Content | Claude (new) | Claude (old) | Gemini 3 Flash | Grok 4.5 |
|---|---|---|---|---|
| TypeScript | 1.73x | 1.32x | 1.16x | 1.05x |
| Rust | 1.58x | 1.22x | 1.19x | 1.05x |
| JavaScript | 1.52x | 1.26x | 1.23x | 1.11x |
| Python | 1.50x | 1.22x | 1.20x | 1.09x |
| HTML page | 1.36x | 1.18x | 1.08x | 1.04x |
| English prose | 1.40x | 1.05x | 1.01x | 1.00x |
| Chinese prose | 1.44x | 1.45x | 0.85x | 0.86x |
| Chinese chat | 1.53x | 1.55x | 0.91x | 0.92x |
The code rows separate cleanly from everything else. TypeScript is the widest gap at 1.73x, but it is not alone: Rust 1.58x, JavaScript 1.52x, Python 1.50x - all well above English prose at 1.40x. 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 the 1.50-1.73x band is the one that maps to your bill - not the gentler 1.40x of an English paragraph.
Why TypeScript specifically
Because GPT's o200k is unusually efficient at 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 (~3.51 chars/token), while Claude's tokenizer is similarly dense on both. TypeScript is the outlier because one vendor tuned its tokenizer for exactly the language you write and the other did not. The gap is widest right where GPT is strongest.
The Chinese rows tell a different story
On Chinese, Claude sits about 1.45-1.55x above GPT - but with both tokenizers. Old: 435 tokens against GPT's 300. New: 433. This tax is not the new release; it is a long-standing Claude-family disadvantage on CJK that the new tokenizer did not touch. (Gemini actually beats 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 on what you write.
What that does to the price
Multiply the public list price by the measured divergence and you get the effective price - what you actually pay to process the same work. Divergence here is the blended multiplier for a realistic English coding request, normalized to GPT's o200k. GPT rows price out at their sticker; everyone else is scaled by how many more (or fewer) tokens they make of the same content:
| Model | List price in / out ($/Mtok) | Divergence | Effective in / out ($/Mtok) |
|---|---|---|---|
| GPT-5.1 | $1.25 / $10.00 | 1.00x (ruler) | $1.25 / $10.00 |
| GPT-5.5 | $5.00 / $30.00 | 1.00x | $5.00 / $30.00 |
| GPT-5.6 Sol | $5.00 / $30.00 | 1.00x (verified) | $5.00 / $30.00 |
| Grok 4.5 | $2.00 / $6.00 | 1.03x | $2.06 / $6.18 |
| Gemini 3 Flash | $0.50 / $3.00 | 1.09x | $0.55 / $3.27 |
| Claude Sonnet 4.6 | $3.00 / $15.00 | 1.14x (old tokenizer) | $3.42 / $17.10 |
| Claude Sonnet 5 (intro) | $2.00 / $10.00 | 1.50x (new tokenizer) | $3.00 / $15.00 |
| Claude Sonnet 5 (from Sep 1) | $3.00 / $15.00 | 1.50x | $4.50 / $22.50 |
| Claude Opus 4.6 | $5.00 / $25.00 | 1.14x (old tokenizer) | $5.70 / $28.50 |
| Claude Opus 4.8 | $5.00 / $25.00 | 1.50x (new tokenizer) | $7.50 / $37.50 |
| Claude Fable 5 | $10.00 / $50.00 | 1.50x (new tokenizer) | $15.00 / $75.00 |
Read a few rows. Opus 4.6 and 4.8 share a $5.00 / $25.00 sticker but differ ~32% in effective price - Finding 1, now in dollars. GPT-5.5 and GPT-5.6 Sol share both the sticker and the effective price, because they share the verified tokenizer: the two GPT tiers differ by capability, not by a hidden token tax. Gemini 3 Flash stays the cheapest in effect - its tokenizer runs slightly heavier than GPT's, but its sticker is low enough that it does not matter.
One independent data point in the same direction: Ploy published a production migration to GPT-5.6 Sol this week and reported 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 tokenizer with the model's own verbosity. Different measurement, same direction.
The honest range: 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. We put the TypeScript figure in the title 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. Featuring your actual workload is not cherry-picking - but "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.
If you build an agent, English sets your tax
A chatbot whose content is Chinese should care most about the CJK rows above. But in a coding agent, almost every request is dominated by English scaffolding: the system prompt, the tool schemas, the code, the JSON. In our blend, Claude's new tokenizer stays about 1.50x GPT whether the user's chat message is English or Chinese - a single chat line is a rounding error next to tens of thousands of tokens of 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 set the multiplier. Run a representative sample through each tokenizer before you trust a rate card.
- Treat a tokenizer change as a 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. "What did this build actually cost" folds tokenizer and model verbosity together. The provider's own
usagefield is the ground truth. - Treat $/Mtok as the opening line, not the answer. Necessary, useful - and 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 list prices yourself): Anthropic pricing (anthropic.com/pricing), OpenAI pricing (platform.openai.com/docs/pricing), Google Gemini API pricing (ai.google.dev), 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.