Claude Code pricing 2026: real 30-day bill for a solo dev, a team, and an agency

Quick Answer

Claude Code pricing in June 2026 spans five real prices: $0 (Free, no Claude Code), $20/mo (Pro, very limited Claude Code), $100/mo (Max 5x), $200/mo (Max 20x), $100/seat/mo (Team Premium), and pay-as-you-go on the API. The three cohort bills below show what each plan actually costs once usage caps, parallel sessions, and team overhead are priced in: a solo dev who codes 30 hours a week lands around $200/mo on Max 20x, a five-engineer team lands around $500/mo on Team Premium, and a twelve-contractor agency lands between $1,800 and $2,400/mo. Free does not include Claude Code at all.

Claude Code pricing 2026 in 90 seconds

Anthropic ships Claude Code two ways: as part of a flat-rate Claude subscription, or as pay-as-you-go API usage with your own key. The flat-rate plans are where almost every dev I know actually pays, so that is where the bill math starts.

The current published lineup, lifted from Anthropic's official Plans & Pricing page and the Anthropic Help Center plan-selection guide as of June 27, 2026:

A few things are worth pulling out before the math. First, the Free plan does not include Claude Code at all, and Pro at $20/mo gives you so little Claude Code usage that most active Reddit threads frame it as essentially a teaser tier for coding. Second, the limits are session-window-based: the Max 20x plan resets roughly every 5 hours and is widely reported to cap around 900 messages per window, so parallel agents (which Claude Code officially supports) drain it faster than serial use. Third, Anthropic's per-token API rate sheet is the only price you pay if you skip the subscription entirely: Sonnet 4.6 at $3 in / $15 out per million, Haiku 4.5 at $1 / $5, Opus at $5 / $25 (June 2026 figures, prompt-cache discounts apply).

With that map in hand, here are the three cohort bills.

Solo dev: what $20, $100, and $200 actually buy

Cohort A is the one most readers will recognize: a single developer who treats Claude Code as the daily driver for 25 to 35 hours of coding a week. Sessions are mostly sequential, one main agent at a time, with the occasional parallel TypeScript-cleanup run. No team seats. No reseller markup.

At Pro ($20/mo) the math goes south fast. The plan was rebranded in April 2026 to include Claude Code, but the usage allocation is tight enough that even a single non-trivial feature build pushes you against the 5-hour window cap. The hands-on test in the Cursor versus Claude Code 30-day bill we ran for the same workflow on Day 2 hit the Pro cap inside the first afternoon. Treat Pro as the dabbler tier; not the solo-dev tier.

At Max 5x ($100/mo) the picture changes. Five times the Pro allowance is enough for a steady part-time pattern: ~15 hours a week of focused coding, no parallel agents, no large monorepo crawls. The two recurring failure modes I see at this tier are (a) starting a long planning session right before lunch, then losing the rest of the window if a planning chain takes hundreds of tool calls, and (b) running a single overnight refactor agent that quietly eats the next morning's allowance.

At Max 20x ($200/mo) the cap stops feeling like a cap for most of the week. The real shape of the bill is fixed at $200; the question is whether you have a week where you exceed even the 20x cap (which a fanned-out 12-agent task absolutely can, per the parallel-agent math Anthropic itself documents) and you start running into the hard 5-hour reset rather than the usage ceiling.

Independent perspectives in the SERP cluster put the implied API-equivalent value at Max 20x somewhere between $3,000 and $6,000 per month per heavy user. A widely circulated r/ClaudeCode tracking thread, June 2026 calculated "For every $200 subscription, Anthropic throws in another $7,800" of equivalent API spend on the most active accounts. The number is loud, but the directional point is right: if you are coding full-time, Max 20x is the only solo tier that does not interrupt your day.

Solo bill, 30 days, June 2026:

• Light dabbler: $20 (Pro). Will hit caps. Use for evaluation only.
• Part-time builder, 15 hr/wk: $100 (Max 5x). One overnight job will sting.
• Full-time dev, 30+ hr/wk, occasional parallel agents: $200 (Max 20x). Stop here.

Five-engineer team: Standard seats vs. Premium seats

Cohort B is the small startup or in-house tools group: five engineers, each working full-time, who want unified billing, SSO, and admin controls. The temptation is to default to Team Standard at $20/seat ($100/mo total) because the page chart makes it look like the "team" version of Pro. It is not.

Per Anthropic's Team plan documentation, Team Standard seats do not include Claude Code at all. That is the single most expensive mistake teams make this quarter. Five Standard seats at $100/mo total looks like a steal next to five solo Max 20x seats at $1,000/mo, but you are buying chat seats, not coding seats.

Team Premium at $100/seat (billed annually) or $125/seat (billed monthly) is the actual five-engineer team plan. Five seats land you at $500/mo annual or $625/mo monthly billing, with each seat getting "5x more usage than Standard seats." For a team that wants to keep sessions inside one billing account with admin visibility, that is the right floor.

A few comparisons that come up every time I price this:

• Five individual Max 20x seats = $1,000/mo. No central billing. No SSO. Each dev manages their own key. Cheaper than Team Premium pooled? Often not, because Max 20x per dev has higher individual usage ceilings than Premium does per seat. The pooling math is in Anthropic's favor.
• Five individual Pro seats = $100/mo. Reads cheap. Useless for real team coding; the caps strangle every dev inside the first afternoon.
• Five API-only keys with no subscription, billed at platform rates = highly variable. The Day 8 OpenRouter pricing teardown walked through what 4 token mixes cost at direct-API rates; on a team of 5 with mixed model use, you usually clear $500-$900/mo even with cache hits.

The under-discussed Team Premium gotcha: the "5x Standard" multiplier is on Standard seat usage, not on Max 20x usage. Premium is not equivalent to a $100 Max 5x seat under the hood. Several team-billing tracking threads on r/ClaudeAI through Q2 2026 suggest a non-trivial share of Premium teams hit pool-window caps on busy days where a Max 20x solo would not have.

Five-engineer team bill, 30 days, June 2026:

• Team Premium, 5 seats, annual: $500/mo.
• Team Premium, 5 seats, monthly: $625/mo.
• 5x individual Max 20x: $1,000/mo.
• API pay-as-you-go for 5 mixed users: $500 to $900/mo, no SSO.

If the team values pooled billing, SSO, and audit logs, Premium wins. If each dev is independent, the math favors a stack of Max 20x seats only when individual usage routinely outruns the pooled Premium ceiling.

Agency of 12: contractors, reseller framing, and the messy real bill

Cohort C is the agency or studio: 12 working contractors, mixed permanence (4 full-time, 8 fractional), some clients who want Claude Code involvement disclosed, some who don't. This is where the bill stops being a single SKU and starts being a portfolio.

Three real billing patterns I see across studios this quarter:

Pattern 1: bundle into Team Premium pooled seats. 12 Team Premium seats annual = $1,200/mo. Centralized. SSO. One invoice. Works when contractors are stable employees of the agency. Falls apart when a contractor is a 1099 working 6 hours a week for you and 40 hours a week for someone else; you are paying for a seat they barely touch.

Pattern 2: reimburse individual Max 20x. 4 full-time × $200 = $800/mo, plus 8 fractional × $100 (Max 5x) = $800/mo. Total: $1,600/mo, reimbursed against each contractor's own Anthropic billing. Cleaner from an accounting standpoint, messier from a security one (each contractor holds their own API key, no central audit).

Pattern 3: API-only with a routing layer. Pay-as-you-go on the API with per-client cost attribution. Variable bill of $1,200 to $2,400/mo depending on token mix and cache hit rate. This is where the OpenRouter pass-through fee math we ran on Day 8 and the full LLM workflow cost calculator we ship on BudgetForge get heavy use. The win on this pattern: per-client cost attribution is trivial. The cost: no flat-rate ceiling, so a runaway agent on Tuesday wrecks the month.

The hybrid I see most often: 4 full-time on Team Premium pooled ($400/mo), 8 fractional on individual Max 5x or pay-per-API depending on client work shape ($800-$1,200/mo), plus a small Claude Code API budget for after-hours automations ($200-$400/mo). Total range: $1,400 to $2,000/mo for a 12-person agency, which lines up with what the Verdent AI 2026 Claude Code costs guide, March 2026 reports as the typical mid-sized-studio range.

Twelve-contractor agency bill, 30 days, June 2026:

• Team Premium pooled, 12 seats annual: $1,200/mo (clean billing, wastes fractional seats).
• Mixed individual reimbursement: $1,600/mo (messy compliance).
• API-only, attribution-friendly: $1,200-$2,400/mo (no ceiling).
• Hybrid (4 Premium + 8 mixed): $1,400-$2,000/mo (most common).

The 5.5x token-efficiency angle nobody costs in

The bills above only tell half the story. The other half is that Claude Code, when measured task-for-task against Cursor on the same workflow, uses roughly 5.5x fewer tokens to reach an equivalent result. We measured this in Day-2's head-to-head Cursor and Claude Code companion teardown; the headline ratio held across three repeated builds.

Why does this matter for the bill? Two reasons:

1. API-only Claude Code is cheaper per task than API-only Cursor, even though Cursor's published per-request price looks similar, because the Claude Code harness emits fewer planning turns, fewer redundant file reads, and is more aggressive about prompt caching (cache writes 1.25x at 5-min, 2x at 1-hr; cache hits at $0.30/M for Sonnet 4.6 per Anthropic's published cache pricing).
2. The subscription is even better-arbitraged than it looks. If the Max 20x plan would translate to $3,000-$6,000 of API-equivalent value at Claude Code's token efficiency, the same workflow run through a less-efficient harness at the same flat $200 would translate to closer to $15,000-$30,000 of equivalent third-party API spend. The flat-rate price is identical; the implied value is not.

The honest counter: nobody actually pays the API-equivalent number, because nobody routes their entire month through Cursor at API-cold rates. The arbitrage number is rhetorical, not financial. The directional point holds though: when comparing subscriptions, also compare the harness token economy, not just the sticker price.

When the subscription beats the API (and when it loses)

For most full-time coders the Max 20x subscription beats pay-as-you-go API. The break-even is roughly the point where your monthly inferred API spend (token-by-token, no cache amortization) crosses $200. For a solo dev running Claude Code 30+ hours a week, that break-even is reached inside the first week of the month.

The subscription loses in five specific cases:

1. Heavy parallel automation. A 20-agent task that wants 1M tokens per agent per run, fired multiple times per day, exceeds the 5-hour window before exhausting the monthly quota. The API has no window cap; only the budget does.
2. Long quiet weeks. If you take 3 weeks off, you still pay the $200 flat. API-only bill is $0 in a quiet week.
3. Per-client cost attribution. Subscriptions are a single line item; API usage attaches to individual run IDs. Agencies billing clients per-feature need the API trail.
4. High Opus mix. Subscriptions weight model availability per usage tier; the API just charges Opus $5/$25 per million end of story.
5. BYOK requirements. Some enterprise clients require a key they own.

When Cursor still wins on price: a team of 5 on Cursor's $20/mo Pro tier sits at $100/mo total with reasonable allowances for chat-style coding, less so for agentic builds. If your team's workload is 80% in-IDE pair programming and 20% agent runs, Cursor's flat tier is genuinely competitive against Team Premium at 5x the cost. The published Cursor Hobby and Pro subscription page lists Pro at $20/mo with extended Agent limits, frontier models, MCP support, and skills/hooks; Teams at $40/user/month adds centralized billing and Bugbot review.

How to pick (the 60-second decision)

• Solo dev, <10 hr/wk on Claude Code → Pro at $20/mo. Accept the caps.
• Solo dev, 10-25 hr/wk → Max 5x at $100/mo. Watch overnight jobs.
• Solo dev, 25+ hr/wk or any parallel-agent habit → Max 20x at $200/mo. The only tier that doesn't interrupt your day.
• 3-10 engineer team, central billing required → Team Premium at $100/seat annual. Standard does not include Claude Code; this is the trap.
• Agency, 10+ contractors, mixed permanence → hybrid stack: Premium for core team, individual subscriptions or API for fractional contractors.
• Anything with parallel-agent fleets, per-client attribution, or BYOK requirements → API pay-as-you-go, route through your own cost-attribution layer.

FAQ

Does the Claude Free plan include Claude Code?

No. As of June 27, 2026, Claude Code is only available on Pro ($20/mo), Max 5x ($100/mo), Max 20x ($200/mo), Team Premium ($100-125/seat/mo), Enterprise (add-on), or via direct API access. Free is chat-only.

Is $200/mo Max 20x worth it for a solo dev?

Yes if you code more than 25 hours a week with Claude Code, no if you don't. Below that threshold the $100 Max 5x plan rarely hits caps; above it, you'll lose enough time to throttling that the extra $100 pays for itself.

Does Team Standard at $20/seat include Claude Code?

No. Team Standard is the most common Claude pricing mistake teams make this quarter. Only Team Premium at $100-125/seat includes Claude Code.

Is Claude Code subscription cheaper than the API?

For most coders, yes. If your token usage at API rates would exceed $200/mo, the Max 20x flat plan is cheaper. The break-even comes earlier than people expect because Claude Code's harness uses roughly 5.5x fewer tokens than comparable in-IDE tools and benefits from aggressive prompt caching.

How does Claude Code compare to Cursor on price?

Cursor Pro at $20/mo is cheaper sticker price than Claude Code Max plans, but the workflows differ: Cursor is pair-programming-first, Claude Code is agent-first. For full-time agentic coding Claude Code Max 20x wins on token economy; for IDE pair programming Cursor's $20 tier is competitive.

What happens when you hit the Max 20x cap mid-day?

You wait for the 5-hour rolling window to reset. The cap is per-window, not per-day; if you hit it at 10am, you're back at 3pm. Hard-blocked workflows that need uninterrupted runs should either (a) split into smaller batches, (b) move time-sensitive runs to direct API, or (c) accept the gap.

Can a 12-person agency just buy 12 Premium seats?

You can, and you'll pay $1,200/mo annual. The question is whether all 12 are full-time enough to use the seat. Most agencies end up on a hybrid: Premium for the core team, individual subscriptions or API for fractional contractors.

Math check: solo full-time → $200/mo flat, five-engineer team → $500/mo on Team Premium annual, 12-contractor agency → $1,400 to $2,000/mo on a hybrid stack. Claude Code at roughly 5.5x token efficiency makes the subscription arbitrage real but rhetorical; the break-even versus the API lands around $200/mo of inferred token cost for full-time coders.