Claude Opus 5.5 lists at $4 per million input tokens, GPT-5.5 at $5. On the same code, Opus input costs 28% more
Per-token list prices assume a token is the same amount of text everywhere. It isn't. We sent the same 24 samples of code, diffs, test logs, shell output, tool-call JSON, Markdown and English and Chinese prose to 13 models and read the billed token counts. On code and tool output Claude 5.5 used 1.60 times as many tokens as GPT-5.5, so Opus 5.5 input costs 28% more per character than GPT-5.5 despite a lower per-token price, and Sonnet 5.5 input costs 37% more than Gemini 3 Pro's at the same per-token price.
Choosing GPUs? Compare GPUs for your traffic · Get your node measured, free
Claude Opus 5.5 costs $4 per million input tokens and GPT-5.5 costs $5. We sent both the same 263,763 characters of code, docs and agent tool output. Opus billed 108,871 tokens and GPT-5.5 billed 68,147, so per character, Opus input costs 28% more.
Disclosure: the requests in this test went through CodeRouter, a product our team built, with every model named explicitly, so no routing was involved and each request went to the model we asked for. TokenWatt measures; CodeRouter is ours. Where a model has a public tokenizer, we also counted the text locally, and the bills matched it.
Model price lists compare dollars per million tokens. That works only if a token is the same amount of text on every model, and it isn't. Each model family cuts text into tokens its own way, so the same file costs a different number of tokens on each.
Coding agents mostly send code, diffs, test output, shell output and tool-call JSON, so that's what we measured.
What we measured. 24 text samples, 281,832 characters (291,654 bytes):
- Source code in Python, TypeScript, JavaScript, Go, Rust and Java: whole files from Flask, Requests, Hono, Express, Gin, Cobra, ripgrep, serde_json, Gson and Guava, pinned to a commit.
- Diffs: git diffs from Flask and Hono commits.
- Test and build logs: npm and cargo logs from public CI runs of ky and anyhow.
- Agent tool output: pytest output, grep, find and ls output, git diffs, and the tool calls and results as OpenAI- and Anthropic-format JSON, all from coding-agent sessions we ran on public open-source repositories.
- Prose: Markdown docs from FastAPI and the Rust book, and English and Chinese prose from Wikipedia's "Tea" and "茶" articles.
How we counted. Each sample went to each model twice: once inside a short fixed prompt, and once with the prompt alone. Both requests used the same fresh random tag. The difference in billed input tokens is the cost of the text itself. Every model in the same family billed exactly the same count on all 24 samples: Opus, Sonnet and Haiku 5.5; GPT-5.5 and GPT-5 mini; Gemini 3 Pro and 3 Flash; DeepSeek V4.1 Flash and V4 Pro; Qwen Plus and Qwen Max. The tables therefore show seven tokenizers.
Tokens per 1,000 characters
| Content | Claude 5.5 | GPT-5.x | Gemini 3 | Kimi K2.6 | DeepSeek V4 | GLM-5.3 | Qwen |
|---|---|---|---|---|---|---|---|
| Python | 356 | 228 | 265 | 227 | 242 | 227 | 229 |
| TypeScript / JavaScript | 405 | 259 | 301 | 258 | 267 | 255 | 256 |
| Go | 426 | 236 | 280 | 244 | 255 | 239 | 240 |
| Rust | 375 | 235 | 276 | 238 | 253 | 236 | 237 |
| Java | 387 | 243 | 275 | 243 | 249 | 236 | 238 |
| Git diffs | 439 | 270 | 336 | 267 | 289 | 271 | 282 |
| pytest output | 459 | 253 | 315 | 246 | 282 | 252 | 259 |
| npm / ava log | 373 | 223 | 232 | 235 | 227 | 222 | 224 |
| cargo test log | 518 | 362 | 381 | 361 | 372 | 366 | 367 |
| grep / find / ls output | 425 | 252 | 324 | 250 | 279 | 254 | 268 |
| Tool-call JSON | 464 | 289 | 338 | 285 | 307 | 292 | 300 |
| Markdown docs | 377 | 263 | 291 | 259 | 270 | 263 | 272 |
| All code and tool output | 413 | 258 | 302 | 258 | 273 | 258 | 263 |
| English prose | 347 | 218 | 220 | 221 | 218 | 223 | 227 |
| Chinese prose | 1,133 | 840 | 766 | 654 | 680 | 689 | 725 |
"All code and tool output" pools the 20 samples that aren't prose (263,763 characters). Almost all of it is ASCII, so tokens per 1,000 characters is also, within 1%, tokens per kilobyte.
As a multiple of GPT-5.5's count:
| Claude 5.5 | GPT-5.x | Gemini 3 | Kimi K2.6 | DeepSeek V4 | GLM-5.3 | Qwen | |
|---|---|---|---|---|---|---|---|
| All code and tool output | 1.60× | 1.00× | 1.17× | 1.00× | 1.06× | 1.00× | 1.02× |
| Range across the 12 code and tool-output types | 1.43–1.81× | 1.00× | 1.04–1.28× | 0.97–1.05× | 1.02–1.11× | 0.97–1.01× | 0.98–1.06× |
| English prose | 1.59× | 1.00× | 1.01× | 1.01× | 1.00× | 1.02× | 1.04× |
| Chinese prose | 1.35× | 1.00× | 0.91× | 0.78× | 0.81× | 0.82× | 0.86× |
Claude's gap is widest on pytest output and Go (1.81×) and narrowest on cargo logs (1.43×) and Markdown (1.44×). Across all 24 samples, Claude billed 118,636 tokens and GPT-5.5 billed 74,852.
What that does to the price list
Price per million characters is the per-token list price times tokens per character. Here it is for the pooled code and tool output, sorted by input price per character:
| Model | Input, per 1M tokens | Input, per 1M characters | Cache hit, per 1M tokens | Cache hit, per 1M characters | Output, per 1M tokens | Output, per 1M characters |
|---|---|---|---|---|---|---|
| Claude Opus 5.5 | $4.00 | $1.65 | $0.20 | $0.083 | $20.00 | $8.26 |
| GPT-5.5 | $5.00 | $1.29 | $0.50 | $0.13 | $30.00 | $7.75 |
| Claude Sonnet 5.5 | $2.00 | $0.83 | $0.10 | $0.041 | $10.00 | $4.13 |
| Gemini 3 Pro | $2.00 | $0.60 | $0.20 | $0.060 | $12.00 | $3.62 |
| Qwen Max | $1.60 | $0.42 | $0.32 | $0.084 | $6.40 | $1.68 |
| GLM-5.3 | $1.40 | $0.36 | $0.26 | $0.067 | $4.40 | $1.14 |
| DeepSeek V4 Pro | $1.32 | $0.36 | $0.044 | $0.012 | $3.96 | $1.08 |
| Kimi K2.6 | $0.95 | $0.25 | $0.16 | $0.041 | $4.00 | $1.03 |
| Gemini 3 Flash | $0.50 | $0.15 | $0.050 | $0.015 | $3.00 | $0.91 |
| Qwen Plus | $0.40 | $0.11 | $0.080 | $0.021 | $1.20 | $0.32 |
| DeepSeek V4.1 Flash | $0.30 | $0.082 | $0.0060 | $0.0016 | $1.20 | $0.33 |
| GPT-5 mini | $0.25 | $0.065 | $0.025 | $0.0065 | $2.00 | $0.52 |
| Claude Haiku 5.5 | $0.10 | $0.041 | $0.010 | $0.0041 | $0.50 | $0.21 |
Prices are the providers' list prices on November 5, 2026 (standard tier, short-prompt pricing; Gemini 3 Pro means gemini-3.1-pro-preview). DeepSeek is shown at its peak price, which applies 01:00–04:00 and 06:00–10:00 UTC on weekdays; the rest of the week is half that. Qwen is Alibaba Cloud's international price, with non-thinking output (the Chinese mainland region is cheaper); its cache-hit price is the implicit cache's 20% of input. GPT-5 mini is deprecated, with a December 11, 2026 shutdown. Kimi K2 models closed to new users on October 31 and are due to retire by the end of December.
What changes once you price the text instead of the token:
- Opus 5.5 and GPT-5.5 swap places. Opus is 20% cheaper per input token ($4 against $5) and 28% more expensive per character of code ($1.65 against $1.29 per million characters). On output, Opus is a third cheaper per token ($20 against $30) and 6.5% more expensive per character ($8.26 against $7.75).
- The same price isn't the same price. Sonnet 5.5 and Gemini 3 Pro both list at $2 per million input tokens. On the same code, Sonnet input costs 37% more ($0.83 against $0.60 per million characters), and its output costs 14% more even though its output price per token is lower ($10 against $12).
- Cheap stays cheap. Per character of input and of output, Haiku 5.5 is still the cheapest model here (on cache hits, DeepSeek V4.1 Flash is cheaper). Its lead over GPT-5 mini shrinks, though: it's 60% cheaper per token and 36% cheaper per character.
- Cache hits still favor Claude. Opus 5.5 and Sonnet 5.5 bill cache hits at 5% of the input price, against 10% on GPT-5.5. Per character, an Opus cache hit still costs 36% less than a GPT-5.5 one. Claude also bills cache writes (1.25× the input price for a 5-minute cache), so for an agent that rereads most of its context, run your own cache-hit and cache-write mix through these numbers.
- Chinese reverses part of it. On Chinese prose Claude uses more than one token per character (1,133 per 1,000). Kimi K2.6 uses 22% fewer tokens than GPT-5.5, and DeepSeek V4, GLM-5.3, Qwen and Gemini 3 use 9–19% fewer.
Three checks
The bill matches the public tokenizers. For GPT-5.5 and GPT-5 mini (tiktoken's o200k_base), DeepSeek V4.1 Flash and V4 Pro, Kimi K2.6, GLM-5.3 and Qwen Plus and Max, we ran the published tokenizer on the same text. The billed count matched within one token on every sample. That one token is where the sample meets our fixed prompt. We found no hidden overhead on the text itself. Qwen Plus and Max matched the Qwen3 tokenizer (Qwen3-235B-A22B-Instruct-2507). The newer Qwen3.8 tokenizer counts 5% more tokens on the same text. Claude and Gemini publish no tokenizer, so for them the providers' billed counts are the only source. Three Claude samples sent through Anthropic's own request format, instead of the OpenAI format, gave identical counts.
Claude's newer tokenizer. Anthropic's pricing page says Claude 4.7 and later models use a newer tokenizer that "produces approximately 30% more tokens for the same text". We ran the same 24 samples on Claude Haiku 4.5, which still uses the previous tokenizer. On code and tool output, Claude 5.5 used 1.29 times as many tokens, in line with Anthropic's figure. On English prose it used 1.44 times as many, and on Chinese 1.005 times. Five samples on Sonnet 4.6 matched Haiku 4.5's counts exactly.
Output tokens follow the same tokenizer. We asked every model to repeat a 1,179-character Python snippet word for word. Claude 5.5 wrote 459 tokens, against 458 for the same text as input. GPT-5.5 wrote 285 against 276, Gemini 3 Pro 314 against 315, Qwen 277 against 277. So the output ratios follow the input ones. Reasoning tokens come on top, are billed as output and aren't text, so they don't appear in these counts.
How we did it, and the limits
- The text only. Each count is the billed input tokens of the prompt with the text minus the same prompt without it. Each request was one user message, with no system prompt and no tools, and a 1-token output limit. GPT-5.x rejects limits that low, so it got 16 (64 on one retry). Chat formatting, tool definitions and images cost the same in both requests, so they aren't in these numbers. We measured tool-call JSON as text; a provider's native tool-call format is rendered before it's counted.
- One corpus. 24 samples, about 290 KB. The Chinese sample is the smallest, at 4,441 characters (12.8 KB). Minified code, base64, CSV, comments in other languages or other programming languages will give different numbers. The npm and cargo logs come from CI runs, with timestamps and color codes removed. Our numbers are the exact counts for these samples, and only an approximation for any other text.
- Price per character isn't cost per task. It compares the same input text. To finish the same task, models write different amounts, reason for different lengths and take different numbers of steps, so a task can cost more on a model that is cheaper per character, or less. Measuring that takes the same tasks run on each model.
- Repeatable. Counts are deterministic: the 52 sample–model pairs we ran twice gave identical counts.
- One day's list prices. We used no discounts, batch pricing or long-prompt tiers.
- Through our own product. Requests went through CodeRouter's explicit-model path. CodeRouter passes the message text to the provider unchanged and reports the provider's usage. Its compression was off; it only acts on prompts near the context limit in any case. Where a public tokenizer exists, the counts match it to within the one boundary token.
Data
Per-sample counts for every model and tokenizer, with each sample's source link, commit, license and SHA-256 hash, plus the prices and their sources: /data/tokenizer-tax/. The corpus files themselves aren't republished; each one is pinned by URL and hash.
Keep reading
Where a coding agent's bill goes: output is under 10% of it
385 developer-days of our own team's coding-agent traffic at list prices: output is under 10% of the bill, the most expensive tenth of days is over half of it, and heavy days cost more per request, not only more requests.
What a coding agent costs per developer: 385 developer-days of our own usage
Five months of our own team's coding-agent traffic: 163 requests and $4.30 on a typical developer day, 378 requests and $13.03 on a heavy one, at list prices with routing (corrected November 7). How that compares with Claude's subscription and seat plans, what moved the bill, and what these numbers don't tell you.
The pi adapter for Qwen3.8-27B on FP8: 3× fewer turns held up, the accuracy gain was smaller
harness-hub's pi adapter is a LoRA that teaches Qwen3.8-27B to work inside the pi coding agent. Its card reports 39.5% → 55.8% on Terminal-Bench 2.1 on BF16 weights. We serve the FP8 checkpoint, so we tested it there: on 25 Terminal-Bench tasks under pi, the adapter solved 17 and the base model 14, a gap too small to call on 25 tasks. Its efficiency held clearly: on the 12 tasks both solved, it needed 9.5 turns against 28.5 and 1,432 output tokens against 5,254 (medians). It also ran 10 minutes without a fault under the long-context load that crashed MTP on our shared GPU. It's on our API now at Qwen3.8's price.