The real costs of Claude Code

Tokens = money: understanding what gets billed

Every interaction with Claude Code consumes tokens, units of text that the model processes. Everything counts: your prompt, the conversation context, files Claude reads, MCP schemas, and of course the generated responses.

There are two types of tokens, billed differently:

• Input tokens: everything Claude receives, your message, the history, files read, MCP results
• Output tokens: responses generated by Claude, code, explanations, files

Output tokens typically cost 3 to 5 times more than input tokens.

Official Anthropic pricing (March 2026)

Per-model pricing via direct API

For a typical development session with Sonnet (the default model):

• Light session (30 min, simple questions): 50,000 tokens -> **$0.30**
• Medium session (2h, module refactoring): 200,000 tokens -> **$1.20**
• Intensive session (full day, large project): 500,000 tokens -> **$3.00**

MCP impact on costs: concrete calculations

MCPs have a direct impact on your token consumption, often overlooked. Here are estimates based on the actual MCP architecture.

Startup cost based on active MCPs

At the start of each session, Claude loads tool schemas from all configured MCPs. This "fixed cost" is paid before you even type your first message.

Simulation: a 2-hour session with different configurations

# Session type: feature development (module refactoring)

SCENARIO A: No MCP
  Startup             :    500 tokens input
  User prompts        :  5,000 tokens input
  Code read by Claude : 30,000 tokens input
  Claude responses    : 15,000 tokens output
  TOTAL               : 35,500 input + 15,000 output
  COST (Sonnet)       : ~$0.11 + ~$0.23 = ~$0.34

SCENARIO B: With 3 MCPs (filesystem, github, context7)
  MCP startup         :  8,000 tokens input
  User prompts        :  5,000 tokens input
  Code read by Claude : 30,000 tokens input
  MCP results         :  8,000 tokens input (call results)
  Claude responses    : 15,000 tokens output
  TOTAL               : 51,000 input + 15,000 output
  COST (Sonnet)       : ~$0.15 + ~$0.23 = ~$0.38

SCENARIO C: With 10 active MCPs
  MCP startup         : 25,000 tokens input
  User prompts        :  5,000 tokens input
  Code read by Claude : 30,000 tokens input
  MCP results         : 12,000 tokens input
  Claude responses    : 15,000 tokens output
  TOTAL               : 72,000 input + 15,000 output
  COST (Sonnet)       : ~$0.22 + ~$0.23 = ~$0.45

The difference between 0 and 10 MCPs for the same session is ~$0.11, which may seem modest per session but represents $30/month over 5 sessions/day.

Claude Max subscriptions: what you're actually buying

Claude Max (formerly Claude Pro) is a fixed-price subscription that seems unlimited, but isn't.

What Claude Max includes

• Priority access to Claude without queuing
• Increased message limit (not unlimited)
• Access to the latest models including Opus

The real limits

Claude Max is subject to message limits per time window (typically per hour or per day). These limits vary based on server load and aren't precisely published. In practice:

• Light usage (fewer than 20 messages/hour): you'll never hit the limit
• Heavy usage (continuous 4h+ sessions): you may experience throttling: Claude responds more slowly or asks you to wait

Plan comparison table

When to choose the direct API vs a subscription

Prefer a subscription (Pro or Max) if:

• You want predictable costs
• You use Claude Code daily for development
• You're getting started and want to explore without billing surprises

Prefer the direct API if:

• Your usage varies a lot (active some months, not others)
• You integrate Claude into your own tools
• You want precise control over which model you use
• Your usage is low (less than $50/month in API costs)

Hidden costs of third-party MCPs

Some popular MCPs rely on paid third-party APIs you must also subscribe to.

Cost/value optimization strategies

1. Only load the MCPs needed for the session

Use per-project .mcp.json files to load only relevant MCPs:

// For a frontend project without a database
// .mcp.json at the project root
{
  "mcpServers": {
    "filesystem": { ... },
    "playwright": { ... }
  }
}
// GitHub, PostgreSQL, Slack -> not loaded = context savings

2. Use /cost to monitor your consumption

# In a Claude Code session
/cost
# Shows: input tokens, output tokens, estimated session cost

Use this command regularly to identify expensive sessions and adjust your prompts.

3. Write precise prompts

A vague prompt generates a long, often unsuitable response that you'll need to correct with a second prompt. Double the cost for an inferior result.

# Expensive and inefficient
"Improve my code"

# Precise and cost-effective
"In src/auth/auth.service.ts, lines 45-60:
optimize the SQL query to avoid the N+1 problem.
Use eager loading with Prisma. Keep TypeScript types."

4. Prefer Sonnet over Opus unless the task warrants it

Opus costs 5x more than Sonnet. For most development tasks, Sonnet is sufficient. Reserve Opus for:

• Complex system architecture
• In-depth security analysis
• Massive refactors requiring a global view

5. Use /compact proactively

A lighter context = fewer input tokens per message. /compact can cut end-of-session costs by 2-3x.

Estimating your monthly budget

# Monthly calculation formula

Sessions/day x Days/month x Cost/session

Example: Independent developer, daily usage:
3 sessions/day x 20 days/month x $0.38/session
= ~$23/month via direct API

-> Claude Pro (~$20/month) would be more affordable and predictable
-> Claude Max (~$100/month) is only justified at 5+ intensive sessions/day

Next steps

• Context management: How context directly impacts your costs
• Myths about Claude Code: "Claude Code is free with Pro", debunked
• Security best practices: Security and savings go hand in hand
• Interactive configurator: Generate an optimized configuration for your usage
• Extended Thinking and Plan Mode: When to enable deep thinking (and its cost)