Plans, Pricing, and Models

Overview

Claude Code isn't free, and understanding its cost structure matters as much as knowing how to use it. The difference between choosing your plan well and choosing badly can be hundreds of dollars a month — or worse, losing access in the middle of a sprint because you burned through your quota.

Anthropic offers three subscription plans for Claude Code: Pro ($17/mo annual or $20/mo monthly), Max 5x (from $100/mo), and Max 20x (from $200/mo). Each has different usage levels, model access, and exclusive features. On top of that, there's the API key option with pay-per-token billing for programmatic use.

Available models (April 2026):

• Opus 5 — the most capable in the family, with a significant improvement in agentic coding
• Sonnet 5 — a balance of speed and intelligence for everyday tasks
• Haiku 4.5 — fast and cheap for simple tasks, Explore subagents, and background work

In this capsule you'll understand exactly what each plan includes, how to pick the right one for your profile, what happens when you hit the usage limit, and concrete strategies to optimize costs without sacrificing productivity. By the end, you'll know exactly what Claude Code should be costing you, and why.

The Claude Code plans

Overview (April 2026)

⚠️ Prices verified in April 2026. Check claude.ai/pricing for up-to-date information. AI prices change frequently.

┌─────────────────────────────────────────────────────────────────┐
│                  SUBSCRIPTION PLANS                             │
│                                                                 │
│  INDIVIDUAL:                                                    │
│  ┌───────────┐  ┌───────────────┐  ┌─────────────────┐          │
│  │   PRO     │  │   MAX 5x      │  │   MAX 20x       │          │
│  │ $20/mo    │  │  $100/mo      │  │  $200/mo        │          │
│  │           │  │               │  │                 │          │
│  │ Sonnet 5  │  │ Sonnet 5      │  │ Sonnet 5        │          │
│  │ Opus ltd. │  │ Opus 5 full   │  │ Opus 5 full     │          │
│  │           │  │               │  │                 │          │
│  │ Base usage│  │ 5x usage      │  │ 20x usage       │          │
│  │           │  │               │  │ Priority access │          │
│  └───────────┘  └───────────────┘  └─────────────────┘          │
│                                                                 │
│  TEAMS:                                                         │
│  ┌─────────────────────┐  ┌──────────────────────────────┐      │
│  │  TEAM               │  │  ENTERPRISE                  │      │
│  │  Standard: $25/mo   │  │  Custom pricing              │      │
│  │  Premium: $125/mo   │  │  SSO/SAML + dedicated SLA    │      │
│  │  Minimum 5 users    │  │  Custom policies             │      │
│  │  Centralized admin  │  │  Audit Logs, SCIM, HIPAA     │      │
│  └─────────────────────┘  └──────────────────────────────┘      │
│                                                                 │
│  ┌─────────────────────────────────────────────────┐            │
│  │  API KEY — Pay per token (no subscription)      │            │
│  │  For programmatic use: CI/CD, SDK, headless     │            │
│  └─────────────────────────────────────────────────┘            │
└─────────────────────────────────────────────────────────────────┘

⚠️ Note: Prices and features can change. Check the current information at claude.ai/pricing. The data in this capsule is from April 2026.

The Pro plan ($20/mo)

What it includes

• Access to Claude Code in the terminal, VS Code, JetBrains, desktop, and web
• Sonnet 5 as the main model — no restrictions
• Opus 5 with limited usage — a daily quota that refills
• Standard context window
• CLAUDE.md, Skills, Hooks — the full configuration surface
• Subagents — available within the plan's quotas

Who it's for

✅ Developers who are exploring Claude Code
✅ Moderate use: 1-3 hours of interaction a day
✅ Personal projects and side projects
✅ Students and learners
✅ Anyone who wants to try before committing to Max

❌ Not enough for intensive professional use (8+ hours/day)
❌ The Opus limit is noticeable if you depend on it for complex tasks

Limitations

• Opus 5 has a limited quota — when you run out, it downgrades you to Sonnet
• At peak demand, Pro users can experience higher latency
• No priority access — Max users go first in the queue
• The 1M-token context requires extra usage (not included by default)

The typical Pro scenario

Monday:
→ You use Claude Code for 2 hours in the morning
→ Tasks with Sonnet 5: no problems
→ You try Opus for one complex task: it works

Tuesday:
→ A long 4-hour session
→ At the 3-hour mark, the Opus quota runs out
→ Claude downgrades you to Sonnet automatically
→ Simple tasks are still fine, complex ones lose quality

Wednesday:
→ The Opus quota refills
→ You have access again

If that cycle creates friction for you, you need Max.

The Max 5x plan ($100/mo)

What it includes

Everything in Pro, plus:

• 5x more usage than Pro — significantly more daily capacity
• Full Opus 5 — access without Pro's severe restrictions
• 1M context window with Opus 5 — included in the subscription (Sonnet 1M requires extra usage)
• A larger token quota per hour and per day

Who it's for

✅ Professional developers who use Claude Code daily
✅ Heavy use: 4-8 hours of interaction a day
✅ Complex projects that need Opus frequently
✅ Freelancers who depend on Claude Code for productivity
✅ Tech leads who use Claude for code review and architecture

❌ It can fall short for extreme use (10+ hours/day, every day)

The value calculation

Average developer without Claude Code:
→ Ships 1 complete feature per day

Developer with Claude Code (Max 5x):
→ Ships 2-3 complete features per day

Productivity increase: 2-3x
Cost of Max 5x: $100/mo ≈ $5 per working day
Cost of a developer hour: $50-150/hour

ROI: If Claude Code saves you 1 hour a day ($50-150),
     you're earning $1,000-3,000/mo for $100.

The typical Max 5x scenario

Monday to Friday:
→ 6 hours a day of heavy use
→ Opus 5 for architecture and refactoring (no practical restrictions)
→ Sonnet 5 for routine tasks
→ You rarely hit the limit
→ When you get close, you drop /effort to low for simple tasks

Result: consistent productivity all week

The Max 20x plan ($200/mo)

What it includes

Everything in Max 5x, plus:

• 20x more usage than Pro — the highest ceiling available
• Priority access — lower latency, less waiting at peak times
• A bigger Opus quota — for people who need deep reasoning constantly

Who it's for

✅ Power users who live inside Claude Code
✅ Extreme use: 8+ hours a day, every day
✅ Tech leads reviewing PRs from large teams
✅ Developers who use Opus + max effort frequently
✅ When $200/mo is marginal compared to the value it generates

❌ Overkill if your real usage is under 6 hours a day
❌ If you rarely need Opus, Max 5x is enough

The typical Max 20x scenario

A full day of development:
→ 10+ hours of interaction with Claude Code
→ Opus 5 + max effort for systems architecture
→ Deep code review of 5+ PRs a day
→ You launch large refactorings that take hours
→ You never hit the limit

Result: Claude Code is your constant copilot, no restrictions

Team plans

Team (Standard $25/mo or Premium $125/mo per user, minimum 5 users)

What it includes:

• Everything in Pro
• Centralized administration with an Admin Console
• Unified billing
• A larger quota shared across the team
• Shared Projects, shared Skills, Activity Feed
• Standard seat: full access to Claude Code
• Premium seat: 5x more usage than Standard, premium Cowork, Computer Use

Who it's for

✅ Teams of 5-20 developers that need centralized management
✅ Startups and mid-sized companies with a per-team budget
✅ Managers who need to control billing from one place
✅ Teams that want shared quotas (a developer who doesn't use much
   "lends" capacity to someone in an intense sprint)

❌ Individual developers (minimum 5 users)
❌ Large companies with SSO/compliance requirements (they need Enterprise)

Enterprise (custom pricing)

What it includes:

• Everything in Team
• SSO/SAML
• Custom security policies (Enterprise CLAUDE.md)
• A dedicated SLA
• An advanced admin dashboard

Who it's for

✅ Organizations with 10+ developers
✅ Companies that require SSO/SAML for authentication
✅ Teams with compliance requirements (SOC 2, HIPAA, depending on the case)
✅ Organizations that need centralized security policies
✅ Companies that require an SLA with dedicated support

❌ Small teams with no enterprise security requirements
❌ Individual developers or freelancers

Contact: anthropic.com/enterprise

API Key: pay per token

How it works

The alternative to a subscription is paying per use with an API key. There's no fixed monthly fee — you pay for every token you consume.

Pricing per token (April 2026)

⚠️ Note: These prices are approximate and can change. Check platform.claude.com/docs/pricing.

When to use an API key instead of a subscription

Subscription:
→ Daily, interactive, predictable use
→ You want a fixed monthly cost
→ You use Claude Code as your main tool

API key:
→ Sporadic or automated use
→ CI/CD pipelines that only run on PRs
→ Automation scripts that run X times a month
→ Headless SDK for specific tasks
→ You want to pay only for what you use

You can combine both

OAuth (Max 5x subscription):
→ Your daily interactive use in the terminal

API key:
→ GitHub Actions for automatic code review on PRs
→ A documentation script that runs every Friday
→ An internal team CLI tool

They're not mutually exclusive. Billing is independent.

How to choose your plan

Decision tree

How often will you use Claude Code?

├─ Exploring / learning / occasional use
│  → Pro ($20/mo)
│
├─ Daily professional use (4-8 hrs/day)
│  │
│  ├─ Do you need Opus frequently?
│  │  ├─ Yes → Max 5x ($100/mo)
│  │  └─ No, Sonnet is enough → Pro ($20/mo) may do
│  │
│  └─ Is your company paying?
│     ├─ Yes → Max 5x, no question
│     └─ No → Start with Pro, upgrade if you fall short
│
├─ Power user / tech lead (8+ hrs/day)
│  │
│  └─ Do you review a large team's code or need maximum quota?
│     ├─ Yes → Max 20x
│     └─ No → Max 5x
│
├─ A team of 5+ developers
│  │
│  ├─ Do you need SSO/SAML and security policies?
│  │  ├─ Yes → Enterprise (custom pricing)
│  │  └─ No → Team (Standard $25 / Premium $125 per user)
│  │
│  └─ Do you need centralized admin and unified billing?
│     ├─ Yes → Team or Enterprise
│     └─ No → Individual subscriptions may do
│
└─ CI/CD / automation only
   → API key (pay per token)

Typical profiles

Rate limits by plan

What rate limits are

Rate limits determine how much you can use Claude Code in a given window of time. When you hit them, Claude Code tells you, and you have to wait or adjust your behavior.

How they work

┌────────────────────────────────────────────┐
│  Usage quota                               │
│                                            │
│  Pro:     ████░░░░░░░░░░░░  (base)         │
│  Max 5x:  ████████████████░  (5x base)     │
│  Max 20x: ████████████████████ (20x base)  │
│                                            │
│  Quota refills over time                   │
│  (it's not a hard daily cap)               │
└────────────────────────────────────────────┘

What happens when you hit the limit

1. Model downgrade: If you're on Opus and hit the limit, it downgrades you to Sonnet automatically
2. Queue: If demand is high, your requests get queued (Pro waits longer than Max)
3. Warning message: Claude Code tells you when you're near the limit, or that you've hit it
4. Gradual refill: The quota refills over time (it isn't a reset at midnight)

Signs you need a higher plan

⚠️ You see "rate limit reached" more than twice a week
⚠️ You get downgraded from Opus to Sonnet at critical moments
⚠️ You regularly wait in the queue for more than 30 seconds
⚠️ You adjust your work so you don't burn quota (self-censoring)
⚠️ You split tasks that could have been a single session

If you recognize 2+ of these signs, it's time to move up a plan.

Cost optimization strategies

Strategy 1: Use the right model for the task

Simple task (quick fix, formatting, a question):
→ Sonnet 5 (cheaper in tokens)

Complex task (architecture, refactoring, review):
→ Opus 5 (justifies the higher cost)
→ Effort high or max for deep reasoning

Don't use Opus to ask "what time is it?" — that's taking a Ferrari to the grocery store.

Strategy 2: Short, focused sessions

❌ A 4-hour uninterrupted session
→ Context grows, tokens pile up, cost climbs

✅ 3 sessions of 45 minutes with a clear goal
→ Fresh context, efficient tokens, better result

Every new session starts with clean context. CLAUDE.md gets reloaded (it's persistent), but the conversation starts from zero. That's more token-efficient than one endless session.

Strategy 3: A well-built CLAUDE.md saves tokens

Without CLAUDE.md:
→ 3-4 messages explaining your stack, conventions, structure
→ Claude asks, you answer, Claude asks more
→ ~5,000 tokens spent on context that should have been automatic

With CLAUDE.md:
→ 0 context messages
→ Claude reads CLAUDE.md automatically (~2,000 tokens)
→ The first interaction is already productive
→ Net saving: ~3,000 tokens per session

A good CLAUDE.md is an investment in token efficiency.

Strategy 4: Sonnet for trivial tasks

# In your Claude Code session:
> /model sonnet
> "Rename the variable 'x' to 'userCount' in this file"

You don't need Opus or deep reasoning for a rename. Sonnet produces the same result faster and with less quota.

Strategy 5: /compact before the context explodes

After ~20 interactions:
> /compact
→ Claude compresses the context, keeps what matters
→ Reduces accumulated tokens without losing CLAUDE.md or key decisions

Strategy 6: Start new sessions for new topics

❌ The same session for 5 different tasks
→ Claude drags context from task 1 while you work on task 5
→ Tokens wasted on irrelevant context

✅ A new session for each main topic/task
→ Clean context, fresh CLAUDE.md, maximum efficiency

Comparisons and decisions

Pro vs Max 5x: when to make the jump?

Stay on Pro if:
→ You use Claude Code < 3 hours a day
→ Sonnet 5 is enough for most of your tasks
→ You don't mind Opus having a limited quota
→ $100/mo isn't justified by your usage level

Move up to Max 5x if:
→ You use Claude Code 4+ hours a day
→ You need Opus frequently for complex tasks
→ Pro's rate limits interrupt your flow
→ Your productivity justifies the $80/mo difference

Max 5x vs Max 20x: is doubling worth it?

Stay on Max 5x if:
→ You use Claude Code 4-8 hours a day
→ You rarely hit the Max 5x limit
→ You're not the bottleneck for a large team

Move up to Max 20x if:
→ You use Claude Code 8+ hours a day
→ You hit the Max 5x limit weekly
→ You're a tech lead reviewing PRs for a team of 5+
→ Priority access matters to you
→ You need the maximum Opus quota with max effort

Is paying for Claude Code worth it?

Let's run the numbers:

Assumptions:
- Your work hour is worth $50 (conservative for a developer)
- Claude Code saves you 1 hour a day (conservative)

Monthly saving: 20 days × 1 hour × $50 = $1,000/mo
Cost of Max 5x: $100/mo
ROI: 10x

Even if Claude Code only saves you 30 min/day:
Saving: 20 × 0.5 × $50 = $500/mo
ROI: 5x (with Max 5x)

For most professional developers, the ROI is clear even on the most expensive plan.

Enterprise and Team: when to scale up

If your organization has 5+ developers using Claude Code, consider the team plans (detailed above in the "Team plans" section):

• Team (Standard $25 / Premium $125 per user): Centralized administration, unified billing, shared quotas. Ideal for teams of 5-20 developers.
• Enterprise (custom pricing): SSO/SAML, compliance, a dedicated SLA, an advanced admin dashboard. For organizations with 10+ developers and enterprise security requirements.

The advantage of team plans over individual subscriptions: centralized administration, better usage visibility, and potentially a better cost per developer.

Contact: anthropic.com/enterprise

Common patterns

Pattern 1: Start with Pro, upgrade as needed

Month 1: Pro ($20/mo)
→ You learn Claude Code
→ You evaluate how much you actually use it
→ You find out whether rate limits affect you

Month 2-3: An informed decision
→ If you use it lightly: stay on Pro
→ If you use it heavily: move up to Max 5x
→ If you're a power user: consider Max 20x

You don't have to commit to Max on day 1.

Pattern 2: Max 5x + an API key for automation

Max 5x ($100/mo):
→ Your daily interactive use

API key (~$20-50/mo depending on usage):
→ GitHub Actions: code review on every PR
→ A weekly script: automatic documentation
→ An internal tool: a CLI that uses Claude for X

Total: ~$120-150/mo, covers interactive + automation

Pattern 3: A team with mixed plans

Tech Lead:       Max 20x ($200) — PR review, architecture
Senior Devs (3): Max 5x ($100 each) — heavy development
Junior Devs (2): Pro ($20 each) — learning, guided tasks
CI/CD:           API key ($30-50) — shared automation

Team total: ~$770-790/mo

Pattern 4: Changing plans by season

Intense sprint (2 weeks):
→ Max 5x or Max 20x (you need all the capacity)

Quiet sprint / maintenance:
→ Pro may be enough

You can change plans month to month based on your workload.

Pitfalls and edge cases

Pitfall 1: Paying for Max when Pro is enough

If you use Claude Code 1-2 hours a day and rarely need Opus, $100/mo for Max 5x is money burned. Start with Pro and move up only if the limits genuinely get in your way.

Pitfall 2: Not using the quota you pay for

You pay for Max 5x ($100/mo) but:
→ You only use Claude Code 3 times a week
→ You only use Sonnet (never Opus)
→ You never come close to the limit

= You're paying $80/mo extra for nothing
→ Drop down to Pro

Pitfall 3: Assuming more expensive = better results

Max 20x doesn't make Claude "smarter." It's the same Claude with the same models. Max 20x gives you MORE usage and PRIORITY — not more intelligence.

Pro with Opus 5 = the same quality as Max 20x with Opus 5
The difference is how much Opus you can use, not how good it is

Pitfall 4: Not considering the cost of NOT using Claude Code

The internal debate:
"$100/mo is a lot for a tool"

The real math:
→ Without Claude Code: 2 extra hours hunting bugs, writing boilerplate
→ 2 hours × $50/hour × 20 days = $2,000/mo in lost time
→ $100/mo for Claude Code = a net saving of $1,900/mo

The tool's cost is marginal compared to the cost of not having it, if you use it correctly.

Pitfall 5: Out-of-date pricing

Anthropic adjusts prices and features regularly. This capsule has data from April 2026. Before making a plan decision:

1. Visit claude.ai/pricing
2. Compare with what this capsule says
3. If something changed, the site has the current information

Complete worked example

Scenario: choosing a plan for a full-stack freelancer

Profile:
- Full-stack freelancer (React + FastAPI)
- 3 active projects at the same time
- 5-6 hours of development a day
- Needs code review for himself (works alone)
- Budget-conscious but willing to invest if the ROI is clear

Analysis:

1. Daily use: 5-6 hours → Pro falls short (rate limits)
2. Needs Opus: yes, for architecture and reviewing his own code
3. Remote Control: no, he always works from his own setup
4. Budget: $100/mo is manageable if the ROI is there

Decision: Max 5x ($100/mo)

Why:
→ 5x usage covers his 5-6 daily hours
→ Full Opus for review and architecture
→ He doesn't need the extras in Max 20x
→ ROI: if it saves him 1 hour/day × $75/hour = $1,500/mo

Optimization:
→ Sonnet 5 for routine tasks (formatting, boilerplate)
→ Opus 5 for architecture decisions and code review
→ Separate sessions per project (clean context)
→ A CLAUDE.md per project (module 03 covers this)

Practice exercises

Exercise 1: Calculate your ROI

Run this calculation for your situation:

1. How many hours a day do you think Claude Code will save you? (be conservative)
2. What's your work hour worth?
3. Multiply: hours × value × 20 working days = monthly saving
4. Compare that with the cost of the plan you need

Hours saved/day: 1 hour (conservative)
Value of your hour: $40/hour
Working days: 20

Monthly saving: 1 × $40 × 20 = $800/mo

Plan chosen: Max 5x = $100/mo
ROI: $800 / $100 = 8x

Even being ultra-conservative (0.5 hours saved/day):
$20 × 20 = $400/mo
ROI: 4x

Conclusion: easy to justify

Exercise 2: Identify your profile

Answer these questions and work out your ideal plan:

1. How many hours a day will you use Claude Code?
2. Do you need Opus frequently, or is Sonnet enough?
3. Is your company paying, or is it out of your own pocket?
4. Do you need priority access and maximum quota?

Exercise 3: Track your real usage

For 1 week, record:

• How many hours a day you use Claude Code
• How many times you get downgraded from Opus to Sonnet
• How many times you see rate limit messages
• How many tasks could have used Sonnet instead of Opus

# Week of [date]

## Monday
- Hours: 3
- Rate limits: 0
- Opus→Sonnet downgrades: 1 time
- Tasks that didn't need Opus: 2

## Tuesday
...

Exercise 4: Optimize a session

Open Claude Code and do these 4 tasks, using the optimal model and effort for each:

1. Quick question: "What version of Node am I using?" → Sonnet
2. Simple task: "Create a .gitignore for a Python project" → Sonnet
3. Medium analysis: "Explain this project's file structure" → Sonnet
4. Complex task: "Suggest architecture improvements for this project" → Opus

Summary

• 5 plans: Pro ($20/mo), Max 5x ($100/mo), Max 20x ($200/mo), Team (Standard $25 / Premium $125 per user), Enterprise (custom) + API key (pay-per-token)
• Pro is enough for learning and moderate use (1-3 hrs/day)
• Max 5x is the sweet spot for professionals (4-8 hrs/day, Opus without restrictions)
• Max 20x is for power users (8+ hrs/day, priority, maximum quota)
• The API key is for automation and programmatic use (CI/CD, SDK)
• Rate limits exist — when you hit them, you get downgraded or queued
• To optimize cost: use Sonnet for simple tasks, Opus for complex ones, low /effort for trivia
• CLAUDE.md saves tokens — automatic context instead of explaining things by hand
• Start with Pro if you're not sure — move up when the limits get in your way
• The ROI is clear for most professionals: 1 hour saved a day justifies Max 5x
• Prices change — check claude.ai/pricing before you decide

Next capsule: 05 - Model selection and /effort — how to pick the right model and depth of reasoning for each type of task.

Additional resources

1. Claude Pricing — Up-to-date prices for Pro, Max, Team, and Enterprise
2. Manage Costs Effectively — The official guide to cost optimization, rate limits, and token usage
3. Model Configuration — Available models, effort levels, and extended context by plan
4. Claude Models — Specs and per-token pricing for Opus 5, Sonnet 5, and Haiku 4.5
5. Anthropic Console — Managing API keys, usage, and billing
6. Claude Code Best Practices — Recommendations for optimizing usage and costs