Claude Code Pricing Guide: Plans, Credits, and Cost Optimization (2026)

TL;DR

I pay about $80-150/month for Claude Code and I use it 6-7 days a week. Here is the short version of what you need to know. Claude Code runs on Anthropic's API pricing: $3 per million input tokens and $15 per million output tokens for Claude Sonnet 4. A typical coding session costs $0.50-$5. For heavy daily use, expect $50-$200/month. The actual number depends almost entirely on how you manage context. I will show you exactly how to measure and reduce it.

Why I wrote this guide

I have used Claude Code as my daily driver since early 2026. In the first month, my API bill hit $340. I panicked, audited every session, and cut it to $80 the next month without changing how much I shipped. The difference was not "using it less." It was understanding where the money goes.

Most pricing guides for Claude Code are either outdated (pre-June 2026 billing changes) or embedded inside general setup tutorials that spend two paragraphs on cost. I wanted a single page that answers every pricing question I have been asked by other developers: what the plans mean, how credits work, what Max mode costs, how Cursor and Copilot compare, and what a realistic monthly budget looks like.

Claude Code pricing: the base model

Claude Code is not a standalone product with its own subscription. It is a CLI tool that talks to Anthropic's API. You pay Anthropic for API usage, not a flat monthly fee.

There are two ways to pay:

1. Anthropic API (direct)

You create an account at console.anthropic.com, load credits, and Claude Code uses your API key. This is the default path.

Per-token pricing (Claude Sonnet 4, the default model for Claude Code):

What this means in practice: a single /ask question that reads 10,000 tokens of context and generates 500 tokens costs about $0.04. A /build session that reads 50,000 tokens and generates 3,000 tokens costs about $0.20. Max mode (which uses extended thinking) can cost 3-5x more.

2. Anthropic Console (credits)

You buy credits on console.anthropic.com. $5 gets you $5 of API usage. There is no discount for buying in bulk. Credits never expire.

This is the recommended path for individuals because it caps your spending. When credits run out, the API returns errors instead of racking up an unlimited bill. I use this approach and reload $50 at a time.

Max mode pricing

Max mode enables extended thinking (Claude thinks for longer before responding). Extended thinking tokens are billed at the output rate ($15/M). A Max mode session can generate 10,000-50,000 thinking tokens on top of the visible output. This is why a single Max mode request can cost $1-3 instead of $0.20.

You can see your per-session cost by running:

claude --cost

This prints the token usage and dollar amount for the current session. I check this after every long /build command. It is the single most useful habit for cost control.

June 2026 billing change: what actually happened

On June 15, 2026, Anthropic changed how Claude Code billing works. The old model charged per-request with a vague "compute unit" system. The new model is straightforward per-token billing.

Key changes:

• Old "compute unit" pricing replaced with standard token pricing
• Sonnet 4 input dropped from $4/M to $3/M
• Cache read dropped from $0.375/M to $0.30/M
• Max mode thinking tokens are now billed transparently (previously bundled)

If you signed up before June 2026, your old API key still works but uses the new pricing. There is nothing to migrate. The change was automatic and backward-compatible.

Claude Max plan: is it worth it?

Claude Max is a separate subscription ($100/month for individuals, $200/month for teams) that gives you higher rate limits and "significantly more usage" on claude.ai. It is not related to Claude Code pricing.

Important: Claude Max does not give you free API credits. You still pay per-token through the API for Claude Code. The Max plan gives you more usage on the web chat interface, not the CLI.

Some developers confuse this, buy a Max plan thinking it covers their Claude Code usage, and then get surprised by API bills. Do not make this mistake. Claude Code always goes through the API, and API usage is always per-token.

Real monthly costs: data from actual usage

I track my Claude Code costs weekly. Here are three real profiles:

Profile A: Weekend builder (me in early 2026)

• Uses Claude Code 3-4 days/week, 1-2 hours/day
• Mostly /ask questions and short /build commands ($5K-30K tokens each)
• Cost: $40-80/month

Profile B: Full-time indie dev (current)

• Uses Claude Code 6-7 days/week, 3-6 hours/day
• Mix of /ask, /build, occasional Max mode
• Cost: $80-150/month

Profile C: Power user with Max mode

• Uses Max mode for complex refactors 2-3 times/day
• Regular Claude Code for everything else
• Cost: $200-400/month

The biggest variable is not how many hours you use it. It is context size. A session with 100,000 tokens of context costs 20x more per request than a session with 5,000 tokens. I will show you how to keep context small without losing productivity.

Cost optimization: the only techniques that actually work

1. Use /compact aggressively

After 10-15 turns in a session, your context is bloated with old conversation history. Run:

/claude compact

This summarizes the conversation and frees up context. I do this every 8-10 turns. It cuts per-request costs by 40-60% in long sessions.

2. Start new sessions for new tasks

Claude Code sessions accumulate context. If you finish a feature and start a new one, exit the session and start fresh:

# In Claude Code REPL
/exit

# Start new session for new task
claude

A fresh session has zero conversation history, so every request is cheaper. I start 5-8 new sessions per day instead of running one marathon session.

3. Limit file context with `.claude/settings.json

Claude Code reads files in your project to provide context. You can tell it to ignore large or irrelevant files:

{
  "ignorePatterns": [
    "node_modules/**",
    "dist/**",
    "*.lock",
    "*.log",
    "package-lock.json",
    ".next/**"
  ]
}

Less context = lower cost. This also makes Claude Code faster and more accurate because it is not distracted by build artifacts.

4. Use /ask for research, /build for implementation

/ask does not have file-editing permissions and uses less context overhead than /build. If you are asking design questions, exploring a codebase, or debugging, use /ask. Reserve /build for actual code changes.

# Ask about the codebase (cheaper)
/ask How does the auth middleware work in this project?

# Build the feature (more expensive)
/build Add rate limiting to the auth middleware

5. Prefer Sonnet 4 over Opus 4 for daily work

Sonnet 4 is the default model in Claude Code. It costs $3/$15 per million tokens. Opus 4 costs $15/$75 per million — 5x more. Opus is better at complex reasoning, but Sonnet handles 90% of coding tasks. I reserve Opus for architecture decisions and difficult bugs.

Switch models in Claude Code:

# Use Opus for a specific session
claude --model claude-opus-4-20250514

# Set default model in .claude/settings.json
{
  "model": "claude-sonnet-4-20250514"
}

6. Monitor with `/cost

Make /cost a reflex. Check it after every major operation:

/build Refactor the payment service

# ... Claude Code does its thing ...
/cost

# Event: 42,351 input + 3,827 output = $0.31

This builds intuition about what costs money. You will quickly learn that reading large files is cheap but generating long responses with lots of context is expensive.

Claude Code vs Cursor vs GitHub Copilot: pricing comparison

If cost is your primary concern, here is how the three tools compare:

Claude Code is the most expensive option. There is no sugar-coating it. It also gives you the most control: you choose which model to use, you can use Max mode for hard problems, and you are not rate-limited by a subscription tier.

Cursor is the middle ground. $20/month gets you 500 fast premium requests plus unlimited slow requests. For most solo developers, this is enough.

Copilot is the cheapest. $10/month for unlimited autocomplete and chat. It is less capable on complex tasks but handles boilerplate well.

If you are price-sensitive, my recommendation: start with Copilot ($10/month). If you need more power, add Cursor ($20/month). If you are shipping daily and context control matters, go with Claude Code and budget $50-100/month.

Common pricing mistakes

Mistake 1: Setting up an API key without a spending limit. Go to console.anthropic.com → Settings → Limits and set a monthly hard cap. I set mine at $200. This prevents a buggy script from running up a $1,000 bill overnight.

Mistake 2: Using Max mode for everything. Max mode costs 3-5x more than regular mode. It is designed for problems where "think harder" is the bottleneck: complex architecture decisions, debugging heisenbugs, writing novel algorithms. Using it for "add a login form" is burning money.

Mistake 3: Ignoring cache. Anthropic caches your prompt prefixes automatically. If you structure your prompts consistently (same system prompt, same file structure), 30-50% of your input tokens can hit the cache at $0.30/M instead of $3/M. This happens automatically — you do not need to configure anything. Just avoid changing your prompt structure unnecessarily.

Mistake 4: Comparing per-request costs across tools. A single Claude Code /build request that costs $0.30 accomplishes more than a Copilot autocomplete that costs a fraction of a cent. The unit of value is "task completed," not "API call made." Compare tools by how much they help you ship, not by cost per request.

Setting up a cost monitoring script

I run this shell alias to track my Anthropic API spending:

# Add to ~/.zshrc or ~/.bashrc
alias claude-usage='curl -s https://api.anthropic.com/v1/organizations/usage \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(f\"Month: \${d.get(\"total_spend\",0):.2f}\")"'

Anthropic also shows usage in the Console: console.anthropic.com → Usage. I check this weekly, not daily. Daily checking leads to anxiety without actionable insight.

When to upgrade from Copilot to Cursor to Claude Code

Not every developer needs Claude Code. Here is my heuristic:

• Copilot is enough if you write code mostly in an IDE, value simplicity, and do not need terminal-first workflows. The $10/month plan is unbeatable for what it offers.
• Move to Cursor if you want AI-native code editing (inline generation, tab-to-accept, Composer for multi-file changes) and are willing to pay $20/month.
• Move to Claude Code if you work primarily in the terminal, need agentic workflows (Claude Code executes shell commands, creates files, runs tests autonomously), or want Max mode for deep reasoning.

I use all three. Copilot for quick autocomplete in VS Code, Cursor for heavy IDE sessions, and Claude Code for terminal-based work. The combined cost is about $130/month. For a full-time indie developer, this is a reasonable tool budget — especially compared to hiring.

The bottom line

Claude Code costs money. Real money — not "basically free" like some AI tools. A heavy user can spend $200-400/month. But it also handles work that would otherwise take hours of manual effort.

The key to affordable Claude Code is not "use it less." It is:

1. Use /compact every 8-10 turns
2. Start fresh sessions for new tasks instead of running one marathon session
3. Reserve Max mode for genuinely hard problems
4. Set a monthly spending cap

Do these four things and your bill will drop 40-60% without changing how much code you ship. I went from $340 to $80 without working differently — I just worked smarter about context.

If you want to dive deeper into Claude Code workflows, check out the Claude Code Hub for the full topic cluster: setup guides, workflow patterns, prompt engineering, and real-world case studies.