Claude Code Pro vs Max in 2026: Usage Limits, Fable Access and the New API Credits

TL;DR

Claude Code Pro costs $20 a month, Max 5x costs $100 and Max 20x costs $200. Every plan bills interactive Claude Code, claude -p and the Agent SDK against the same subscription limits. The June 15, 2026 change that would have moved headless usage into a separate API-rate pool was paused on the day it was due and never came back. Two things now separate Pro from Max. The first is capacity: 5x or 20x Pro’s per-session allowance. The second is a pair of perks Pro doesn’t get. Fable 5 and 5.1 are included in Max limits (up to half your weekly allowance), and since October 7, Max comes with $100 or $200 a month in Claude API credits. If you only code interactively and rarely hit limits, Pro is enough. If you also pay an API bill of $80 or more a month, Max 5x costs about the same as the bill it replaces.

What Happened to the June 15 Billing Change

This page originally covered a change that never shipped. Here’s how it played out.

In May 2026, Anthropic announced that from June 15, programmatic Claude Code usage would stop counting against subscription limits. That meant claude -p (headless mode), Claude Agent SDK projects, the Claude Code GitHub Action and third-party apps that authenticate through the Agent SDK. Each plan would instead get a monthly credit pool billed at API rates, reported at the time as $20 on Pro, $100 on Max 5x and $200 on Max 20x. Interactive terminal sessions would stay on the subscription. For anyone running agents in CI, that looked like a real price increase, and plenty of coverage (this article included) worked through the math.

On June 15 itself, Anthropic paused it. The New Stack reported the reversal the same day, and the Anthropic help article on using the Agent SDK with your plan still reads: “We’ve paused the previously-announced changes to Claude Agent SDK usage.” Its current wording is unambiguous: “Claude Agent SDK, claude -p, and third-party app usage still draw from your subscription limits.”

The story picked up again on October 7, 2026. Instead of reviving the split, Anthropic updated the same article to say Max and Team plans now include monthly API credits. The help page for those credits says the Agent SDK credits “announced in June” aren’t available. A Hacker News thread on the update tracked the wording change from the October 6 version of the page to the October 7 one.

The net result as of mid-October:

• Headless and SDK usage on a subscription login works the way it did before June. It shares your five-hour and weekly limits with interactive use.
• Max subscribers get a separate API balance on top, for work that runs through an API key.
• Pro is unchanged, and no subscription price went up.

Every Plan, Side by Side

Three details in that table need explaining.

Claude chat and Claude Code share one set of limits. Anthropic’s article on using Claude Code with Pro or Max says activity in either counts toward the same totals, IDE usage included. A long research chat in the morning means less Claude Code headroom in the afternoon.

The 5x and 20x multipliers apply per session. The Max plan article defines Max 5x as “five times the Pro plan’s per-session usage allowance” and Max 20x as “20 times.” Weekly caps exist on every paid plan, and Anthropic doesn’t publish them as a multiple of Pro, so don’t assume Max 20x buys exactly four times Max 5x’s weekly ceiling.

There’s also a small difference when a session limit lands mid-response. Claude Code may finish the step it’s on and show “Usage limit reached · wrapping up.” Pro gets that grace once per weekly period. Max gets it every time a session limit hits, within the weekly cap.

The Fable Question

For many users, Fable access is now the main difference between the plans. Fable 5 and Fable 5.1 are Anthropic’s top coding models (the Fable 5 review covers the benchmarks and the fine print). The Fable plan article says of Pro: “Fable 5 and Fable 5.1 aren’t included in your plan’s usage limits.” On Pro, every Fable token runs on pay-as-you-go usage credits from the first prompt, at API rates. Fable 5.1 lists at $10 per million input tokens and $50 per million output tokens on the API pricing page.

On Max, Fable is “included as a standard part of your plan,” and you can spend up to 50% of your weekly usage limits on it. The article doesn’t separate Max 5x from Max 20x here, so both get the same 50% share of their own (different) limits.

My read: if you want Fable as your daily driver in Claude Code, Pro doesn’t really work as a plan. You’d be paying $20 for the subscription and then the full API price for the model you actually use. Opus and Sonnet models are covered on Pro (the pricing page lists Opus among Pro’s models), and for most interactive work they’re the sensible default anyway. The AI coding models hub ranks where each one wins.

What the Max API Credits Actually Cover

The October 7 credits are easy to misread. They’re a balance on the Claude Developer Platform that only API-key work can spend. Per the credits help article:

Claiming them takes a few steps. You have to be the Max subscriber and have been on the plan for at least seven days. You also link exactly one Claude Console organization, where you need the Owner, Admin or Billing role. Each Console organization can only receive credits from one plan, and switching the linked organization means contacting support. No card is required on the Console side. The help article says usage “is never charged to your Claude plan,” and unused credits expire at the end of each billing cycle. Team plans get $20 per Standard seat and $100 per Premium seat, pooled and capped at $500 a month.

The practical consequence: Claude Code authenticated with your subscription login never touches this balance. To spend it from Claude Code tooling, you run claude -p or an SDK project with an ANTHROPIC_API_KEY from the linked organization. That moves those runs off your plan limits and onto the credit. For CI jobs that’s often exactly what you want, because a nightly agent pipeline stops eating into the five-hour window you need for interactive work.

What $100 or $200 of Credit Buys

To put the credit in task terms, I wrote a short script against the current list prices. The workload is an assumption, not a measurement: one PR review that reads 80K tokens of context (60K of it from prompt cache), plus 20K fresh input and 6K output. Cache-write costs are left out to keep it simple.

"""What Claude Max's monthly API credits buy at list prices (verified 2026-10-15).

Prices: https://platform.claude.com/docs/en/about-claude/pricing, $ per million tokens.
The task profile is an assumption (a mid-sized PR review), not a measurement.
"""

PRICES = {  # model: (input, cache_read, output)
    "Haiku 5.5":  (0.10, 0.01, 0.50),   # prompts up to 100K tokens
    "Sonnet 5.5": (2.00, 0.10, 10.00),
    "Opus 5.5":   (4.00, 0.20, 20.00),
    "Fable 5.1":  (10.00, 0.25, 50.00),
}

# One PR review: 80K tokens of context read, 60K of it served from cache,
# 20K fresh input, 6K output. Cache writes are ignored for simplicity.
FRESH_IN, CACHED_IN, OUT = 20_000, 60_000, 6_000
CREDITS = {"Max 5x": 100, "Max 20x": 200}


def task_cost(model: str) -> float:
    inp, cache, out = PRICES[model]
    return (FRESH_IN * inp + CACHED_IN * cache + OUT * out) / 1_000_000


print(f"{'model':<11} {'$/review':>9} {'reviews/$100':>13} {'reviews/$200':>13}")
for model in PRICES:
    c = task_cost(model)
    print(f"{model:<11} {c:>9.4f} {CREDITS['Max 5x'] / c:>13,.0f} {CREDITS['Max 20x'] / c:>13,.0f}")

print()
for plan, price in {"Pro": 20, "Max 5x": 100, "Max 20x": 200}.items():
    print(f"{plan:<8} ${price}/mo = ${price / 30:.2f}/day of API-equivalent spend to break even")

print()
# Someone on Pro who also spends $100/mo on the API pays for both.
# Max 5x folds that $100 of API spend into the subscription price.
api_spend = 100
print(f"Pro + ${api_spend} API bill: ${20 + api_spend}/mo")
print(f"Max 5x (credit covers the API bill): ${100 + max(0, api_spend - 100)}/mo")

Running it prints:

model        $/review  reviews/$100  reviews/$200
Haiku 5.5      0.0056        17,857        35,714
Sonnet 5.5     0.1060           943         1,887
Opus 5.5       0.2120           472           943
Fable 5.1      0.5150           194           388

Pro      $20/mo = $0.67/day of API-equivalent spend to break even
Max 5x   $100/mo = $3.33/day of API-equivalent spend to break even
Max 20x  $200/mo = $6.67/day of API-equivalent spend to break even

Pro + $100 API bill: $120/mo
Max 5x (credit covers the API bill): $100/mo

At this task size, $100 covers more than 900 Sonnet 5.5 PR reviews a month, roughly 30 a day, without touching your subscription limits. The last two lines carry the upgrade argument. If you already pay $80 or more a month for API usage in a Console organization you control, Max 5x replaces that bill and adds 5x the Claude Code capacity. Below that, the credit is a perk you may not fully use, since unused credit expires every cycle.

Swap in your own token counts before trusting the table. A multi-file agentic build can easily use ten times this profile. Haiku 5.5’s price also jumps to $0.50/$2.50 once a prompt goes over 100K tokens.

When to Pick Which Plan

Stay on Pro ($20/mo) if:

• You use Claude Code interactively for a few hours a day and only occasionally hit the five-hour limit
• Opus 5.5 and Sonnet 5.5 cover your work and you don’t need Fable regularly
• You have no separate API bill, or it’s small

Move to Max 5x ($100/mo) if:

• You hit Pro’s session limit most days, or claude -p jobs keep eating your interactive window
• You want Fable inside your plan instead of paying API rates for it
• You already spend around $80+/month on the Claude API, which the $100 credit can absorb

Move to Max 20x ($200/mo) if:

• Claude Code is your main development environment for most of the working day
• You regularly run out of Max 5x before the week resets
• Your API usage would use most of a $200 credit anyway

Skip the subscription and go API-only if:

• You never use Claude chat or interactive Claude Code, only API calls
• Your usage swings wildly month to month, so a fixed fee wastes money in quiet months
• You can push work to the Batches API, which halves both input and output prices

For most people, how often you hit session limits decides it. Run /usage for a week and count how often you hit the wall.

How to Track Your Usage

Inside any Claude Code session, /usage shows session cost, plan usage limits and activity stats, according to the commands reference. On a subscription it also breaks down what counts against your plan. /cost and /stats are aliases for the same command. /usage-credits opens the overflow settings covered below.

For headless runs, the headless mode docs say --output-format json returns a payload that includes total_cost_usd and a per-model cost breakdown. A thin wrapper that appends each run’s cost to a log gives you a month of real data:

#!/usr/bin/env bash
# log-claude-cost.sh: run a headless task and append its estimated cost to a CSV
set -euo pipefail
prompt="$1"
claude -p "$prompt" --output-format json \
  | jq -r --arg p "$prompt" '[now | todate, $p, .total_cost_usd] | @csv' \
  >> ~/.claude-cost-log.csv

Then sum the third column at the end of the week:

awk -F, '{gsub(/"/, "", $3); total += $3} END {printf "week total: $%.2f\n", total}' ~/.claude-cost-log.csv

Two caveats from the docs. Both figures are client-side estimates that can differ from your actual bill. And on a subscription login, the dollar figure is notional: you aren’t charged it, it just tells you what the same work would cost through the API. That’s exactly the number you need for the break-even math above. (These snippets need a logged-in Claude Code install, so they weren’t run for this article.)

Usage Credits: The Overflow Setting

When you hit a session or weekly limit, Pro and Max can keep going through usage credits, formerly called “extra usage.” They’re billed at standard API rates, separate from both your plan and the Max API credit.

The original version of this article warned that overflow had no spending cap. That’s no longer true. The usage-credits settings let you set a monthly spending limit (or choose unlimited) and optionally turn on auto-reload. Purchased usage credits generally don’t expire; one exception is Japan, where credits bought from September 10, 2026 expire after six months.

A setup that keeps bills predictable:

• Turn usage credits on with a low monthly cap. Running out mid-task is more expensive in lost time than a few dollars of overflow.
• Point CI and scheduled agents at an API key, so they spend the Max credit (or a Console budget) instead of your interactive limits.
• Check /usage before starting a long refactor late in a session window.

How Claude Code Stacks Up Against Competitors

Two things changed in this category since June. GitHub moved every Copilot plan to AI credits on June 1, at $0.01 per credit, with base and flex allotments listed on the Copilot plans page. And Cursor’s pricing page now sells it through the X Subscription tiers announced October 12 (Plus $8, Premium $30, Super $100, Ultra $200), with a footnote that third-party models in Cursor are “billed separately by usage.” Coverage of the launch reports that the standalone Cursor plans are no longer sold to new customers. If your reason for using Cursor is Claude models, that’s now a second bill on top of the subscription, which makes a Claude plan the more direct way to pay for the same models.

In my view Claude Code keeps an edge in workflow: its terminal-native agent loop suits backend and multi-repo work better than an editor-first tool. The OpenCode vs Claude Code vs Cursor comparison goes deeper on that tradeoff.

Cost-Optimization Tips

The biggest lever is model routing. Haiku 5.5 costs $0.10/$0.50 per million tokens against Opus 5.5’s $4/$20, a 40x gap on both input and output. Formatting, boilerplate and test scaffolding rarely need Opus. In headless jobs, set the model explicitly instead of inheriting the default.

Caching does a lot of the rest. Cache reads cost 95% less than fresh input on Opus 5.5 and Sonnet 5.5 ($0.20 vs $4 and $0.10 vs $2). Claude Code caches automatically. In Agent SDK projects that re-read the same codebase every turn, keep the stable context at the front of the prompt so it stays cacheable.

Sending the whole repo burns tokens on files that don’t matter. Deny rules in .claude/settings.json (for example Read(./dist/**) under permissions.deny) keep build output and vendored code out of reach. The context engineering guide explains why smaller, sharper context tends to produce better agent output, and it costs less too.

For runaway jobs, the CLI’s --max-budget-usd flag puts a dollar ceiling on a headless run, and a turn limit stops an agent that keeps retrying a failed approach. For multi-step agent architectures, the Claude Code subagents guide covers how to split work so one confused subagent doesn’t burn the whole budget.

FAQ

Is Claude Code Pro enough?

For interactive use, a few hours a day, usually yes. Pro includes Claude Code with Opus 5.5 and Sonnet 5.5 inside your limits. It stops being enough when you hit the five-hour session limit most days, when headless claude -p jobs compete with your interactive work for the same allowance, or when you want Fable regularly, since Fable on Pro is billed at API rates through usage credits.

What is the difference between Claude Pro and Max for coding?

Max gives you 5x (Max 5x) or 20x (Max 20x) Pro’s per-session usage. It also includes Fable 5 and 5.1 within your limits, up to 50% of the weekly allowance, and adds $100 or $200 a month in Claude API credits. Claude Code features are the same on every paid plan.

Did the June 15 Claude Code billing change happen?

No. Anthropic paused it on June 15, 2026, the day it was due. claude -p, the Agent SDK and third-party apps still draw from your subscription limits. On October 7, Anthropic added monthly API credits to Max and Team plans instead, and the June credit pool was never introduced.

Can I use Max’s API credits in Claude Code?

Not in interactive Claude Code. The credits cover the Claude API, the Console Playground, Managed Agents and the Agent SDK. To spend them from Claude Code tooling, run claude -p or an SDK project with an API key from the Console organization you linked to your Max plan.

Do Claude Code credits roll over month to month?

The Max monthly API credits don’t. They expire at the end of each billing cycle. Usage credits you buy for overflow are different: they generally don’t expire, except for purchases in Japan from September 10, 2026, which expire after six months.

Is Claude Max 20x worth the $200?

Only if you’d otherwise hit Max 5x limits regularly or would actually spend most of a $200 API credit. For a developer who codes interactively most of the day and runs a few CI agents, Max 5x plus a capped usage-credits budget usually covers it for less.

Sources

• Use the Claude Agent SDK with your Claude plan: Anthropic’s notice pausing the June 15 change, with the October 7 update
• Monthly API credits for Max and Team plans: credit amounts, eligibility and what they cover
• What is the Max plan?: Max 5x and 20x prices and per-session multipliers
• Use Claude Code with your Pro or Max plan: shared limits, weekly limits and wrap-up behavior
• Claude Fable models on your plan: Fable access on Pro, Max and Team
• Manage usage credits for paid Claude plans: overflow billing, spend limits and expiry
• Claude pricing and API pricing: plan prices and per-token rates
• Claude Code commands and headless mode: /usage and JSON cost output
• The New Stack: Anthropic pauses Claude Agent SDK subscription change: same-day report of the pause
• Codersera: Anthropic June 2026 billing change: timeline of the announcement and cancellation
• GitHub Copilot plans and Cursor pricing: competitor pricing

Bottom Line

The June 15 scare is over, and the Pro-vs-Max decision is simpler than it looked in June. Pick on capacity and model access. Pro at $20 is right for interactive coding on Opus 5.5 and Sonnet 5.5. Max 5x is right once session limits start costing you work, once you want Fable without API rates, or once you have an API bill the $100 credit can swallow. For that last group, Max 5x is the best value of the three plans. Max 20x is for people who live in Claude Code all day or keep scripted agent workflows running around the clock. Track a week of /usage before you pay for the bigger plan.