Claude Code Pro vs Max: Real Costs After the June 15 Billing Change

TL;DR

Anthropic splits Claude Code billing on June 15, 2026. Interactive terminal sessions stay on your subscription limits. Programmatic usage (claude -p, Agent SDK, GitHub Actions) moves to a separate credit pool billed at full API rates. Pro gets $20/month in credits, Max 5x gets $100, Max 20x gets $200. If you run agents in CI or automate with headless mode, this changes your economics. If you only use Claude Code interactively in the terminal, nothing changes.

The June 15 Split: What Moves and What Stays

I’ve been running Claude Code on the Max 5x plan since March (I wrote about how it compares to Cursor and Windsurf earlier this year), averaging about three hours of interactive coding per day plus a handful of automated PR review workflows. The June 15 change splits my usage into two separate buckets, and that split caught me off guard when I first read the announcement.

Stays on subscription limits (unchanged):

• Interactive Claude Code in the terminal (the thing you type claude to launch)
• Claude.ai web, desktop, and mobile chat
• Claude Cowork

Moves to separate credit pool (new):

• claude -p (headless/non-interactive mode)
• Claude Agent SDK projects
• Claude Code GitHub Actions
• Third-party apps using Agent SDK authentication

The credit pool bills at standard API rates. When it runs out, programmatic requests stop until your next billing cycle. You can enable overflow billing to keep going, but that charges at API rates with no cap.

If you run automated workflows, the math just changed.

Every Plan, Side by Side

The free plan doesn’t include Claude Code at all. And credits don’t roll over. If you don’t spend your $100 this month, it’s gone.

What the Credits Actually Buy

Credits bill at standard API rates: Haiku 4.5 runs $1/$5 per million input/output tokens, Sonnet 4.6 is $3/$15, and Opus 4.6 is $5/$25. Cache reads cost 90% less ($0.10/$0.30/$0.50 per million, respectively). One wrinkle: Opus 4.7’s tokenizer inflates token counts by about 35% compared to Sonnet 4.6 on the same text. Your $100 in Max 5x credits buys fewer Opus interactions than the raw per-million rates suggest.

This is what the credits actually cover, depending on which model your automated workflows use:

I’m estimating a “session” as a heavy debugging interaction consuming about 500K–1M tokens across input and output. A quick single-file fix uses far fewer tokens. A multi-file agentic build uses more.

Real-World Cost Breakdown

The session estimates above are abstract. Common automated tasks cost more than you’d expect at API rates, especially with the 35% tokenizer overhead factored in:

The effective cost increase is about 35% across the board. Per-token rates stayed flat, but the Opus 4.7 tokenizer inflates token counts on the same text, so every task burns more credits than it used to.

For my own workflow (roughly 15 automated PR reviews per week plus a few headless code generation runs), that works out to about $65/month in credits. Well within the Max 5x budget. A Pro user running the same workload would blow through their $20 in credits by week two.

When to Upgrade: The Decision Framework

I’ve been tracking my usage for three months. This is how I decide:

Stay on Pro ($20/mo) if:

• You use Claude Code interactively only, with no claude -p, no CI, no Agent SDK
• Your automated usage is light: fewer than 5 programmatic tasks per week
• You’re comfortable switching to Haiku or Sonnet for automated work to stretch credits

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

• You run 10+ automated tasks per week (PR reviews, test generation, code migrations)
• You want 5x the interactive session limits too, since the subscription upgrade affects both pools
• $100/month in credits roughly matches your API bill if you were paying direct

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

• Claude Code is your primary development environment, 6+ hours daily
• You run heavy CI automation: multiple agent pipelines, nightly code sweeps
• You regularly hit Max 5x limits before the week resets

Skip the subscription, go API direct if:

• You only need headless mode and don’t use Claude.ai chat at all
• You want batch pricing (50% discount for async jobs)
• Your monthly usage is spiky ($300 one month, $20 the next) and you don’t want to pay $200/month for the peak

The breakeven math is simple. If you’d spend more than $X/day at API rates, the subscription that costs $X×30 is cheaper. Pro breaks even at $0.67/day in API spend. Max 5x at $3.33/day. Max 20x at $6.67/day. Track your actual usage for a week before deciding.

How to Track Your Usage

Before June 15, audit what you’re actually consuming. Run /usage inside any Claude Code session to see your current limits. For programmatic usage, add a wrapper that logs token counts:

claude -p "refactor auth module" --output-format json 2>/dev/null | \
  jq '{input_tokens: .usage.input_tokens, output_tokens: .usage.output_tokens, 
       cost_estimate: (.usage.input_tokens / 1000000 * 5 + .usage.output_tokens / 1000000 * 25)}'

Output:

{
  "input_tokens": 42817,
  "output_tokens": 3291,
  "cost_estimate": 0.296315
}

This gives you the actual per-task cost at Opus rates. Run it against your typical workloads for a week and multiply by 4.3 to estimate monthly spend. That number tells you which tier to pick.

For GitHub Actions, check the Claude Code action logs. They report token consumption per step. Sum them across a billing period to get your CI baseline.

How Claude Code Stacks Up Against Competitors

I’ve been using all three of these tools alongside each other this year. The cost comparison looks like this:

Cursor bundles agent capabilities into the $20 plan without a separate credit pool. Copilot’s AI Credits model is conceptually similar to Claude’s post-June-15 system, but GitHub ties it into Actions, PR reviews, and the rest of their toolchain more tightly. Both avoid the “two separate pools” complexity that Claude is introducing.

But Claude Code’s terminal-native workflow is faster than anything Cursor offers for backend work (see my OpenCode vs Claude Code vs Cursor breakdown for a deeper comparison). I’ve measured 2-3x faster iteration on Go and Python refactors compared to Cursor’s composer mode. That speed advantage is worth paying for. Just know what you’re paying.

Cost-Optimization Tips

If you’re staying on Pro or want to stretch Max 5x further, a few specific changes cut costs significantly:

Route by task complexity. Use Haiku 4.5 for simple tasks (formatting, boilerplate, test scaffolding) and reserve Opus for reasoning-heavy work (architecture decisions, complex bug hunts, multi-file refactors). Haiku is 5x cheaper per input token and 5x cheaper per output token than Opus. Routing correctly can cut your credit burn by 60%.

If your agent loops re-read the same codebase context on every turn, turn on prompt caching. Cached input tokens cost 90% less on Sonnet and Opus. Caching alone can slash input costs by 70-90%. Claude Code handles this automatically for interactive sessions, but you’ll want to configure it explicitly for Agent SDK projects.

Sending your entire repo as context burns tokens on irrelevant files. Use .claude/settings.json to scope which directories Claude Code reads. The sweet spot I’ve found is 50K-200K tokens of context, enough for the agent to understand the codebase while keeping costs predictable.

Set per-task budgets. In Agent SDK projects, configure max_tokens per step. A runaway agent loop that keeps retrying a failed approach can eat through credits fast. Capping individual steps at 8K output tokens prevents most runaway scenarios. If you’re building multi-step agent workflows, my Claude Code subagents guide covers the architecture patterns.

Overflow Billing: Watch This Setting

When your credit pool runs out, Anthropic gives you two options via the “usage credits” toggle in settings:

1. Disabled (default): programmatic requests fail until your next billing cycle. Your interactive Claude Code keeps working.
2. Enabled: requests continue, billed at API rates with no cap.

Option 2 is convenient until you get a $400 surprise because an agent loop ran wild overnight. (GitHub Copilot has a similar credits model with its own overflow traps.) If you enable overflow, set up spending alerts. Anthropic doesn’t offer granular per-day caps. The toggle is all-or-nothing.

My setup: overflow disabled on the main account, a separate API key with a hard spending limit for CI jobs that can’t wait.

FAQ

Is Claude Pro worth it for Claude Code?

At $20/month, Pro gives you interactive Claude Code access plus $20 in programmatic credits. If you only use Claude Code interactively (no claude -p, no Agent SDK), Pro is the right plan. Interactive usage stays on subscription limits and the credit pool just sits there. If you run any automation, $20 in credits covers about 13 Opus sessions or 40 Sonnet sessions per month.

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

Max plans give you higher interactive session limits (5x or 20x Pro’s caps) plus a larger credit pool for programmatic use. Max also includes priority model access during peak hours and Cowork for multi-step task delegation. The coding experience is identical: same models, same Claude Code features. The difference is how much you can use them before hitting limits.

Should I use Claude Code Max or the API directly?

If your usage is steady and you also use Claude.ai chat and interactive Claude Code, Max bundles everything. If your usage is spiky or you only need headless agent capabilities, API direct with batch pricing (50% discount) is often cheaper. Run the breakeven calculation: if your daily programmatic API spend consistently exceeds $3.33, Max 5x saves money. Below that, API direct wins.

Do Claude Code credits roll over month to month?

No. Unused credits expire when your billing cycle resets. There’s no top-up mechanism either. If you need more credits mid-month, the only option is enabling overflow billing at API rates or upgrading to a higher tier.

Is Claude Max 20x worth the $200?

For most developers, no. Max 20x is for people who spend 6+ hours per day in Claude Code and run heavy automated pipelines: nightly code migrations, large-scale test generation, multi-repo agent workflows. If you’re not regularly hitting Max 5x limits, the extra $100 buys headroom you won’t use.

Sources

• Anthropic Claude Max plan documentation — official plan details and limits
• Anthropic API pricing — per-token rates, cache pricing, and batch discounts
• Claude Code pricing and June 15 billing changes — detailed breakdown of the credit pool transition
• Anthropic June 15 billing change explained — credit allocations, overflow behavior, and migration checklist
• Claude Code pricing plans comparison — Pro, Max, Team, and API rate cards

Bottom Line

The June 15 change only bites if you run programmatic Claude Code workloads: claude -p, Agent SDK, or GitHub Actions. Interactive usage is untouched. For most developers on Pro who code interactively, nothing changes. For anyone running automated pipelines, track your actual token consumption for a week, multiply by 4.3, and pick the tier that covers it. Max 5x at $100/month is the right call for regular CI automation. Max 20x is for the small percentage of developers whose AI workflows have replaced most of their manual coding. And if your usage is unpredictable, skip the subscription math entirely and go API direct with batch pricing.