Claude has six plans: Free (20/month), Max (200/month), Team and Enterprise. Every paid plan includes Claude Code; Free does not. A subscription is usually the better deal for steady daily use, and the pay-as-you-go API is better for apps, automation and batch jobs.
Below is the plan table, a plain explanation of how API token pricing works, and a small dependency-free Python script, claude_cost.py, that turns token volumes into dollars and compares them with plan prices. If you are new to the unit, what a token is is worth a quick read first.
One caveat: all prices here were checked on 2026-11-20 on the official Claude pricing page and the API pricing docs. They change, so confirm there before you buy. The script uses published list prices only. It is a rough estimator, not a billing tool, and it does not model prompt caching.
Claude pricing plans at a glance
| Plan | Price | What the pricing page says |
|---|---|---|
| Free | $0 | Limited usage every 5 hours and weekly. No Claude Code, no Opus. |
| Pro | 17/month billed annually ($200 up front) | Claude Code included. No API credit. |
| Max | $100/month | 5x Pro usage. Claude Code included. $100/month API credit. Fable included up to half the weekly limit. |
| Ultra | $200/month | 10x Pro usage per week. No 5-hour limit for verified accounts. Claude Code included. $200/month API credit. |
| Team, Standard seat | 20/month annual | 2 to 150 seats. Claude Code included. |
| Team, Premium seat | 100/month annual | 5x Standard usage. Claude Code included. Team API credit is pooled, up to $500/month. |
| Enterprise | $20/seat/month, annual, 20-seat minimum | Plus usage billed at API rates. Claude Code included. |
Subscription usage limits are described only as multipliers of Pro. Anthropic does not publish a token count per plan, so you cannot convert “5x Pro” into dollars exactly.
Which Claude plans include Claude Code?
Every paid plan includes Claude Code: Pro, Max, Ultra, Team (Standard and Premium seats) and Enterprise. The Free plan does not.
You can also run Claude Code against API billing instead of a subscription. In that case you pay per token and the plan multipliers no longer apply.
Check your install and see what Claude Code reports about itself:
claude --versionInside a Claude Code session, two slash commands help you see where you stand:
/costreports token usage and cost for the current session, which is most useful when you are on API billing./statusshows account and session status.
What each one prints depends on your version and login type, so run them yourself rather than trusting a pasted example. If you plan to run Claude Code unattended, read the dangerously-skip-permissions guide first. To keep repeated instructions short, see Claude Code skills and SKILL.md.
What is the monthly API credit on Max, Ultra and Team?
Max and Ultra include a monthly API credit equal to the plan price: 200/month on Ultra. Team has a pooled API credit of up to $500/month. Pro has none.
This matters if you build small projects. A side project that calls the API a few thousand times a month may fit inside the credit, so you pay nothing beyond the subscription. Larger or production workloads will exceed it and should be priced on the API rates below.
How Claude API token pricing works
You pay per million tokens (MTok), with separate rates for input (your prompt and context) and output (what the model writes). Output is priced higher. Here are the rates from the API docs, as of 2026-11-20:
| Model | Input per MTok | Output per MTok |
|---|---|---|
| Fable 5.2 | $8 | $40 |
| Opus 5.5 | $4 | $20 |
| Sonnet 5.5 | $2 | $10 |
| Haiku 5.5 | 0.50 above | 2.50 above |
Two features change the bill:
- Batch API: 50% off, for work that does not need an immediate answer.
- Prompt caching: writing to a 5-minute cache costs 1.25x the input price and a 1-hour cache write costs 2x. Reading from the cache costs 0.1x on most models and 0.05x on Opus 5.5 and Sonnet 5.5.
Worked out for the two models used below:
| Model | Input | 5-min cache write | 1-hour cache write | Cache read |
|---|---|---|---|---|
| Sonnet 5.5 | $2.00 | $2.50 | $4.00 | $0.10 |
| Opus 5.5 | $4.00 | $5.00 | $8.00 | $0.20 |
All figures are per MTok. Caching pays off when you resend the same long context many times, such as a big codebase prompt or a long system prompt.
Estimate your own cost with a Python script
Save this as claude_cost.py. It needs only Python 3 and no packages. It prints the API cost for a token volume, the batch price, and how that cost compares with the Pro, Max and Ultra monthly prices.
import argparse
# (input, output) in USD per million tokens, from the published API pricingPRICES = { "fable-5.2": (8.00, 40.00), "opus-5.5": (4.00, 20.00), "sonnet-5.5": (2.00, 10.00), "haiku-5.5": (0.10, 0.50),}HAIKU_LONG_PROMPT = (0.50, 2.50) # prompts above 100k tokensBATCH_FACTOR = 0.5 # Batch API is 50% offPLANS = {"Pro": 20, "Max": 100, "Ultra": 200} # USD per month, billed monthly
def api_cost(tokens_in, tokens_out, price): return tokens_in / 1_000_000 * price[0] + tokens_out / 1_000_000 * price[1]
def main(): parser = argparse.ArgumentParser(description="Estimate Claude API cost for a token volume.") parser.add_argument("--model", required=True, choices=sorted(PRICES)) parser.add_argument("--input", type=int, required=True, help="input tokens per month") parser.add_argument("--output", type=int, required=True, help="output tokens per month") parser.add_argument( "--long-prompts", action="store_true", help="haiku-5.5 only: use the rate for prompts above 100k tokens", ) args = parser.parse_args()
price = PRICES[args.model] if args.model == "haiku-5.5" and args.long_prompts: price = HAIKU_LONG_PROMPT
cost = api_cost(args.input, args.output, price) batch = cost * BATCH_FACTOR
print(f"Model: {args.model}") print(f"Tokens: {args.input:,} input, {args.output:,} output") print(f"Rates per MTok: ${price[0]:.2f} input, ${price[1]:.2f} output") print(f"API cost: ${cost:,.2f}") print(f"Batch cost: ${batch:,.2f}") print() print("Plan comparison (API cost for this volume vs plan price):") for name, monthly in PLANS.items(): if cost > 0: months = monthly / cost ratio = cost / monthly print( f" {name:<6} ${monthly}/month " f"API is {ratio:.2f}x the plan price, " f"plan price covers {months:.2f} months of this volume" ) else: print(f" {name:<6} ${monthly}/month API cost is zero")
if __name__ == "__main__": main()Check your Python version, then run the same volume (20 million input tokens and 2 million output tokens a month) on Sonnet 5.5:
python3 --versionpython3 claude_cost.py --model sonnet-5.5 --input 20000000 --output 2000000
Now the same volume on Opus 5.5:
python3 claude_cost.py --model opus-5.5 --input 20000000 --output 2000000
You can check the script by hand. For Sonnet 5.5, 20 MTok in at 10 gives 4 plus 2 MTok at 120. The batch figures should be exactly half of those.
How to read the break-even lines
“API is 1.00x the plan price” means the API would cost exactly what the plan does for that volume. Anything above 1.00x means the API is more expensive than that plan, if you could fit that work inside the plan’s limits.
That last condition is the catch. A subscription has usage limits, and the API does not, so a heavy workload may simply not fit in Pro. The comparison tells you what the same tokens cost on the API, not whether the plan will let you use them.
Subscription vs API: when each is cheaper
A subscription wins when your usage is steady, interactive and heavy, such as hours of Claude Code every day. You pay a flat price, and the usage multipliers (5x Pro on Max, 10x Pro weekly on Ultra) cap your exposure. An API bill for the same interactive work grows with every token and can be hard to predict.
The API wins when usage is bursty, automated or small:
- Apps and automation: your code calls the model, so you need an API key and per-token billing.
- Batch jobs: the Batch API’s 50% discount has no subscription equivalent.
- Very light use: a few calls a month cost far less than $20.
- Repeated long context: cache reads at 0.1x or 0.05x of the input price cut costs sharply.
If you are choosing between giving a model tools through a protocol and calling an API directly, MCP vs API covers that separate question. Model choice also affects cost and quality, which is the subject of Fable 5.2 effort levels.
Which plan should you pick?
- Light chat use: start on Free, then move to Pro (17/month billed annually) once you hit the limits or want Claude Code.
- Daily Claude Code work: Max (200/month), depending on how often you hit limits. Ultra removes the 5-hour limit for verified accounts.
- Apps, automation and batch jobs: use the API. The monthly API credit on Max or Ultra can cover a small API project, so you may not need a second bill.
- Teams: Team seats start at 20/month annual, with Premium seats at 5x Standard usage and a pooled API credit. Enterprise adds a 20-seat minimum and usage at API rates.
FAQ
What is the difference between a Claude subscription and the Claude API?
A subscription gives you a flat monthly price with usage limits expressed as multipliers of Pro. The API charges per million input and output tokens with no fixed fee. They are billed separately, apart from the monthly API credit on Max, Ultra and Team.
Does the Free plan include Claude Code?
No. According to the pricing page, Free has limited usage every 5 hours and weekly, with no Claude Code and no Opus. Pro is the cheapest plan that includes Claude Code.
Is the Batch API worth using?
If the work can wait, yes. The Batch API is 50% off the standard token prices, and the script’s batch line shows the saving for your volume.
How do I see what Claude Code is costing me?
Run /cost inside a Claude Code session and /status for account details. On API billing you can also multiply your token counts by the per-MTok rates, which is what claude_cost.py does.