Anthropic sells Claude by the multiplier. Pro gives you "at least 5x more usage per 5-hour session than Free"; Max is "5x or 20x more usage per 5-hour session than Pro". Nowhere does a plan page tell you how many messages that is, and Anthropic says so plainly — there is no fixed message count, because length and complexity decide how much of the window a request eats.
The API sells the same model by the token. So the two things you are choosing between are not quoted in the same unit, and the usual advice — "just get Max if you use it a lot" — is a guess dressed as a rule.
This converts one into the other. Every figure below was computed with the same functions that run the calculators on this site, against published rates.
What the plans cost
| Plan | Monthly | What it says you get |
|---|---|---|
| Free | $0 | "Free covers everyday questions" |
| Pro | $20 ($17 billed annually, $200 upfront) | "at least 5x more usage per 5-hour session than Free" |
| Max 5x | $100 | "5x more usage per session than the Pro plan" |
| Max 20x | $200 | "20 times more usage per session than the Pro plan" |
Two details matter more than the prices. Limits reset on a rolling five-hour session, with weekly limits on top. And usage is shared across every surface — claude.ai, the desktop app and Claude Code all draw from the same allowance, so "I only use Claude Code" is not a separate budget.
The API has no session window and no weekly cap. It has a bill.
The crossing point, on a chat-shaped request
Start with the easy case: a question of about 700 tokens in and a 900-token answer — a normal exchange, not a document.
| Plan | Per month | Break-even | ≈ per working day |
|---|---|---|---|
| Pro | $20 | 1923 | 87 questions |
| Max 5x | $100 | 9615 | 437 questions |
| Max 20x | $200 | 19231 | 874 questions |
Source: CalculatorAI · calculatorai.app · CalculatorAI subscription-vs-API engine · rates verified 2026-09-09
One such request costs $0.0104 on the API. So Pro pays for itself at roughly 1,900 questions a month, and Max 20x needs about 19,000 — call it 874 a working day, which is a question every thirty-three seconds for eight hours.
If that were the whole story, almost nobody should be on Max. It is not the whole story, and the reason is the shape of the requests, not their number.
Real requests are not chat-shaped
A coding turn is not 700 tokens of input. It carries files, a system prompt, tool definitions and the conversation so far — 18,000 tokens of input against a 1,200-token reply is conservative for an editing session.
| Request shape | One request | Pro | Max 5x | Max 20x |
|---|---|---|---|---|
| Chat question | $0.0104 | 1,923/mo | 9,615/mo | 19,231/mo |
| Coding turn | $0.0480 | 417/mo | 2,083/mo | 4,167/mo |
| Coding turn, 90% cached | $0.0188 | 1,062/mo | 5,308/mo | 10,616/mo |
The same plan buys a quarter as many coding turns as chat questions. Pro's break-even falls from 1,923 requests to 417 — about nineteen a working day, which any real session passes before lunch.
Note also what caching does to that row: it more than doubles the break-even, from 417 to 1,062. On the API, caching the fixed part of a request is billed at roughly a tenth of the base input rate, and it moves the line further than upgrading a plan does.
So is the API cheaper? For single turns, dramatically
Take someone who would describe themselves as a heavy user, on the cached coding shape, twenty-two working days:
| Coding turns a day | Sonnet 5 on the API | Opus 5 on the API |
|---|---|---|
| 20 | $8.29 | $20.72 |
| 60 | $24.87 | $62.17 |
| 150 | $62.17 | $155.43 |
A hundred and fifty coding turns a working day is a lot of work, and on Sonnet it is $62 against $200 for Max 20x. Even on Opus it stays under the plan price.
This is the number people quote when they say the API is cheaper. It is correct, and it is measuring the wrong thing.
The agent loop is where it reverses
A coding "turn" is rarely one call. Ask an agent to do something and it reads, edits, runs, reads the failure and edits again — and each step resends the conversation so far, so input grows roughly with the square of the number of steps. Same model, same caching, twenty tasks a working day:
At fourteen steps on Opus the API costs more than Max 20x — the plan is the cheap option.
Show these figures as a table
| 6 steps per task ($ a month) | 14 steps per task ($ a month) | |
|---|---|---|
| Claude Sonnet 5 | 36 | 146 |
| Claude Opus 5 | 90 | 364 |
Source: CalculatorAI · calculatorai.app · CalculatorAI agent-cost engine · rates verified 2026-09-09
A single call is $4.93 a month. Six steps a task is $35.95. Fourteen steps is $145.70 — nearly thirty times the one-call figure for work a user would describe identically. On Opus the same fourteen-step loop is $364.24 a month, comfortably past Max 20x.
That inversion is the answer to the question in the title. The API is cheaper for people who send requests. The subscription is cheaper for people who start loops.
Expressed as a daily allowance, on Sonnet with an eight-step loop:
| Plan | Agent tasks a working day before the API costs more |
|---|---|
| Pro, $20 | ~10 |
| Max 5x, $100 | ~49 |
| Max 20x, $200 | ~98 |
Ten agent tasks a day is a normal Tuesday. Ninety-eight is not.
Caching beats upgrading
Before changing plan in either direction, price the caching. Same eight-step loop, twenty tasks a day, Sonnet:
| Caching | Per task | Per month |
|---|---|---|
| None | $0.1180 | $71.78 |
| System prompt and tools cached | $0.0928 | $56.45 |
| Conversation cached too | $0.0531 | $32.31 |
Caching the conversation cuts the bill by 55% — more than the difference between two plan tiers, and it changes nothing about the answers. If your agent carries tool definitions from MCP servers, that overhead is its own line item and it is larger than most people expect.
Seats are the part people forget
A subscription is per person. An API key is shared. Five people doing forty cached coding turns a day each:
| Metric | Monthly |
|---|---|
| Five Max 5x seats | $500.00 |
| The same work on the API | $82.90 |
That gap is not a rounding error, and it grows linearly with the team. It is also the case where the comparison is least honest about what you lose: five people on the API need something to type into, and the plan includes that.
What I would actually do
- If your usage is conversational, the API wins and it is not close. Pro needs about 87 questions a working day to pay for itself.
- If you run agents, buy the plan. Ten agent tasks a day already passes Pro; a heavy Opus loop passes Max 20x. Price the loop rather than the request — the AI Agent Cost Calculator models growing context, retries and caching per call.
- Turn on caching before you change anything. 55% on the same work, same model, same output.
- Count seats before you compare. One API key against five subscriptions is a different question from one against one.
- Then check your own numbers, not these. Put your real request sizes into the subscription vs API calculator — it prints the crossing point and how far your current volume sits from it, which is the only figure that decides anything.
One honest caveat, and it is not a small one: this compares price and nothing else. A plan buys an interface, a mobile app, file uploads and a support relationship; an API key buys tokens. If the interface is how you work, the cheaper column is not automatically the right one.
Where these numbers come from
Plan prices and the wording of the limits are Anthropic's own, from the pricing page and the Max plan help article, read on 11 September 2026. CalculatorAI is not affiliated with Anthropic.
Every dollar figure is ours, computed by importing the same functions that run the calculators on this site, against Anthropic's published API rates as verified on the date shown on each calculator page. The assumptions:
- Claude Sonnet 5 at $2 per million input tokens and $10 per million output; Claude Opus 5 at $5 and $25. Cached input is billed at a tenth of the base input rate.
- The chat shape is 700 input tokens and 900 output. The coding shape is 18,000 input and 1,200 output, which is a mid-session edit rather than a first message.
- Agent rows use a 2,000-token system prompt, a 300-token instruction, 350 tokens written per step, 600 tokens returned per tool call, and a context that grows with every step.
- 22 working days a month. No batch discount.
- No retries anywhere. A real agent fails calls, re-reads files and makes a second attempt at a bad plan, so every agent figure here is a floor, not a forecast.
Where the assumptions bias the result: the single-turn rows flatter the API, because they price a request rather than the loop a person actually starts. The agent rows flatter the subscription slightly less than reality would, because retries are excluded. And token counts outside OpenAI's tokenizer are estimates with a stated range — Claude's exact count is not something any calculator can know, ours included.
Related reading
The four numbers that decide any AI bill — the model, the resent prompt, the loop and the length of the answer — are worked through in what AI actually costs once you run it. If your agent has MCP servers attached, their tool definitions ride along on every step and cost more than most people's model usage. And if Claude arrives on your card as a monthly plan rather than a bill, it belongs in a subscription audit with everything else that renews quietly.