TL;DR

• Claude pricing starts with a Free plan, which does not include Claude Code. As of September 2026, Pro costs $20/month, and Max starts at $100/month. Annual Pro pricing is listed at $17/month, with $200 billed upfront.

• Claude Code is included in paid subscriptions: Pro, Max, Team, and Enterprise. You can also use pay-as-you-go API billing. The cheaper option depends on your model, usage, and plan limits.

• Team plans: Standard seats cost $25/user/month, or $20 with annual billing. Premium seats cost $125/user/month, or $100 with annual billing.

• Enterprise pricing: The listed seat fee is $20/user/month, billed annually, plus usage charged at API rates. Enterprise adds SSO, audit logs, and custom data retention.

• API pricing: Standard input/output rates per million tokens are $1/$5 for Haiku 4.5, $2/$10 for Sonnet 5, $4/$20 for Opus 5.5, and $10/$50 for Fable 5.1. Prompt caching can reduce repeated-input costs.

For developers building multi-turn agents, growing conversation history can increase token costs. Tools like persistent memory for Claude can help reduce the context sent with each request.

You’re building something on Claude, and it’s working. Then usage picks up, you check your bill, and the number is twice what you expected. Token costs compound fast, and if you don’t understand exactly how Claude charges for input, output, caching, and long-context requests, you’ll keep getting surprised.

This guide breaks down every Claude pricing tier: subscription plans for individuals and teams, API token costs for developers, and the specific mechanics behind caching, batch processing, and tool usage. It also covers where those costs come from at the code level, and what you can do to bring them down.

Anthropic Pricing: Claude App, API, and Console

Anthropic sells access to Claude through two billing surfaces, and knowing which one you’re on explains most billing confusion.

• Claude app (claude.ai): The consumer chat product for web, desktop, and mobile. Billed through the Free, Pro, Max, Team, or Enterprise subscription plans covered below, at a flat monthly or annual rate rather than per token.

• Claude Platform (platform.claude.com), also called the Claude Console (CLI): The developer surface for building with the Claude API. This is where you add a payment method, generate API keys, monitor usage, set spend limits, and get billed per token. Note that console.anthropic.com is an older address for the same platform: both point to the same sign-in and dashboard.

A Claude subscription doesn’t carry over to the API: they’re billed separately, even if you’re already paying for Pro or Max. If you’re running Claude Code, it’s worth confirming you’re on your subscription’s usage pool and not accidentally billing via an API key; see below for the exact gotcha to check.

Claude Code Plan Comparison at a Glance

Claude code pricing comparison across these plans mostly comes down to how much usage you need and whether you need Claude Code.

Free and Pro cover casual-to-daily use at a flat rate, Max scales that same flat-rate model up for heavy individual users, and Team and Enterprise add per-seat billing plus collaboration and compliance features. None of these plans change which Claude models you get access to: they only change how much room you have to use them.

Why your Claude bill compounds fast

Every conversation re-sends context on each turn. A 10-turn chat with a 50K-token history can create 500K input tokens, most of it repeated context. Mem0 stores durable user and project memory, then retrieves only what matters per request.

See how persistent memory reduces LLM token costs →

Individual Plans

Claude’s individual plans are built around usage volume rather than model access: everyone on Free, Pro, or Max gets the same underlying Claude models, just with different session limits and feature sets.

Free

The Free plan costs $0: no credit card required. It covers web, iOS, Android, and desktop access with text, image, and code generation, web search, and desktop extensions.

The catch: daily usage limits apply. You’ll hit the ceiling quickly if you’re doing anything beyond light experimentation.

No Claude Code on Free. If you need the terminal-based coding agent, you’ll need Pro or higher.

Pro: $20/month

Pro runs $20/month, or $200/year ($17/month equivalent) on annual billing.

What you get on top of Free:

• Higher usage limits (5-hour rolling session window)

• Claude Code in the terminal

• File creation and code execution

• Unlimited Projects

• Google Workspace integration

Pro is the right call for daily users who hit Free’s limits regularly. If you’re a developer who runs Claude Code sessions a few times a week, Pro covers most workflows.

Watch out: if ANTHROPIC_API_KEY is set in your shell, Claude Code bills at API rates, ignoring your subscription entirely.

Max: $100 or $200/month

Max comes in two tiers:

• Max 5x: $100/month: 5× the session capacity of Pro

• Max 20x: $200/month: 20× the session capacity of Pro

Max isn’t a different model tier. It’s a bigger bucket. You get the same Claude models as Pro: just more headroom before hitting limits.

Max 20x makes financial sense for heavy users. At current API rates, Sonnet 4.6 costs $3/M input and $15/M output. A daily user burning several million tokens per week can easily exceed $300/month on raw API. The $200 flat rate is often cheaper.

Max plans are monthly-only: no annual discounts are available.

Team and Enterprise Plans

Team Plan

Team plans require a minimum of 5 seats and come in two tiers:

• Standard: $25/seat/month (billed monthly) or $20/seat/month (billed annually)

• Premium: $125/seat/month (billed monthly) or $100/seat/month (billed annually)

Standard covers most organizational collaboration needs. Premium adds Claude Code, making it the right choice for engineering teams building with or on top of Claude.

You can mix Standard and Premium seats on the same team: useful if only part of your org needs Claude Code access.

Enterprise Plan

Enterprise is custom-priced, starting around $20/seat/month with API usage billed separately on top.

What Enterprise adds over Team:

• HIPAA readiness

• SSO and SCIM

• Audit logs

• Custom data retention

• Admin spend limits per user

Token costs are metered directly at standard API rates: there’s no included usage in the seat fee. Admins can set per-user spend caps.

Enterprise is the right fit if compliance or procurement is in the room.

Claude API Pricing

Cut your Claude API costs in production

Mem0 retrieves relevant memory instead of re-injecting full conversation history. Use it with Claude to reduce repeated input context while keeping personalization intact.

Start free with Mem0 →

What Actually Drives Claude API Costs?

The price per token is only the starting point. Your actual Claude API cost depends on how many tokens you send, how many tokens Claude generates, how much context is cached, and how often your application calls the model.

• Input tokens: Every word of your prompt, conversation history, and system instructions counts. This is usually the largest cost driver in production, because it grows every turn unless something actively manages it.

• Output tokens: What Claude generates back is priced higher per token than input across every model. Longer, more detailed responses cost proportionally more.

• Cache reads/writes: Reusing a cached prompt costs a fraction of standard input price, but there’s a small write surcharge the first time, and the cache expires after its TTL (5 minutes by default, or 1 hour with extended caching).

• Long conversation history: Every prior turn typically gets resent on the next call unless you’re actively managing context, which is exactly what makes multi-turn agents expensive at scale.

• Tool schemas/results: Tool definitions and the results tools return both consume tokens on every call where those tools are available, whether or not the model actually uses them.

• Agent/subagent calls: Each subagent runs its own context window from scratch, so costs multiply by however many run in parallel, not just by how much work gets done.

Model Pricing: Haiku, Sonnet, Opus

All prices are per million tokens (MTok), USD.

Sonnet 5’s $2/$10 pricing is permanent, not introductory. Anthropic had originally framed this as launch pricing through August 31, 2026, with a step-up to $3/$15 scheduled for September 1. On August 10, 2026, Anthropic cancelled that increase and made $2/$10 the standard, ongoing rate. If you budgeted for the September increase, you can stand down.

Haiku 4.5 is the budget workhorse: fast, cheap, good for high-volume classification and simple tasks.

Sonnet 4.6 is the previous-generation production default. At $3/$15, it now costs 50% more than Sonnet 5 for the successor model, which is an unusual position for a newer model to be in.

Opus 5 (released July 24, 2026) is Anthropic’s current flagship, replacing Opus 4.8. It’s priced identically to Opus 4.8 at $5/$25, positioned as coming close to Fable 5’s frontier intelligence at half Fable’s price. It’s now the default model on Max and the strongest model available on Pro. Opus 4.8 (released May 28, 2026) remains available at the same rate as a fallback model, it hasn’t been retired, just superseded as the default. The tokenizer change introduced with Opus 4.7 (up to 35% more billable tokens for the same text) carries forward into both Opus 4.8 and Opus 5, so factor this into cost estimates regardless of which one you use.

Automating with Claude: The Agent SDK Credit Pool

If you’re running Claude through cron jobs, CI pipelines, claude -p scripts, or any third-party agent that authenticates via your Claude subscription rather than a standalone API key, this section is about your specific billing path.

Programmatic usage, the Agent SDK, headless claude -p, Claude Code GitHub Actions, and third-party agent apps, now draw from a separate monthly credit pool rather than your interactive subscription limits:

Your interactive usage, Claude Code in the terminal, Claude Cowork, and chat on web/desktop/mobile, is unaffected and stays on your normal subscription limits. This credit pool exists specifically because programmatic, agentic usage behaves completely differently from interactive use: a human sends a handful of prompts a day, while an automated agent can generate thousands of requests, loop, retry, and run continuously. That pattern was never what the subscription pools were sized for.

The credit is billed at standard API rates and doesn’t roll over month to month. Once it’s exhausted, further programmatic usage is billed at standard API rates on top if you’ve enabled overage; otherwise, it stops. If you’re an API-key-only user on the Claude Platform with no subscription, this doesn’t apply to you at all: you’re already paying standard per-token rates with no separate credit needed.

Practically, this means: if you’re running a lightweight scheduled script on Pro, $20/month in credit likely covers it. If you’re running a CI pipeline that triggers Claude Code agent workflows on every pull request, or a production automation loop, budget against Max 5x or Max 20x credit allowance specifically, not your interactive plan’s usage limits, since the two no longer share a pool.

Claude Code Pricing: Subscription vs. API Framework

Both billing paths run through Claude Code, and picking the wrong one for your workload is a common, avoidable cost mistake.

• Subscription (Pro, Max, Team, Enterprise seat) fits interactive use: You’re typing into the terminal, reviewing diffs, iterating in real time. Cost spikes here show up as hitting a rate limit, not a surprise invoice, since you’re capped by the plan’s usage pool rather than billed per token in real time.

• API key billing fits scripted, automated, or high-volume work: CI pipelines, batch jobs, and programmatic code generation via the Agent SDK bill per token with no usage ceiling other than what you configure. This gives you tighter cost control (spend limits, caching, batch discounts) but also means there’s no rate-limit backstop: a runaway loop bills you directly rather than just getting throttled.

• The practical rule: if a human is driving the session, a subscription is almost always the better economics. If nothing is watching the session in real time, use the API with a spend limit configured, because an unattended agent on a subscription just hits a wall (frustrating, but free), while the same agent on an API key can generate a real bill before anyone notices.

What Are the Three Mechanics That Control Your Real Claude Code Cost?

Two of these are active mechanics today. The third existed for a period in 2026 and was removed, included here because it explains billing behavior some users may still remember or read about elsewhere.

• 5-hour rolling session window: A burst-protection limit that opens with your first prompt and covers short-term activity. This is the limit most people hit first, and it resets on a rolling basis rather than a fixed daily schedule.

• Weekly active-compute cap: A separate, harder ceiling on total compute used across a full week, shared across Claude Code, Claude.ai chat, and Cowork. This is the one that actually stops you cold: hitting the 5-hour window just means waiting a few hours, but hitting the weekly cap means waiting for the weekly reset. If your workflow already looks clean and you’re still hitting this weekly, that’s a real signal to consider a higher tier.

• Peak-hour burn multiplier (historical, not currently active): From March 26, 2026, Anthropic reduced 5-hour limits during weekday peak hours (5–11 AM PT), meaning the same usage burned through the window faster during that window. Anthropic removed this peak-hour reduction on May 6, 2026, at the same time it doubled the base 5-hour limits for Pro, Max, Team, and seat-based Enterprise plans. As of this writing, time-of-day doesn’t change your burn rate the way it briefly did earlier in 2026, but it’s worth knowing this existed in case you see older advice referencing it.

What Causes Claude Code Bill Spikes? Usage Scenarios to Watch

These are documented patterns, several from community-reported incidents rather than official Anthropic statistics, but consistent enough across independent sources to be worth watching for.

How to Forecast Claude Code Pricing for Your Team

• Track Claude Code pricing with /cost: Running /cost inside an active session gives you real token usage and dollar figures for that specific session, the most direct way to see what a representative workflow actually costs before scaling it across a team.

• Monitor Claude Code cost with a statusline widget: Several community tools (ccusage, cc-budget, Claude Code Usage Monitor) surface daily and monthly burn rate from local logs, so you can catch a spike in progress rather than discovering it on next month’s invoice.

• Forecast from your heaviest users, not your average user: Team-wide averages hide the subagent-fan-out and long-session-growth patterns above; a forecast built only on median usage will underestimate the tail risk that actually drives surprise bills.

• Set a workspace spend limit as a hard backstop: For API-billed teams, a configured spend limit in the Console is the only mechanism that stops a cost incident regardless of which of the patterns above caused it.

How to Reduce Claude Code Costs: 10 Practical Tips

• Keep CLAUDE.md under 200 lines: Every line in this file gets re-sent on every turn. A bloated CLAUDE.md is pure recurring overhead, whether or not the model ever needs most of it.

• Add a .claudeignore: Excluding build artifacts, dependencies, and generated files keeps Claude Code from indexing or reading content that adds tokens without adding value.

• Use /compact at natural breakpoints: Manually compacting at the end of a logical unit of work, rather than waiting for autocompact to fire mid-task, gives you more control over what survives the summary.

• Use /clear when switching topics: Starting a fresh context for an unrelated task avoids carrying irrelevant history forward at full token cost.

• Audit and remove unused MCP servers: Every connected server adds overhead on every turn it’s available, whether or not it gets called. Disconnect what you’re not actively using.

• Default to Sonnet; use Opus for complex tasks: Reserve the flagship model for work that actually needs its reasoning depth; routine tasks rarely need it.

• Cap extended thinking: Set an explicit thinking-token budget rather than letting every request default to maximum reasoning depth, especially for simple tasks.

• Use Plan mode for large tasks: Getting the plan right before execution reduces the back-and-forth correction cycles that otherwise burn tokens.

• Schedule long-running agent tasks during off-peak hours: While the peak-hour rate multiplier itself has been removed as of May 2026, off-peak scheduling still reduces contention and queueing on shared infrastructure.

• Set API workspace spend limits: For teams billing through the API, this is the backstop that catches every other failure mode on this list if it slips through anyway.

How to Cut Claude API Costs with Memory

Here’s the problem most developers hit at scale: multi-turn conversations get expensive fast.

Every time a user sends a message, the full conversation history goes back into the context window. A 20-turn conversation might carry 15,000+ tokens of history on every single request: tokens you’re paying for repeatedly, even though most of that history is redundant.

This is token bloat. And it compounds. By turn 50, you’re sending 40,000+ tokens of context just to answer a simple follow-up question.

Prompt caching helps, but it doesn’t solve the root problem. Cache TTLs expire. Long conversations overflow cache boundaries. And you’re still paying write costs on every cache refresh.

The cleaner fix: replace raw conversation history with compressed memory. Instead of replaying the full transcript, you store a structured summary of what matters: user preferences, prior decisions, key facts, and inject only that into each new request.

Mem0’s persistent memory infrastructure does exactly this for Claude. It sits between your application and the Claude API, automatically extracting and compressing relevant context. In production deployments, this approach reduces token usage by up to 90% compared to naive full-history injection.

The math is straightforward. If you’re spending $500/month on Sonnet 4.6 API calls and 60% of that is redundant conversation history, a 90% reduction on that portion saves ~$270/month, before you’ve changed a single model or prompt.

💡 Building with Claude?

Mem0 cuts token costs by up to 90% by replacing full conversation history with compressed memory. Works with Claude’s API out of the box: no prompt engineering required.

Start free: 50 memories, no credit card. → persistent memory infrastructure

Building with Claude in production? The fastest way to reduce repeated API spend is to stop sending the same context every turn. Read: how to reduce LLM token costs

Prompt Caching

Prompt caching lets you reuse previously processed content: system prompts, documents, and conversation history at a fraction of the standard input price. You pay once to write to cache, then read back at 90% off.

For Sonnet 4.6, a system prompt that costs $3.00/M at standard rates drops to $0.30/M on cache reads. The write surcharge pays for itself after just a few requests.

Two TTL options: 5-minute (default) and 1-hour (extended caching, higher write cost).

Batch Processing

The Batch API processes requests asynchronously within a 24-hour window in exchange for a flat 50% discount on all input and output tokens: across every Claude model.

At batch pricing:

• Sonnet 4.6: $1.50 input / $7.50 output per million tokens

• Haiku 4.5: $0.50 input / $2.50 output per million tokens

• Sonnet 5: $1.00 input / $5.00 output per million tokens

Ideal for content generation, data classification, document analysis, and any workload where real-time responses aren’t required.

Tools and Extras

How to Choose the Right Claude Plan

Single developer, less than 10 hours/week: light use, no coding agents: Free or Pro ($20/mo)

• Full-time engineer, daily use: heavy sessions, Claude Code, multi-step workflows: Max 5x ($100/mo)

• Extreme power user: running Agent Teams, 300M+ tokens/month: Max 20x ($200/mo) is often cheaper than the raw API

• Team without Claude Code: Team Standard ($20/seat/mo annual)

• Engineering team with Claude Code: Team Premium ($100/seat/mo annual)

• Enterprise: Compliance-sensitive org (HIPAA, SSO, audit logs, 500K context)

• Developer building a product: API directly: pay per token, use Batch API + prompt caching to control costs

One thing to check before subscribing: if you’re a developer, confirm whether you’re hitting your plan’s session limits or whether you’re accidentally billing via API key. These are two completely different billing paths.

How Does Claude API Pricing Compare to GPT and Gemini?

Here’s how Claude Sonnet 5 stacks up against the closest competitors at the mid-tier:

At the flagship tier:

Raw list price: Claude isn’t the cheapest option. GPT-4.1 at $2/$8 and Gemini 2.5 Pro at $1.25/$10 undercut Sonnet on paper.

Prices move often enough that a static table goes stale. If you want to run the numbers on your own token mix, LLM Cost Calculator compares Claude, GPT and Gemini rates side by side.

Where Claude competes: prompt caching is more aggressive than OpenAI’s (90% off cache reads vs ~50% for most OpenAI models, though rates vary by model and may have changed; verify at openai.com/api/pricing). For applications with repeated system prompts or long documents, effective Claude costs can drop well below list price. Anthropic’s 1M context window also means fewer chunking workarounds compared to models with smaller windows.

Frequently Asked Questions

Q. What is the cheapest way to use Claude?

The cheapest way is the Free plan at $0: no credit card needed. For API access, Haiku 4.5 is the most affordable model at $1/M input and $5/M output tokens. Combine it with the Batch API (50% off) for async workloads, and you’re looking at $0.50/$2.50 per million tokens: the lowest Claude API rate available.

Q. Is Claude Pro worth $20/month?

For daily users who regularly hit Free’s rate limits, yes. Pro gives you higher session capacity, Claude Code, file creation, code execution, and Google Workspace integration. The annual plan at $200/year ($17/month) makes it even more cost-effective. If you’re only using Claude a few times a week, Free may be sufficient.

Q. What’s the difference between Max 5x and Max 20x?

Both Max tiers give you access to the same Claude models as Pro. The difference is session capacity: Max 5x gives you 5× Pro’s per-session limit; Max 20x gives you 20×. Neither is a model upgrade: they’re larger usage buckets. Max 20x at $200/month is aimed at users running Agent Teams or sustained heavy workloads where the flat rate beats pay-per-token API billing.

Q. How much does Claude API cost for a heavy user?

It depends on model and volume. A developer sending 10 million tokens/day on Sonnet 5 at a 50/50 input/output mix would spend roughly $60/day at standard rates ($2/M input × 5M + $10/M output × 5M). With prompt caching on repeated system prompts and Batch API for async jobs, effective costs can drop by 50–90%. For very high-volume workloads, Anthropic offers volume discounts: contact their sales team.

Q. Does Claude have a free API tier?

The Claude API has no ongoing free tier. However, new users may receive a small amount of free starter credits on signup. After those are used, it’s pay-as-you-go: you’ll need to add a payment method. The free claude.ai product is separate from the API and doesn’t include API access.

Q. What is prompt caching and how much does it save?

Prompt caching stores reusable content: system prompts, documents, conversation history, so you pay full price once, then 90% less on subsequent reads. For Sonnet 4.6, cached reads cost $0.30/M instead of $3.00/M. There’s a small write surcharge (25% above standard input price), but it pays for itself after just a few cache hits. Most impactful for apps with consistent system prompts or large repeated context.

Q. Is “Anthropic pricing” the same thing as “Claude pricing”?

Not exactly. “Claude pricing” usually refers to the consumer subscription plans (Free, Pro, Max, Team, Enterprise) billed through the Claude app at claude.ai. “Anthropic pricing” is the broader term that also covers Claude API token rates, billed separately through the Claude Platform at platform.claude.com. In practice, people use both terms interchangeably, but if you’re trying to find the right rate card, it helps to know whether you mean the app subscription or the API.

Q. What is the Agent SDK credit pool, and how does it affect automation costs?

If you run Claude through the Agent SDK, headless claude -p CI pipelines, or a third-party agent authenticating via your Claude subscription, that usage now draws from a separate monthly credit rather than your interactive plan limits: $20 on Pro, $100 on Max 5x, $200 on Max 20x, $20/seat on Team Standard, and $100/seat on Team Premium. Your regular Claude Code terminal sessions, Cowork, and chat usage aren’t affected and stay on your normal subscription limits. The credit is billed at standard API rates, doesn’t roll over, and once it’s used up, further automated usage either stops or bills at standard API rates on top, depending on whether you’ve enabled overage.

Useful Sources

• Claude Plans & Pricing: Official Page

• Claude API Pricing Documentation

• Anthropic Privacy Center: API Data & Training

• Mem0: Persistent Memory for Claude