Most developers overpay for Claude Code because they pick the wrong plan for their usage pattern. A solo developer doing 5 tasks a day on the $200/month Max plan is burning $160/month they don't need to. A heavy user on API pricing at 20+ tasks a day could save $2,000/month by switching to Max.
This guide breaks down every Claude Code pricing tier, what you actually get at each level, and how it compares to Cursor and GitHub Copilot. The goal: pick the cheapest plan that matches your real usage.
Plan Overview
| Plan | Price | Usage Limits | Best For |
|---|---|---|---|
| Free | $0 | ~15 messages / 5 hrs (Sonnet) | Trying Claude Code |
| Pro | $20/mo | ~45 messages / 5 hrs (Sonnet + limited Opus) | Solo devs, moderate use |
| Max 5x | $100/mo | 5x Pro limits | Daily power users |
| Max 20x | $200/mo | 20x Pro limits | All-day coding agents |
| Team | $25-150/seat/mo | Standard or Premium seats | Engineering teams |
| Enterprise | Custom | Custom limits + SLA | Large organizations |
Shared usage pool
Claude Code and Claude.ai chat share the same quota on Pro and Max plans. Heavy chat usage during the day reduces your available Claude Code messages. If you use both products regularly, factor in total usage across both, not just Claude Code alone.
Free Tier
Claude Code's free tier gives basic access with Sonnet. You get approximately 15 messages per 5-hour rolling window. There is no access to Opus, no Projects, and limited file handling.
The free tier is enough to evaluate whether Claude Code fits your workflow. It is not enough for daily development work. Most developers hit the limit within 30-60 minutes of active coding.
What You Get
Sonnet model access, basic file editing, terminal commands, conversation history. Enough for evaluation and occasional use.
What You Don't Get
Opus model access, Projects, extended context, priority access during peak hours. The rate limits make sustained development impractical.
Pro Plan ($20/month)
Pro is the entry point for regular Claude Code use. You get approximately 45 messages per 5-hour rolling window with Sonnet 4.6, plus limited Opus 4.6 access. The exact message count varies based on message length and complexity.
At $20/month, Pro works well for developers running 5-10 coding tasks per day. Beyond that, you will hit rate limits regularly, especially if you also use Claude.ai for chat.
Pro plan includes
- Models: Sonnet 4.6 (primary) + Opus 4.6 (limited)
- Usage: ~45 messages per 5-hour window (shared with chat)
- Features: Projects, extended context, MCP server support
- Context window: 200K tokens standard, 1M tokens (beta) with Opus
- Annual discount: ~$17/month when billed yearly
The Pro plan is identical in price to Cursor Pro ($20/month) and double GitHub Copilot Pro ($10/month). The difference is what you get: Claude Code is a terminal-native agentic tool that reads, edits, and runs code autonomously. Cursor is an IDE with AI features. Copilot is primarily autocomplete with chat.
Max Plans ($100-200/month)
Max is for developers who use Claude Code as their primary development tool and hit Pro rate limits daily. Two tiers exist:
| Max 5x | Max 20x | |
|---|---|---|
| Price | $100/month | $200/month |
| Usage vs Pro | 5x Pro limits | 20x Pro limits |
| Estimated messages / 5hrs | ~225 messages | ~900 messages |
| Priority access | Yes | Yes |
| Early feature access | Yes | Yes |
| Best for | Power users (10-20 tasks/day) | Agent workflows (20+ tasks/day) |
At $200/month, Max 20x is expensive compared to Cursor or Copilot. But the math works differently. Claude Code at Max 20x is effectively unlimited for a single developer. Running the equivalent workload on API pricing (20+ tasks/day on Opus) would cost $2,000-4,000/month.
When Max pays for itself
If you run more than 8-10 coding tasks per day and would otherwise use API pricing, Max saves money. The break-even point for Max 5x ($100/month) is roughly 5-8 Opus tasks per day on API pricing. For Max 20x ($200/month), the break-even is roughly 10-15 tasks per day. Above those thresholds, Max is cheaper per task.
Team Plan
The Team plan starts at $25 per user per month ($30/month if billed monthly) with a minimum of 5 members. It includes everything in Pro plus team administration, centralized billing, and usage visibility.
The catch: standard Team seats ($25/user) include Claude chat and basic features, but full Claude Code agent access requires Premium seats at $150/user/month. This is the most commonly overlooked detail in Claude's team pricing.
| Standard Seat | Premium Seat | |
|---|---|---|
| Price | $25/user/month | $150/user/month |
| Claude chat | Yes | Yes |
| Claude Code (basic) | Yes | Yes |
| Claude Code (full agent) | Limited | Full access |
| Admin controls | Yes | Yes |
| SSO/SAML | No | No (Enterprise only) |
For a 10-person engineering team where everyone needs full Claude Code access, that is $1,500/month on Premium seats. Compare that to Cursor Teams at $400/month ($40/user) or GitHub Copilot Business at $190/month ($19/user). Claude Code is the most expensive option for teams, but it also does the most: autonomous multi-file edits, terminal access, and agentic workflows that Copilot and base Cursor do not match.
Enterprise
Enterprise pricing is negotiated per organization and typically starts around $60/seat/month with a minimum of 70 users. It includes SSO/SAML, SCIM provisioning, audit logs, custom rate limits, dedicated support, and compliance APIs.
Security & Compliance
SSO/SAML, SCIM provisioning, audit logging, data retention controls, and compliance APIs. Required for regulated industries.
Custom Limits
Negotiable rate limits, custom SLAs, dedicated account management, and training data opt-out. Volume discounts available.
API Pricing (Pay-per-Token)
Instead of a subscription, you can use Claude Code with an Anthropic API key and pay per token. This is completely separate from the Pro/Max subscription and does not count against subscription quotas. You control costs with daily and monthly spend limits in the Anthropic Console.
| Model | Input | Output | Cached Input |
|---|---|---|---|
| Haiku 4.5 | $1.00 | $5.00 | $0.10 |
| Sonnet 4.6 | $3.00 | $15.00 | $0.30 |
| Sonnet 4.6 (>200K ctx) | $6.00 | $22.50 | $0.60 |
| Opus 4.6 | $5.00 | $25.00 | $0.50 |
A typical coding task consumes 50K-200K input tokens and 5K-20K output tokens. That works out to $0.20-$1.35 per task on Sonnet, $0.50-$4.00 per task on Opus. Long conversations with extended thinking can reach $10-30 per session.
For more detail on per-task costs and context accumulation, see our Claude Code cost breakdown.
Batch API discount
The Batch API processes requests asynchronously at a 50% discount on both input and output tokens. If your workflow allows async processing (test generation, bulk refactoring), batch mode cuts costs in half.
Claude Code vs Cursor vs GitHub Copilot: Pricing
The three dominant AI coding tools have very different pricing structures. Direct price comparison is misleading because each tool does different things, but here is what you pay at each tier.
| Tier | Claude Code | Cursor | GitHub Copilot |
|---|---|---|---|
| Free | Limited (Sonnet) | Limited requests | 2K completions, 50 premium requests |
| Standard | $20/mo (Pro) | $20/mo (Pro) | $10/mo (Pro) |
| Mid-tier | $100/mo (Max 5x) | $60/mo (Pro+) | $39/mo (Pro+) |
| Power user | $200/mo (Max 20x) | $200/mo (Ultra) | N/A |
| Claude Code | Cursor | GitHub Copilot | |
|---|---|---|---|
| Standard seats | $25/user | $40/user | $19/user |
| Premium / full access | $150/user | $40/user | $39/user (Enterprise) |
| 10-person team cost | $250-1,500/mo | $400/mo | $190-390/mo |
| Min team size | 5 users | 3 users | 1 user |
Claude Code
Terminal-native agent. Reads, writes, and runs code autonomously across files. Most capable for complex multi-step tasks. Most expensive for teams at full access. 5.5x more token-efficient than Cursor in independent tests.
Cursor
AI-enhanced IDE. Best for developers who want AI integrated into their editor. Tab completions, inline chat, and agent mode. Credit-based billing since June 2025. Strong all-around value at $20/month.
GitHub Copilot
Cheapest entry point at $10/month. Strongest autocomplete. Best for teams already on GitHub Enterprise. Weaker agentic capabilities compared to Claude Code and Cursor agent mode.
Which Plan Should You Pick?
| Your Situation | Best Plan | Monthly Cost |
|---|---|---|
| Evaluating Claude Code | Free tier | $0 |
| Solo dev, 5-10 tasks/day | Pro | $20/mo |
| Solo dev, 10-20 tasks/day | Max 5x | $100/mo |
| Heavy use, 20+ tasks/day | Max 20x | $200/mo |
| Variable/occasional use | API key | $0.20-4.00/task |
| Team (basic access) | Team standard | $25/user/mo |
| Team (full agent access) | Team premium | $150/user/mo |
| Enterprise (70+ users) | Enterprise | Custom (~$60+/user) |
The hybrid approach
Many developers use a Pro or Max subscription for daily interactive work, plus an API key for automated tasks (CI integration, batch operations, subagent workflows). The subscription handles rate-limited interactive use; the API handles high-volume automated use. You pay for both, but total cost is often lower than going all-in on either one.
How to Reduce Your Claude Code Bill
Regardless of which plan you choose, these optimizations reduce token consumption and help you stay within rate limits.
Write a CLAUDE.md
A project-level CLAUDE.md tells Claude where things are, which patterns to follow, and what to skip. Reduces exploratory file reads by 40-60%, directly cutting token usage.
Use Sonnet for Routine Work
Switch to Sonnet with /model for simple edits, test writing, and refactoring. Sonnet costs 3-5x less than Opus per token. Save Opus for complex multi-file reasoning.
Keep Sessions Short
Context accumulates every turn. Five 4-turn sessions cost less than one 20-turn session. Start fresh when you finish a discrete task.
Use Subagents
Subagents start with only the context they need. Three subagents at 20K context each cost less than one session at 200K accumulated context. Better parallelism, lower total tokens.
Use Fast Apply for Edits
Morph's fast apply model handles file edits at 10,500 tok/s instead of using the full Claude model for every character change. Cuts edit-related token usage by 70-80%.
Use WarpGrep for Search
WarpGrep finds relevant code in 1-2 targeted searches instead of Claude reading 20+ files to find what it needs. Fewer file reads = fewer input tokens = lower cost.
FAQ
How much does Claude Code cost?
Claude Code is included in Anthropic's Pro plan ($20/month), Max plans ($100-200/month), Team plan ($25-150/seat/month), and Enterprise (custom pricing). There is also a limited free tier. Alternatively, you can use Claude Code with an API key and pay per token: $3/$15 per million tokens for Sonnet 4.6, $5/$25 for Opus 4.6.
Is Claude Code free?
Claude Code has a limited free tier with basic Sonnet access and approximately 15 messages per 5-hour window. This is enough for evaluation but not for daily development. For regular use, you need Pro ($20/month) or an API key.
What is the difference between Pro and Max?
Pro ($20/month) gives approximately 45 messages per 5-hour window. Max 5x ($100/month) gives 5 times that, and Max 20x ($200/month) gives 20 times that. Max also includes priority access during peak hours and early access to new features. If you hit Pro rate limits more than twice a week, Max is worth it.
Is Claude Code cheaper than Cursor?
At the individual level, they are comparable: both Pro plans are $20/month, and both have $200/month power-user tiers. For teams, Cursor is cheaper ($40/user) than Claude Code premium seats ($150/user). However, Claude Code uses 5.5x fewer tokens than Cursor for identical tasks in independent benchmarks, so the cost-per-result equation favors Claude Code for complex work.
Do Claude Code and Claude chat share usage limits?
Yes. On Pro and Max plans, Claude Code and Claude.ai share the same usage quota. Heavy chat usage reduces available Claude Code messages. API usage is separate and does not affect subscription quotas.
Should I use a subscription or API pricing?
If you run fewer than 8-10 tasks per day, API pricing is cheaper. Above 10 tasks per day, Max saves money. Many developers use both: a subscription for interactive work, an API key for automated and batch tasks.
Related Guides
Cut Claude Code token costs with Morph
Fast Apply handles file edits at 10,500 tok/s, cutting edit tokens by 70-80%. WarpGrep finds code in 1-2 searches instead of 20+ file reads. Same results, fewer tokens, lower bill.