The most expensive Claude plan costs $200 a month. At API prices, the usage it allows could be worth about $11,000 a month.
I did not measure that plan. I measured mine. I pay $100 a month for Max 5x, and in the last 30 days my Claude Code usage would have cost about $5,000 at API prices. The weekly limit stopped me twice, and those stops let me put a dollar value on the plan: about $5,500 a month. The $200 plan allows twice as much usage per week, so it is worth about twice as much.
Anthropic sells its plans in "times Pro usage", not in dollars, so the plan page does not show these numbers. I calculated them from the transcripts that Claude Code keeps on my disk.
In this article I'll show how I measured it, what each plan is worth in API dollars, where the tokens went, and why your own number is probably smaller.
The case: one developer (me), one machine, Claude Code on the Max 5x plan, from October 4 to November 3, 2026. Most of the work was coding with agents on Claude Opus 5.5. Every number in this article is an estimate from my own usage, and the $11,000 is an extrapolation from my plan to the $200 one. Anthropic does not publish its limits in dollars, and I have no data on what my usage costs Anthropic.
The Result
| Plan | Price per month | Usage it allows, at API prices | Ratio |
|---|---|---|---|
| Max 5x (mine, measured) | $100 | ~$5,500 | ~55× |
| Ultra (extrapolated) | $200 | ~$11,000 | ~55× |
And my real month on Max 5x: I paid $100 and used ~$5,000 at API prices. That is $3.30 a day against $160 a day, a 98% discount.
How I Measured It
Claude Code writes every session to a JSONL file under ~/.claude/projects/. Each answer from the model carries a usage block with four counts: input tokens, cache writes, cache reads and output tokens. I summed every answer of the 30 days, from the main sessions and from the subagents, and priced each one with the public API price table:
| Model | Input | Cache write (5 min / 1 h) | Cache read | Output |
|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $5 / $8 | $0.20 | $20 |
| Claude Sonnet 5.5 | $2 | $2.50 / $4 | $0.10 | $10 |
The prices are in US$ per million tokens, from Anthropic's pricing page on November 3, 2026. Opus 5.5 was 96% of my cost.
What My Plan Is Worth
The Max 5x plan has two limits: one per 5 hours and one per week. I hit both. Each stop shows a message with the time of the reset, so I summed the API-equivalent usage inside each window, up to the stop.
| Limit | Times I hit it | API-equivalent at the stop |
|---|---|---|
| Weekly | 2 | ~$1,250 |
| 5 hours | 3 | ~$150 to ~$180 |
A week has 33.6 windows of 5 hours, and the weekly limit runs out after 7 or 8 full ones. So for heavy work, the weekly limit is the one that stops you. Both times, it stopped me on a Saturday, about one day before the weekly reset.
From the weekly limit, the monthly ceiling is about $1,250 × 4.35 ≈ $5,500 of API usage for $100, about 55 times the price. In these 30 days, I used about 90% of it.
What the $200 Plan Is Worth
The Ultra plan costs $200. It gives "10x Pro usage" per week instead of "5x", and it has no 5-hour limit for verified accounts.
If 10x is exactly twice 5x, its weekly ceiling is about $2,500 of API usage, and its monthly ceiling is about $11,000. Both plans also include API credits for the Claude Platform: $100 a month on Max and $200 on Ultra. I did not count them here.
The ratio stays at about 55×. The $200 plan does not make a token cheaper. It buys twice the room, and it removes the 5-hour stop. I don't have Ultra, so this number is an extrapolation from my measurements, not a measurement.
Where the Tokens Went
| Token type | Tokens | API cost | Share of cost |
|---|---|---|---|
| Cache reads | 13.9 billion | ~$2,700 | 54% |
| Cache writes | 0.2 billion | ~$1,400 | 28% |
| Output | 0.05 billion | ~$900 | 18% |
| Input without cache | almost zero | ~$0 | 0% |
| Total | ~14 billion | ~$5,000 |
98% of my tokens were cache reads. An agent sends the whole conversation again on every call: the instructions, the files it read, the tool results. I made about 56,000 calls, and each one read a large context again.
The prompt cache makes that cheap. On Opus 5.5, a cache read costs $0.20 per million tokens, 5% of the input price. Even so, the context is most of the bill: cache reads and cache writes together are 82% of the cost. The output, which includes all the code the model wrote, is only 18%.
Why Your Number Is Probably Smaller
A plan is worth what you actually use, and I am a heavy user.
Anthropic's Claude Code documentation says that across enterprise deployments, the average developer costs about $13 per active day and $150 to $250 per month at API prices. On the $100 plan, that is a discount of about 35% to 60%. That is still a good deal, but it is far from 98%.
To use $11,000 a month on the $200 plan, you would need about 45 to 75 times the usage of that average developer. My usage was 20 to 30 times that average, and it filled about 90% of my $100 plan.
Is Anthropic Losing Money on Me?
I don't know. The API price is a list price, not a cost. Anthropic itself sells the same tokens at different prices: the Batch API costs 50% of the normal price, and a cache read costs 5% of an input token. 98% of my tokens were the cheapest kind. Many subscribers also use much less than the ceiling.
I found analyst estimates of Anthropic's margins, but they disagree with each other and I could not verify them, so I don't quote them here. What I can say is narrower: my subscription price is not a cost, and the API price is not a cost either.
Measure Your Own
Here is the script I used, cut to the essentials. It reads your transcripts, removes duplicates and prints the API-equivalent cost since a date:
"""What would my Claude Code usage cost at API prices?
Reads the transcripts under ~/.claude/projects and prices every assistant
message with the public API price table. Usage: python3 claude_api_equivalent.py 2026-10-04
"""
import glob
import json
import os
import sys
from collections import Counter
# US$ per million tokens: input, 5-minute cache write, 1-hour cache write, cache read, output.
PRICES = {
"claude-opus-5-5": (4.00, 5.00, 8.00, 0.20, 20.00),
"claude-sonnet-5-5": (2.00, 2.50, 4.00, 0.10, 10.00),
"claude-fable-5-1": (10.00, 12.50, 20.00, 0.25, 50.00),
}
since = sys.argv[1] if len(sys.argv) > 1 else "0000"
seen, dollars, tokens, unpriced = set(), Counter(), Counter(), Counter()
for path in glob.glob(os.path.expanduser("~/.claude/projects/**/*.jsonl"), recursive=True):
if not os.path.isfile(path): # skip broken links
continue
with open(path, errors="replace") as handle:
for line in handle:
if '"usage"' not in line:
continue
try:
entry = json.loads(line)
except json.JSONDecodeError:
continue
message = entry.get("message") or {}
usage, model, message_id = message.get("usage"), message.get("model"), message.get("id")
# A resumed session copies old messages into a new file, so dedupe across files.
if entry.get("type") != "assistant" or not usage or message_id in seen:
continue
if entry.get("timestamp", "") < since or model == "<synthetic>":
continue
seen.add(message_id)
if model not in PRICES:
unpriced[model] += 1
continue
cache = usage.get("cache_creation") or {}
write_1h = cache.get("ephemeral_1h_input_tokens") or 0
write_5m = (usage.get("cache_creation_input_tokens") or 0) - write_1h
counts = {
"input": usage.get("input_tokens") or 0,
"cache write": write_5m + write_1h,
"cache read": usage.get("cache_read_input_tokens") or 0,
"output": usage.get("output_tokens") or 0,
}
p_in, p_5m, p_1h, p_read, p_out = PRICES[model]
dollars["input"] += counts["input"] * p_in / 1e6
dollars["cache write"] += (write_5m * p_5m + write_1h * p_1h) / 1e6
dollars["cache read"] += counts["cache read"] * p_read / 1e6
dollars["output"] += counts["output"] * p_out / 1e6
tokens.update(counts)
total = sum(dollars.values())
print(f"{len(seen):,} messages, {sum(tokens.values()) / 1e9:.2f} billion tokens, US$ {total:,.0f} at API prices")
for kind in ("cache read", "cache write", "output", "input"):
print(f" {kind:12} {tokens[kind] / 1e6:>10,.1f} M tokens US$ {dollars[kind]:>8,.0f}")
if unpriced:
print("Not priced (add them to PRICES):", dict(unpriced))
Run it with a start date: python3 claude_api_equivalent.py 2026-10-04. It takes a few seconds. It prices only the models in PRICES, and it lists the other models it finds, so you can add their prices. It can only measure the transcripts that are still on your disk: my oldest ones were already gone.
The Limitations
- The $11,000 is an extrapolation. I measured only Max 5x. The Ultra number assumes that "10x Pro" is exactly twice "5x Pro".
- One user, one machine. My usage on claude.ai also counts toward the limit, and the script cannot see it. The real ceiling may be a little higher.
- The limit is not in dollars. My dollar ceiling depends on my mix: 96% Opus and a large cache. The 5-hour window that was mostly Sonnet stopped at ~$150, and the Opus windows at ~$175. So the limit does not weigh tokens exactly by API price.
- Small samples. I have two weekly stops and three 5-hour stops.
- The API price is not Anthropic's cost. The value is against a list price.
- Prices change. I used the prices of November 3, 2026.
Conclusion
- My $100 plan is worth about $5,500 a month at API prices. Last month, I used about $5,000 of it.
- The $200 plan, by the same math, could be worth about $11,000 a month.
- Both plans give about 55 times their price, if you use them to the limit.
- Most people use much less. For an average developer, the $100 plan is a discount of 35% to 60%.
- 98% of my tokens were cache reads. The context, not the code the model writes, is most of the bill.
- Measure your own number. It takes one script and a few seconds.
Your Claude plan could be worth $11,000 a month. Mine was worth $5,000 last month, and I paid $100 for it.
Top comments (0)