What does a million tokens actually buy?
We often compare AI prices as if tokens were a standard unit. But providers count the same text differently, which can change the bill by double-digit percentages.
The views and opinions expressed in this article are my own and do not represent the official positions of Amazon Web Services (AWS).
AI labs are racing to make their models cheaper to use. That got me curious: what would the Claude and GPT price cards look like if they were based on the same amount of text?
It's easy to put prices per million tokens side by side, but a "token" isn't the same unit across providers.
Anthropic gave us a reminder of that in April, when it released Claude Opus 4.7 with a new tokenizer. It was upfront about the change: the same text could use up to 35% more tokens than before.
The experiment
I sent exactly 10,000 words to Claude Opus 5.5 and GPT-6 Sol on Amazon Bedrock and read back the token counts. I used two texts: Pride and Prejudice for English prose, and a repo's technical docs for markdown with code.
- Prose: Claude used 19,645 tokens and GPT used 13,517. That's 45% more tokens on Claude.
- Technical docs: Claude used 21,523 tokens and GPT used 14,000. That's 54% more.
Claude Fable 5.1 gave the same counts, so the same gap applies to both Claude models here.
That should apply to output too. To be sure, I checked anyway: I asked each model to copy the same 10,000 words back verbatim. The counts matched input exactly: +45% for prose and +54% for docs.
What this does to the price card
The providers' standard API prices are $4/$20 per million input/output tokens for Opus 5.5 and $2/$10 for Sol. Fable and Astra both list $10/$50. On paper, that's a 2× gap for the first pair and a tie for the second.
But we're paying for text, so let's compare the same amount of it. Across both samples, Claude used 41,168 tokens and Sol used 27,517: 49.61% more, or about 1.496× as many.
Using that measured ratio, here's the cost in dollars for text that takes up one million Sol tokens. These are unit prices across requests; the 272K cutoff applies to each request's GPT input. Astra's rows assume its token counts match Sol's.
Model | Input | Cache write* | Cache read | Output |
|---|---|---|---|---|
GPT-6 Sol (≤272K) | $2.00 | $2.50 | $0.200 | $10.00 |
GPT-6 Sol (>272K) | $4.00 | $5.00 | $0.400 | $15.00 |
Claude Opus 5.5 | $5.98 | $7.48 | $0.299 | $29.92 |
GPT-6 Astra (≤272K) | $10.00 | $12.50 | $1.000 | $50.00 |
GPT-6 Astra (>272K) | $20.00 | $25.00 | $2.000 | $75.00 |
Claude Fable 5.1 | $14.96 | $18.70 | $0.374 | $74.80 |
For Claude, cache writes use the 5-minute option. Its 1-hour writes would cost $11.97 for Opus and $29.92 for Fable on the same basis. Input, cache writes and cache reads apply to separate portions of a prompt.
Four things stand out:
- Opus 5.5's fresh input and output cost about 3× Sol's at standard context sizes. The measured gap is 2.91× for prose and 3.07× for docs. The prose sample's output tokens cost about $0.39 on Opus and $0.14 on Sol. Above 272K input tokens, the combined-sample gap narrows to about 1.50× for input and 2.00× for output. Cache reads are different: Opus costs about 1.50× Sol's rate below the cutoff, but about 25% less above it.
- Fable vs Astra depends on prompt size and caching. At up to 272K input tokens, Astra is cheaper for fresh input, cache writes and output; Fable is cheaper for cache reads. Above that, Fable is cheaper for fresh input, 5-minute cache writes and cache reads. Output is roughly tied: Fable costs about 3.1% less for prose and 2.5% more for docs. The cheaper overall bill depends on the mix.
- "1M context" doesn't mean the same amount of text. Using the prose sample, Sol's 1.05M-token window works out to roughly 777K words and Claude's 1M-token window to about 509K. Those are text-only estimates, before leaving room for instructions, reasoning and replies.
- The window fills faster, so compaction can come sooner. At the same token threshold, the measured 1.496× ratio leaves room for about 33% less text before the agent needs to compact its history. The actual frequency depends on the agent's threshold and how much history it keeps.Compaction adds summarization work and can lose details the agent still needs. If you cache the history, the new summary needs a fresh cache write, though a separately cached system prompt can stay reusable. In my own agent sessions, the same first call came to about 38K tokens on Claude and 23K on GPT: about 65% more in that example.
Where this matters, and where it doesn't
Token price isn't task price. A coding agent might need several attempts, tool calls and extra reasoning to finish a job. Those all add up. A model with cheaper tokens can still cost more by the time it's done, and benchmarks that measure whole tasks can put the models in a different order.
And fitting more text into a context window doesn't mean making better use of it.
But plenty of production AI work is closer to "text in, text out":
- Summarization of long documents, calls or tickets
- Translation and rewriting
- Extraction and classification over large document sets
- RAG answers where most of the cost is retrieved context
- Content generation at volume, such as product descriptions or reports
For these workloads, the tokenizer difference feeds much more directly into the bill. In my tests, the same text took roughly 1.5× as many tokens on Claude.
So if you're comparing vendors, run your own text through both and count the tokens. Then measure what it costs to finish the job. The price card is only the starting point.
What ratio do you see on your workloads? I'd especially like to hear from anyone testing non-English text or dense code.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article