每个模型的定价页面都只显示一个数字：每百万 token 的价格。但这个数字在不同厂商之间无法直接比较，因为“token”并非固定长度的文本。每个模型的 tokenizer 会将同一份文件切分成不同数量的片段，而你按片段付费。我们统计了所有前沿 tokenizer 下相同字节数的内容。同一份 TypeScript 文件，在 GPT-5.x 上是 681 个 token，而在 Claude 最新的 tokenizer 下则是 1,178 个 token——在考虑任何价格差异之前，就已经相差 1.73 倍。而且，Claude 的新 tokenizer 在相同标价下，比它自己上一代 tokenizer 多产生约 31% 的 token。如果你使用 AI 编程智能体构建应用，你的工作负载主要是代码——而这正是差距最大的地方。
定价页面隐藏的数字
一个模型的账单由两个数字相乘得出：
成本 =（你的内容转化成的 token 数量）x（每个 token 的价格）
定价页面只显示第二个数字，并将第一个数字视为常量。但它并非常量。它是模型 tokenizer 的一个属性——tokenizer 是将你的文本切分成计费单位的组件。两个模型可以标价相同的“5.00 美元 / 100 万输入 token”，但针对同一段文字，给你的账单却不同，因为其中一个模型将这段文字切分成了比另一个更多的 token。
没有人公布每个内容对应的 token 数量，所以也没有人比较它。因此我们测量了它。两个发现：
- 同一厂商：Anthropic 的新 tokenizer 在相同标价下，对同一段代码产生的 token 比上一代多约 30%。一次无声的涨价。
- 跨厂商：在代码方面，Claude 的新 tokenizer 产生的 token 数量是 GPT 的 1.50 倍到 1.73 倍——而 TypeScript，这个编程智能体编写最多的语言，情况最为严重。
我们如何测量的
我们选取了 16 个真实样本：英文散文、一个 HTML 页面、JavaScript、Python、TypeScript 和 Rust 文件、JSON 工具 schema 和工具结果、中文聊天和散文、符号密集的文本，以及我们自己的实时智能体系统提示词。我们对每个样本，在每个模型的真实 tokenizer 下，逐字节进行了统计。没有生成，没有估算——只有 token 计数：
- Anthropic（Claude）——Anthropic 官方的 count_tokens 端点。具有权威性：它与 Anthropic 用于计费的计数完全相同。
- OpenAI（GPT）——通过 tiktoken 有文档记录的 o200k_base tokenizer。对于最新模型，我们并未盲目信任：我们实际调用了 GPT-5.1、GPT-5.5 和 GPT-5.6 Sol 的 API，并读取了实时用量计数，使用长减短差值法消除了请求框架的影响。三者均与 o200k_base 完全一致（比值为 1.0000）。
- Google（Gemini）和 xAI（Grok）——各自使用自己的 token 计数端点。
在本文中，GPT 的 o200k 作为 1.00 倍参考标尺。它之所以是合适的标尺，是因为它不会变动：o200k 早已被冻结并有公开文档记录。而 Claude 的 tokenizer 则一直在变化。有两个模型被有意排除在外：DeepSeek 和 GLM。对于它们，我们只能粗略估算字符数除以四，而非真正的 tokenizer，而编造出来的数字正是本文要指出的问题。
发现一：标价相同，token 却多出约 30%
这是数据集中最清晰的情况，因为费率卡上的任何参数都没有变动。Claude Opus 4.6 和 Opus 4.8 的定价完全相同，均为 5.00 美元 / 25.00 美元。唯一的变化是 tokenizer：旧版 tokenizer 用于 Sonnet 4.6 和 Opus 4.6，新版则用于 Sonnet 5、Opus 4.8 和 Fable 5。每一行的字节数相同，供应商相同，且均在 Anthropic 自己的端点上计数：
| 内容 | 旧 tokenizer | 新 tokenizer | 变化 |
|---|---|---|---|
| 英文散文（2,115 字符） | 476 | 636 | +34% |
| HTML 页面（3,195 字符） | 1,131 | 1,302 | +15% |
| JavaScript（1,933 字符） | 659 | 794 | +20% |
| Python（2,251 字符） | 831 | 1,022 | +23% |
| TypeScript（2,888 字符） | 898 | 1,178 | +31% |
| Rust（2,924 字符） | 1,019 | 1,312 | +29% |
| JSON 工具 schema（9,948 字符） | 2,631 | 3,306 | +26% |
| 我们的智能体系统提示词（42,661 字符） | 10,761 | 14,953 | +39% |
| 中文散文（379 字符） | 435 | 433 | 约 0% |
按照真实智能体请求的构成方式混合这些内容——主要是英文系统提示词、工具 schema、代码和 JSON——新 tokenizer 每次请求大约多出 +32%。注意最后一行：中文几乎没有变化。这种膨胀是英文和代码带来的效应。
所谓的“降价”其实并非如此
这则新闻标题原本看起来像是好消息。Claude Sonnet 5 的定价为 $2.00 / $10.00，低于 Sonnet 4.6 的 $3.00 / $15.00。但这只是首发优惠价，有效期至 2026 年 8 月 31 日。在优惠期内，账目大致相抵：Sonnet 5 生成的 token 数量多出约 32%，但每个 token 的收费却低了三分之一，因此总体成本略低。到了 9 月 1 日，价格将回调至 $3.00 / $15.00——而多出 32% 的 token 数量则保持不变。从那天起，在相同的标价下，同样的代码在 Sonnet 5 上的成本比在 Sonnet 4.6 上高出约 32%。这次折扣只是一个过渡缓冲，并非降价。
我们已通过实际账单进行了验证
token 计数器在你收到账单之前都只是一个承诺，因此我们还实际发送了付费请求（max_tokens: 1），并读取了每个提供商实际收取的 usage.input_tokens。对于相同的内容：Opus 4.6 收取了 2,541 个输入 token，Opus 4.8 收取了 3,191 个——两者都与各自的 count_tokens 预测精确匹配。这种 token 数量膨胀不仅体现在估算器中，也实实在在地出现在发票上。
我们特意在最昂贵的模型上多花了这笔调用费用，因为“相同的 tokenizer，没什么特别的”正是本文所质疑的那种说法。对于相同的内容，Fable 5 收取了 3,191 个输入 token——与 Opus 4.8 完全一致——因此 Fable 使用的是相同的新 tokenizer，并按实际计数收费。没有隐藏的按 token 加价：Fable 的昂贵之处在于其标价（$10 / $50），而非秘密的 token 税。这次验证的总成本约为 0.08 美元。
发现 2：代码方面的差距最大
接下来是跨厂商的对比。以下每个数字都是相对于 GPT 对同一文件 token 计数的倍数——GPT 的 o200k 作为 1.00x 的基准，因此 1.20x 意味着“比 GPT 多出 20% 的 token”。Claude 的新旧 tokenizer 并列展示，这样你既能看出新 tokenizer 增加了多少，也能看到 Claude 原本就比 GPT 高出多少：
| 内容类型 | Claude（新版） | Claude（旧版） | 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 页面 | 1.36x | 1.18x | 1.08x | 1.04x |
| 英文散文 | 1.40x | 1.05x | 1.01x | 1.00x |
| 中文散文 | 1.44x | 1.45x | 0.85x | 0.86x |
| 中文聊天 | 1.53x | 1.55x | 0.91x | 0.92x |
代码行的压缩效率明显高于其他内容。TypeScript 的差距最大，达到 1.73 倍，但并非孤例：Rust 为 1.58 倍，JavaScript 为 1.52 倍，Python 为 1.50 倍——均远高于英文散文的 1.40 倍。这并非 TypeScript 的偶然现象，而是整个代码类别的普遍规律，只是 TypeScript 位居榜首。而代码正是 AI 编程智能体全天候生成的内容，因此 1.50-1.73 倍这个区间才对应着你的账单——而非英文段落那更温和的 1.40 倍。
为什么偏偏是 TypeScript
因为 GPT 的 o200k 分词器在处理 TypeScript 时异常高效：大约每 token 对应 4.24 个字符，这反映出其分词器大量训练于网络上的 JavaScript 和 TypeScript 代码，其中驼峰式标识符和 JSX 模式能被压缩为单个 token。这种效率在 Rust 上有所下降（约 3.51 字符/token），而 Claude 的分词器在这两种语言上则密度相近。TypeScript 之所以成为异常值，是因为一家供应商针对你实际编写的语言优化了其分词器，而另一家没有。差距最大的地方，恰恰是 GPT 最强的地方。
中文内容则呈现出另一番景象
在中文处理上，Claude 的 token 消耗量大约是 GPT 的 1.45 到 1.55 倍——但这是针对两个分词器而言。旧版分词器：435 个 token 对比 GPT 的 300 个。新版分词器：433 个。这种额外开销并非新版发布所致；而是 Claude 系列在 CJK（中日韩）字符上长期存在的劣势，新版分词器并未触及。（实际上，Gemini 在中文上击败了 GPT：256 个 token 对比 GPT 的 300 个。）结论并非“某个模型总是最便宜”，而是哪个分词器会向你收取额外费用、以及收取多少，取决于你写的是什么内容。
这对价格意味着什么
将公开标价乘以测得的差异倍数，就得到了有效价格——即处理相同工作量时你实际支付的费用。这里的差异倍数是对一个真实的英文编码请求进行综合加权后的乘数，并以 GPT 的 o200k 分词器为基准进行归一化。GPT 的行按标价计费；其他所有模型则根据它们对相同内容生成的 token 数量（更多或更少）进行缩放：
| 模型 | 标价（输入/输出，单位：$/M token） | 差异倍数 | 有效价格（输入/输出，单位：$/M token） |
|---|---|---|---|
| GPT-5.1 | $1.25 / $10.00 | 1.00 倍（基准） | $1.25 / $10.00 |
| GPT-5.5 | $5.00 / $30.00 | 1.00 倍 | $5.00 / $30.00 |
| GPT-5.6 Sol | $5.00 / $30.00 | 1.00 倍（已验证） | $5.00 / $30.00 |
| Grok 4.5 | $2.00 / $6.00 | 1.03 倍 | $2.06 / $6.18 |
| Gemini 3 Flash | $0.50 / $3.00 | 1.09 倍 | $0.55 / $3.27 |
| Claude Sonnet 4.6 | $3.00 / $15.00 | 1.14x（旧分词器） | $3.42 / $17.10 |
| Claude Sonnet 5（介绍） | $2.00 / $10.00 | 1.50x（新分词器） | $3.00 / $15.00 |
| Claude Sonnet 5（自 9 月 1 日起） | $3.00 / $15.00 | 1.50x | $4.50 / $22.50 |
| Claude Opus 4.6 | $5.00 / $25.00 | 1.14x（旧分词器） | $5.70 / $28.50 |
| Claude Opus 4.8 | $5.00 / $25.00 | 1.50x（新分词器） | $7.50 / $37.50 |
| Claude Fable 5 | $10.00 / $50.00 | 1.50x（新分词器） | $15.00 / $75.00 |
读了几行数据。Opus 4.6 和 4.8 的标价都是 $5.00 / $25.00，但实际有效价格相差约 32%——这是发现之一，现在用美元表示。GPT-5.5 和 GPT-5.6 Sol 的标价和有效价格都相同，因为它们使用相同的已验证分词器：这两个 GPT 层级按能力区分，而非隐藏的 token 税。Gemini 3 Flash 的实际价格仍然最便宜——它的分词器运行成本略高于 GPT，但标价足够低，因此影响不大。
一个方向相同的独立数据点：Ploy 本周发布了一篇关于生产环境迁移到 GPT-5.6 Sol 的文章，报告称在完成相同构建任务时，输入 token 量为 170 万，而 Claude Opus 4.8 为 260 万——大约少了 35%。这是真实的账单，而非合成探测，它结合了更精简的分词器和模型自身的冗长程度。测量方法不同，但方向一致。
诚实的范围：1.4 倍到 1.73 倍，而非“2 到 4 倍”
你会看到有人声称 Claude 使用的 token 量是 GPT 的 2 到 4 倍。我们的测量结果不支持这一说法，夸大其词反而会削弱真正的论点。按内容类型划分，Claude 的新分词器与 GPT 的 o200k 分词器对比：
- 英文散文、HTML、JSON：大约 1.36 倍到 1.42 倍。
- 代码（Python、JavaScript、Rust、TypeScript）：大约 1.50 倍到 1.73 倍，TypeScript 差距最大。
- 中文和符号密集的文本：大约 1.44 倍到 1.53 倍。
这是真实存在的、影响显著的，并且值得在定价中考虑——但范围是有限的。我们把 TypeScript 的数据放在标题里，有一个诚实的原因：这是范围的上限，也是 AI 编程智能体整天处理的内容，因此这个数字对应的是真实的账单。展示你的实际工作负载并非选择性挑数据——但声称“Claude 在所有场景下都是 1.73 倍”则是错误的，我们也没有这样宣称。精确才是关键：如果英文散文的诚实数字是 1.4 倍，却称之为 3 倍，那整个论点就很容易被驳倒。
如果你构建一个智能体，英文决定了你的额外成本。
一个内容为中文的聊天机器人最应关注上面那些中日韩字符行。但在编程智能体中，几乎每个请求都以英文脚手架为主导：系统提示词、工具架构、代码、JSON。在我们的混合测试中，无论用户聊天消息是英文还是中文，Claude 的新分词器始终比 GPT 高出约 1.50 倍——在数万 token 的脚手架面前，单行聊天消息的差异只是四舍五入的误差。对于智能体而言，分词器在英文和代码上的表现才是关键数字，无论输入者是谁。
如何真正比较模型价格
- 基于你的内容进行比较，而非标价。你的语言和文件类型决定了乘数。在相信价目表之前，先用每个分词器运行一个有代表性的样本。
- 将分词器变更视为价格变更。当供应商以"相同价格"推出新模型时，检查分词器是否发生了变化。从 Opus 4.6 到 4.8 意味着约 32% 的涨幅，却没有明确的收费项目。
- 以每任务美元数而非每 token 美元数来衡量。"这个构建的实际成本是多少"将分词器和模型的冗长程度结合在一起。供应商自己的使用量字段才是真实依据。
- 将 $/Mtok 视为开场白，而非最终答案。它必要且有用——但在不同分词器之间不具备可比性。
这些都不意味着某个模型是普遍正确的选择。GPT-5.x 在英文和代码上是 token 最精简的选择；Gemini 3 Flash 实际效果出奇地便宜；Claude 的模型即使运行消耗更多 token，也凭借质量赢得一席之地。诚实的解读很简单：你比较的价格应该是你实际支付的价格——在分词器之后，而非之前。
来源（请自行核实标价）：Anthropic 定价（anthropic.com/pricing）、OpenAI 定价（platform.openai.com/docs/pricing）、Google Gemini API 定价（ai.google.dev）、xAI 定价（docs.x.ai）。token 计数来自 Anthropic 的 count_tokens 端点、OpenAI 的 o200k_base（已对照实时 API 使用量验证），以及 Google 和 xAI 的计数端点。生成这些计数时未使用任何文本生成。
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.