Cursor vs Claude Code: Which Costs More Per Project? (And How to Find Out)
If you run a dev agency, your team is probably using both.
Claude Code for agentic tasks — complex refactors, multi-file changes, anything that benefits from deep reasoning and a long context window. Cursor for day-to-day coding — autocomplete, quick edits, inline chat, the IDE workflow.
The billing is completely separate. Anthropic invoices you for Claude Code. Cursor invoices you separately. Neither tells you what either tool cost on any specific project.
So when a client asks why their project ran over budget, or when you're trying to figure out where your margin went, you're looking at two invoices, zero attribution, and a team that can't reconstruct which tool they used on which client.
This article breaks down what Cursor and Claude Code actually cost, where the differences matter, and how to get per-project visibility across both.
The Pricing Structure: What You're Actually Paying
Claude Code
Claude Code runs on Anthropic's API or subscription plans:
- Pro — $20/month, limited Claude Code access, hits rate limits quickly under heavy use
- Max 5× — $100/month per developer, 5× Pro capacity
- Max 20× — $200/month per developer, 20× Pro capacity
- Team Premium — $100/seat/month minimum 5 seats, centralized billing and admin controls
- API pay-as-you-go — Sonnet 4.6 at $3/$15 per million input/output tokens, Opus 4.6 at $5/$25
For agencies on fixed-price contracts, Team Premium or API billing is the relevant tier. Anthropic's own data puts average API-backed usage at $150–250 per developer per month.
One important note: Team Standard ($20/seat) does not include Claude Code. Only Team Premium does. Agencies that bought the wrong tier are paying for an entitlement their developers can't use.
Cursor
Cursor pricing:
- Hobby — Free, 2,000 completions/month, limited premium requests
- Pro — $20/month per developer, 500 fast premium requests, unlimited slow requests
- Business — $40/seat/month, centralized billing, admin controls, SSO
Cursor's "fast premium requests" are the expensive ones — these use frontier models (Claude, GPT-4o) rather than Cursor's base model. Once your 500 fast requests are exhausted, you either wait for slow requests or pay overage.
In June 2025, Cursor shifted from a fixed "fast request" allotment to usage-based credit pools. The Pro plan gives $20 in credits per month. Heavy agentic usage burns through this quickly — one developer reported $350 in Cursor overages in a single week during intensive project work.
The Stacking Problem
An agency with 8 developers on Team Premium Claude Code and Cursor Pro is paying:
Claude Code Team Premium: 8 × $100 = $800/month
Cursor Pro: 8 × $20 = $160/month
Total subscription floor: $960/monthPlus any API overages on Claude Code, plus Cursor credit overages on intensive projects. Before a single line of code is written, you're at $960/month in AI tooling subscriptions — with zero visibility into which client project any of it went to.
Where Claude Code Costs More
Claude Code is the expensive tool for deep, agentic work. The cost drivers:
Context window usage. Claude Code maintains full conversation history across turns. A long debugging session on a complex codebase can consume 100,000+ tokens per turn by turn 10. At $3/million input tokens on Sonnet 4.6, that's $0.30 per turn — add output tokens and a 20-turn session easily runs $8–15.
Extended thinking. Claude Code enables extended thinking by default on hard problems. Thinking tokens are billed as output tokens at $15/million on Sonnet 4.6. A single complex planning task can generate tens of thousands of thinking tokens.
Agent loops. When Claude Code runs in agentic mode — executing commands, reading files, iterating on failures — costs compound quickly. One secondary report puts a $0.50 fix at $30 after 47 agent iterations.
Model selection. Opus 4.6 costs 67% more than Sonnet 4.6 on input and 67% more on output. If developers are defaulting to Opus for tasks that Sonnet handles fine, you're paying a significant premium for no additional outcome.
Where it shows up on your project costs: Complex features, legacy migrations, anything requiring deep architectural reasoning. These are often the highest-cost work in a sprint — and frequently the fixed-price work where you have the least flexibility to recover the cost.
Where Cursor Costs More
Cursor is the volume tool. Developers use it constantly — autocomplete, quick questions, inline edits. The cost profile is different:
High-frequency small requests. Each fast request is cheap individually. Five hundred fast requests per month sounds like a lot until a developer is actively using Cursor agent mode, where a single feature might consume 50–100 requests.
Agent mode overages. Cursor agent mode chains multiple requests together — reading files, making edits, running commands. This burns through the monthly credit pool significantly faster than chat or autocomplete.
Subscription stacking. Cursor Pro at $20/seat looks cheap next to Claude Code. But Cursor is a second subscription on top of Claude Code — and developers use both. Across a team of eight, that's $160/month that rarely gets attributed to any client project.
Where it shows up on your project costs: Distributed across every developer, every day. Lower per-session cost than Claude Code but higher frequency. Often the "background noise" in your AI bill that nobody questions until you add it up.
The Per-Project Visibility Problem
Neither Anthropic nor Cursor gives you per-project cost data. They bill by workspace and by seat. The cost of a specific client project is invisible to both billing systems.
This creates a specific problem for agencies: you have two AI tool bills and no way to connect either one to the project that drove it.
The approaches teams currently use:
Manual time tracking. Developers note which project they were on when they used AI tools. Incomplete, inconsistent, and doesn't capture the granularity needed for billing.
Estimate by developer-hours. Allocate AI costs proportionally to developer hours per project. Simple but wrong — AI usage is not proportional to hours. Complex projects drive disproportionate AI usage.
Ignore it. By far the most common approach. Accept the total bill and absorb it across all projects.
None of these produce data you can attach to an invoice.
How Attribution Actually Works
The right approach is automatic attribution at the session level — capturing which developer used which tool, on which project, during which session, without requiring any manual input from the developer.
The attribution signal is git context:
- Git remote URL identifies the project and client. Every repository maps to a client engagement.
- Git config identity (user.email) identifies the developer.
- Git branch provides feature-level context.
Claude Code writes session data to local JSONL files. Cursor stores session data in a local SQLite database (state.vscdb). Both are readable without intercepting API calls.
A lightweight collection agent on each developer's machine reads this data, attaches git identity and project context, and ships it to a central dashboard — producing per-client, per-developer cost breakdowns across both tools from a single install.
This is exactly what TokenWatch does. One npx @tokenwatch/cli init per repo. After that, every Claude Code and Cursor session is attributed automatically — no developer workflow changes, no manual tagging, no spreadsheets.
What the Combined Report Looks Like
With attribution in place, the question "which costs more per project, Cursor or Claude Code?" becomes answerable — and the answer varies by project type.
For a greenfield application with a junior-heavy team: Cursor costs often dominate. High frequency of autocomplete and chat requests, lower Claude Code agentic usage.
For a legacy migration with senior developers: Claude Code costs dominate. Deep reasoning sessions, complex multi-file refactors, long agentic chains.
For a typical mixed project: Claude Code drives the spikes (individual sessions with high cost), Cursor drives the baseline (consistent daily usage across the team).
Knowing this per-project breakdown has two direct uses: accurate future proposals, and defensible client conversations about AI cost recovery.
The Question Worth Asking Now
Your team used both tools last month. Combined, they probably cost $800–2,000.
How much of that was on fixed-price client work? How much of that is recoverable?
If you can't answer those questions, you're subsidizing your clients' AI usage out of your own margin. The data to answer them exists — in local files on your developers' machines. It just hasn't been collected, attributed, and surfaced yet.
That's the gap worth closing.