I Tracked My Claude Code Costs for 90 Days — Here's the Real Math

The Test: 90 Days of Daily Claude Code Usage

Every Claude pricing article on the internet does the same thing: copy the pricing table from Anthropic's website, add a paragraph of obvious commentary, and call it analysis. I did something different. I tracked every dollar I spent on Claude Code for 90 consecutive days of real production work.

The setup: I use Claude Code as my primary coding tool. Terminal-based, agentic workflow, running against real codebases ranging from 5,000-line Astro sites to 80,000-line TypeScript monorepos. I write code 8-10 hours per day, 5-6 days per week. Claude Code handles everything from greenfield feature work to debugging, refactoring, and deployment automation.

For the first 30 days, I ran Claude Code on the Max 20x plan ($200/month) exclusively. For days 31-60, I switched to pure API access to compare. For days 61-90, I ran a hybrid setup — Max subscription for primary work, API for overflow and batch tasks. I logged every session: duration, token count, task type, and whether I hit rate limits.

This article is the full cost analysis. Not a feature review — if you want the tool comparison, I wrote a similar TCO breakdown for Linear vs Jira. This is strictly about the money: what Claude Code actually costs when you use it seriously, and which pricing tier makes financial sense for different usage profiles. Methodology details are in our SaaS testing framework.

Anthropic's Pricing Tiers Explained

Anthropic's pricing structure has more tiers than most developers realize. Here's the complete breakdown as of April 2026.

Consumer Plans

Business Plans

API Pricing (Pay-as-You-Go)

The sticker prices look clean. The reality is messier. Subscription tiers don't tell you when you'll hit rate limits. API pricing doesn't tell you how fast token consumption scales with conversation length. And none of the tiers tell you what a typical coding day actually costs. That's what the next section covers.

All pricing figures are based on published pricing pages as of April 2026. Anthropic adjusts rates periodically — verify current pricing at anthropic.com before making purchasing decisions.

My Real Costs: Month by Month

Here's what I actually spent. No projections, no estimates — these are real numbers from my billing dashboard.

Month 1: Max 20x Only ($200 Flat)

The first month was straightforward. I paid $200 for the Max 20x plan and used Claude Code as my sole coding assistant. I tracked daily usage manually with a timer and logged token counts from session summaries.

At $8.70 per working day, this felt like a bargain. I hit rate limits 12 times across the month, mostly during afternoon sessions when I was deep in multi-file refactoring work. Each limit lasted 10-30 minutes. Annoying but not productivity-killing — I used the cooldown periods for code review, documentation, or switching to non-Claude tasks.

The rate limits followed a pattern. Short, focused sessions (under 45 minutes) almost never triggered limits. Long sessions with deep context windows (2+ hours on the same codebase) would reliably hit a limit around the 90-minute mark. I learned to start fresh conversations proactively rather than running a single session for hours.

Month 2: API Only ($1,620)

To understand what the subscription was actually saving me, I cancelled Max and switched to pure API access for 30 days. Same work, same hours, same codebases. The difference: pay-per-token with no usage ceiling.

The API month was eye-opening. With no rate limits, I used Claude Code more aggressively. Token consumption jumped 31% — not because I was wasting tokens, but because I wasn't being forced into cooldown breaks. I let conversations run longer, used more ambitious multi-file operations, and relied on Opus for complex architectural decisions I would have tried to handle with Sonnet during the subscription month.

The cost breakdown: Sonnet accounted for $744 of the total (12.1M tokens at ~$61.50/MTok blended). Opus accounted for $837 (5.6M tokens at ~$149.40/MTok blended). Haiku was negligible at $39. The lesson: Opus usage is the cost multiplier. At 5x the token price of Sonnet, even 30% Opus usage dominated the bill.

Zero rate limits, though. Not once in 22 days did I have to wait. The productivity difference was noticeable — uninterrupted flow for entire work sessions. But at $73.60/day vs $8.70/day, the premium for that continuity was steep.

Month 3: Hybrid ($2,380)

For the final month, I ran the setup I now use permanently: Max 20x for daily interactive coding, supplemented by API access for specific use cases.

Month 3 was the most expensive because I had the worst of both worlds — I was paying for the subscription while also burning API tokens for automated batch tasks (code review pipelines, documentation generation, test writing) that ran concurrently with my interactive sessions. The API overflow was predominantly Opus for complex code review work that I'd set up as background agents.

The lesson: a hybrid approach only saves money if you're disciplined about what goes through the subscription vs the API. If you're running background agents alongside interactive work, the API costs add up fast.

90-Day Summary

The aggregate numbers tell a clear story: the Max 20x subscription at $200/month is by far the most cost-effective option for heavy individual use. The catch is the rate limits. If you can structure your work around occasional 15-minute cooldowns, the subscription is an order of magnitude cheaper than API access for the same volume of work.

Subscription vs. API: The Breakeven Math

The question everyone asks: at what point does the subscription beat pay-per-token API access?

I calculated this by mapping my actual token consumption patterns to API pricing. The key variables are daily coding hours, model mix (Sonnet vs Opus), and average conversation length.

Pro ($20/month) Breakeven

The Pro plan's standard usage limits accommodate roughly 60K-100K tokens per day of interactive use before rate limiting becomes disruptive. At Sonnet API rates ($3/$15 per MTok), that's approximately $0.90-$1.50/day in equivalent API spend.

Pro breaks even vs API at approximately 14-22 coding days per month. If you code with Claude at least 3-4 days per week, Pro is cheaper than API. Below that, API pay-as-you-go wins.

In practice: Pro is cheaper for virtually everyone who uses Claude Code regularly. The $20/month subscription pays for itself after about 15 days of light use. The question isn't whether to get Pro — it's whether you need Max.

Max 20x ($200/month) Breakeven

Max 20x allows roughly 1.2M-2M tokens per day before rate limits. At Sonnet API rates, that's $18-$30/day equivalent.

Max 20x breaks even vs API at approximately 7-11 heavy coding days per month. If you're coding 8+ hours per day for more than two weeks per month, Max saves money vs API.

The comparison to Max 5x ($100/month): Max 5x allows roughly 300K-500K tokens per day. It breaks even vs API at about 5-7 heavy coding days per month. For developers who code intensively 3-4 days per week (consulting, split between multiple projects), the 5x tier can be the sweet spot.

Breakeven by Usage Profile

These estimates assume primarily Sonnet usage. If your workflow is Opus-heavy (complex architecture, nuanced code review), the API costs roughly double and subscriptions become even more favorable. If you're mostly running Haiku for simple tasks, API stays cheap enough that subscriptions rarely save money.

Claude vs. Cursor vs. Copilot: The Cost Comparison

Claude Code doesn't exist in a vacuum. Here's how it stacks up against the two other major AI coding tools on pricing.

Pricing Side-by-Side

On raw price, GitHub Copilot is the cheapest at every tier. Cursor sits in the middle. Claude is the most expensive for equivalent usage levels. The question is whether the output quality justifies the premium.

Cost Per Quality

I've used all three tools extensively. The productivity difference matters more than the price difference.

GitHub Copilot excels at inline completions — fast, context-aware, and integrated into VS Code. For line-by-line coding (filling in function bodies, writing tests for existing patterns, boilerplate), it's the most efficient. Its chat mode (Copilot Chat) handles simple questions well but struggles with multi-file reasoning and complex refactoring. At $10-39/month, it's the clear winner for completion-focused workflows.

Cursor combines inline completions with a more capable chat interface and inline diff editing. The Composer feature handles multi-file edits better than Copilot. For IDE-centric developers who want AI embedded in their editor experience, Cursor is the best value — more capable than Copilot, cheaper than Claude for similar quality chat interactions. At $20-200/month, it covers a wider range of use cases than Copilot.

Claude Code operates differently from both. It's a terminal-based agent that reads your entire codebase, plans multi-step implementations, and executes them. It doesn't do inline completions — it does architecture. For complex tasks (building features from scratch, debugging production issues across multiple services, large-scale refactoring), Claude Code produces output that Copilot and Cursor can't match. The gap is largest on tasks that require reasoning across many files simultaneously.

My current setup: Copilot for inline completions ($10/month), Claude Code Max 20x for complex work ($200/month). Total: $210/month. I dropped Cursor because the overlap with Claude Code's capabilities made it redundant for my workflow. Your mileage will vary — developers who work primarily in a single IDE might prefer Cursor's integrated experience over Claude Code's terminal-first approach.

Which Tool for Which Profile

Token Economics: Why Your Costs Aren't What You Expect

Understanding how tokens work is critical to managing Claude Code costs. Most developers underestimate their token consumption because they think about messages, not context windows.

The Context Window Tax

Every message you send in a Claude Code session includes the entire conversation history plus your codebase context. The first message might send 10K tokens of context. By message 20, you're sending 80K+ tokens of accumulated conversation history — and paying for all of it as input tokens on every single turn.

This is the single most important thing to understand about Claude Code costs: token consumption per message increases linearly with conversation length. A 30-message conversation doesn't cost 30x a single message. It costs roughly 465x a single message in aggregate input tokens (the sum of 1+2+3+...+30 context loads).

The practical impact: starting a fresh conversation every 15-25 messages can reduce total token consumption by 30-40% compared to running a single long session. I tested this deliberately during Month 1. My longest sessions (50+ messages) consumed 3-4x the tokens of the same work done across multiple shorter sessions.

Input vs. Output: Where the Money Goes

Claude's API pricing charges different rates for input tokens (what you send) and output tokens (what Claude generates). For coding work, the ratio is heavily skewed toward input.

My 90-day token breakdown:

• Input tokens: 78% of total consumption
• Output tokens: 22% of total consumption

But because output tokens cost 5x more per token than input tokens (at Sonnet rates: $15 vs $3 per MTok), the cost split is different:

• Input token cost: 44% of total spend
• Output token cost: 56% of total spend

Output tokens are the cost driver even though input tokens dominate volume. When Claude Code generates a 200-line file implementation, that output is expensive. When it writes a short clarifying response, it's cheap. The takeaway: tasks that produce large code outputs (feature implementation, test generation, documentation) cost more than tasks that produce short outputs (debugging analysis, code review comments).

Model Selection Is a Cost Lever

Not every task needs Opus. My Month 2 API data showed that 30% of my Opus usage was on tasks that Sonnet could have handled — I was defaulting to the most powerful model out of habit, not necessity.

A practical model selection framework:

• Haiku ($1/$5 per MTok): Formatting, simple refactoring, boilerplate generation, test scaffolding. Anything where the structure is obvious and the AI just needs to execute it.
• Sonnet ($3/$15 per MTok): Feature implementation, debugging, code review, multi-file edits. The workhorse for 70% of coding tasks.
• Opus ($5/$25 per MTok): Architecture decisions, complex system design, nuanced code analysis where reasoning depth matters. Reserve for the 10-15% of tasks where Sonnet's output quality is noticeably worse.

Switching from 30% Opus to 15% Opus during Month 3 reduced my API overflow costs by roughly 20%. That's a material savings for a discipline change that took zero effort to implement.

Prompt Caching: The Hidden Savings

Anthropic offers prompt caching for API users — cached input tokens cost 90% less than uncached. For Claude Code sessions where the same codebase context is sent repeatedly, this is significant.

In practice, prompt caching reduced my API input costs by 35-45% during Months 2 and 3. The caching kicks in automatically for repeated context windows, so there's no configuration needed. If you're on API access, verify that caching is active — the savings are substantial for long sessions against the same codebase.

Subscription users don't need to think about caching — it's handled behind the scenes. But it's one reason the subscription feels like such good value: Anthropic is absorbing the caching optimization on their end and giving you a flat rate.

Team and Enterprise: When to Upgrade

For solo developers, the Max plan is the ceiling. But if you're buying for a team, the economics shift.

Team Plan Math

The Team Standard plan ($20/seat/month) gives each developer Pro-equivalent access with centralized billing and admin controls. The Team Premium plan ($100/seat/month) gives 5x usage per seat.

For a 10-person engineering team:

Team Standard is the same price as 10 individual Pro plans but adds admin controls and usage visibility. It's a no-brainer for any team of 3+ developers — you get governance features at zero marginal cost.

Team Premium vs individual Max plans depends on how many heavy users you have. If 3 out of 10 developers are power users and the rest are moderate, putting everyone on Team Premium ($1,000/month) is cheaper than putting the 3 heavy users on Max 20x ($600) plus 7 on Pro ($140) = $740. But the Premium plan gives everyone elevated limits, which means moderate users won't hit rate limits during crunch periods.

When Enterprise Makes Sense

Enterprise pricing ($20/seat base + usage at API rates) makes sense when:

• SSO/SAML is a requirement. If your security team mandates single sign-on, Enterprise is the only tier that supports it. This alone justifies the upgrade for most companies over 50 employees.
• You need audit logs. Enterprise provides detailed usage logging — who ran what queries, when, and how many tokens. Required for SOC 2 compliance in many configurations.
• SCIM provisioning. Auto-provisioning and de-provisioning via your identity provider. Critical for companies with frequent hiring/offboarding.
• Usage varies wildly across the team. The base seat cost is low ($20), and you only pay API rates for actual usage. This is ideal when some developers barely use Claude while others burn through tokens constantly — you're not overpaying for unused capacity.

The Enterprise model's usage-based component works well for heterogeneous teams. A 50-person org where 10 developers are heavy users, 20 are moderate, and 20 rarely use Claude might spend $1,000 base + $3,000-5,000 usage = $4,000-6,000/month. The same team on Team Premium would pay $5,000/month flat — potentially more expensive with less flexibility.

The Verdict

After spending $4,200 across 90 days and tracking every token, here's where I land on Claude Code pricing.

The Max 20x plan at $200/month is the best value for serious developers. At 8+ hours of daily coding, it delivers roughly $280-350/month of equivalent API value. The rate limits are real but manageable if you structure your work around shorter conversations. For pure individual coding work, nothing else in Anthropic's lineup comes close on cost efficiency.

API access is the worst value for interactive work and the best value for automation. Paying per-token for your daily coding is 5-10x more expensive than a subscription. But for background tasks — automated code review, batch documentation generation, CI/CD integration — API access is the right model because you pay only for what runs.

The hybrid trap is real. My Month 3 experiment showed that running Max + API simultaneously can be the most expensive option if you're not disciplined. Use the subscription for interactive work. Use the API for discrete automated tasks. Don't let them bleed together.

Recommendations by profile:

• Trying Claude Code for the first time: Start with Pro ($20/month). It's enough to evaluate whether Claude Code fits your workflow before committing to higher tiers.
• Daily coder, 3-5 hours: Pro ($20/month) for most workflows. Upgrade to Max 5x ($100/month) if you hit rate limits more than twice per week.
• Full-time Claude Code user, 6-10 hours: Max 20x ($200/month). The math is unambiguous at this usage level.
• Team lead buying for 5-20 developers: Team Standard ($20/seat) for the admin controls. Upgrade individual heavy users to Max if they hit limits consistently.
• Enterprise with compliance requirements: Enterprise ($20/seat + API usage). The SSO/SAML and audit log requirements alone justify the model for any company where security compliance is non-negotiable.
• Running automated pipelines: API only. Don't waste a subscription seat on a CI bot. Haiku for simple tasks, Sonnet for standard work, Opus sparingly.

Claude Code is not cheap. At my usage level, it's a $200-2,400/month tool depending on how I configure it. But the productivity gain is real. I ship features faster, catch bugs earlier, and produce cleaner code than I did without it. The $200/month Max plan isn't a cost — it's a leverage multiplier on my engineering output. Whether that multiplier is worth the price depends entirely on what your time is worth.