Both companies publish a price list. Only one of them publishes what the price buys.
That is the single most useful thing to know before you choose between Claude Code and Cursor, and it is the thing almost every comparison skips. Cursor’s documentation states, in dollars, how much model usage each paid tier includes. Anthropic states a multiplier — 5x this, 20x that — on a base quantity it has never disclosed. Neither approach is dishonest. But they make the two products very hard to compare, and they mean the honest answer to “which is cheaper” depends on which number you are allowed to see.
Every figure below is quoted from an official Anthropic or Cursor page, checked on 3 August 2026. Where a vendor publishes nothing, this page says Not published and names the pages we checked, rather than filling the gap with an estimate. The full source list is at the bottom.
The short answer
Claude Code is a terminal agent that draws on a Claude subscription or on API billing. Cursor is an editor with a built-in agent that draws on a Cursor subscription. At the $20 tier they cost the same. Above that tier they diverge sharply, and not in the direction the sticker prices suggest.
Cursor Ultra costs $200 a month and includes, per Cursor’s own documentation, $400 of API agent usage. That is the only place in either product’s public documentation where a subscription’s included model spend is stated as a dollar figure larger than the subscription price. If your work is heavy enough to consume it, that is real leverage and it is worth knowing about.
Claude’s plans give you no comparable number to check. What Anthropic publishes instead is something Cursor does not publish at all: aggregate spend data from real deployments. Across enterprise rollouts, Claude Code averages “around $13 per developer per active day and $150-250 per developer per month, with costs remaining below $30 per active day for 90% of users.” That is an observed distribution, not an entitlement, but it tells you what the tool actually costs people, which the entitlement never does.
Every published price, side by side
These are list prices as shown on claude.com/pricing and cursor.com/pricing on 3 August 2026. Cursor’s per-seat prices are per user per month. Anthropic shows both an annual and a monthly rate for several plans; both are listed.
| Tier | Cursor | Claude |
|---|---|---|
| Free | Hobby — $0 | Free — $0 |
| Entry paid | Pro — $20/mo | Pro — $17/mo annual, $20/mo monthly |
| Mid | Pro+ — $60/mo | Max — from $100/mo |
| Top individual | Ultra — $200/mo | Max, 20x option — price shown at checkout |
| Team, standard | Teams Standard — $40/user/mo | Team standard seat — $20/seat/mo annual, $25 monthly |
| Team, premium | Teams Premium — $120/user/mo | Team premium seat — $100/seat/mo annual, $125 monthly |
| Enterprise | Custom, contact sales | $20/seat annual, usage billed at API rates |
One line in that table deserves a flag. Anthropic’s pricing page says Max starts “from $100/month” and lets you “Choose 5x or 20x more usage than Pro per 5-hour session.” It does not print a separate price for the 20x option on the page itself. We are not going to guess at it. If you need that number before committing, it appears during checkout.
What $20 actually buys on each side
Here is where the two companies genuinely differ, and it is a difference of philosophy rather than generosity.
Cursor: dollar-denominated pools
Cursor’s usage documentation states that “Each Cursor plan includes two monthly usage pools” — a Cursor Models pool covering Cursor Grok 4.5 and Composer 2.5, and an Other Models pool for third-party models “charged at model provider prices.” The included amounts:
| Cursor plan | Included, per Cursor docs | Ratio to plan price |
|---|---|---|
| Pro — $20/mo | $20 of API agent usage, plus first-party pool | 1.0x |
| Pro Plus — $60/mo | $70 of API agent usage, plus first-party pool | 1.17x |
| Ultra — $200/mo | $400 of API agent usage, plus first-party pool | 2.0x |
| Teams Standard — $40/user/mo | Not published on the pages we checked | — |
| Teams Premium — $120/user/mo | Not published on the pages we checked | — |
Read the third column before you read anything else on this page. On Pro you are paying roughly cost price for third-party model access and buying the editor. On Ultra you are getting model access at roughly half the rate you would pay an API provider directly. That is a genuine subsidy at the top tier, and it is the strongest single argument for Cursor in this entire comparison — not the editor, not the tab completion, the arithmetic.
There is one wrinkle worth noting because it is the sort of thing that looks like an error and is probably not one. Cursor’s pricing page describes Pro+ as “3x Pro limits on Agent,” while the usage docs put the included API agent pool at $70 against Pro’s $20 — 3.5x. For Ultra the two line up exactly: the pricing page says “20x Pro limits on Agent” and $400 against $20 is precisely 20x. The most likely explanation is that the pricing-page multiplier and the documented dollar pool are measuring adjacent but not identical things, since each plan carries two separate pools. Treat the dollar figures as the ones to plan around, because they are the ones stated in dollars.
Anthropic: multipliers on an undisclosed base
Anthropic’s ladder is built entirely out of ratios. Pro gives “at least 5x more usage per 5-hour session than Free.” Max gives 5x or 20x more than Pro. A Team premium seat gives “5x more usage than standard seats.” Every rung is a multiple of the rung below, and the bottom rung — how much a Free session actually gets — is not published anywhere.
We covered this in depth in our piece on what Anthropic actually publishes about Claude Pro usage limits. The short version: there is no message count, no token quota, and no hour count for any consumer tier. The reason is defensible — usage is metered in tokens, and a token count varies wildly with conversation length, attachments, and model choice, so any published message count would be wrong for most people. But the consequence for anyone comparing products is real. You cannot compute Claude’s cost per unit of work from the price list, because the price list contains no units.
What Anthropic publishes instead: observed spend
Anthropic’s cost documentation for Claude Code fills the gap from the other direction. Rather than an entitlement, it publishes what deployments actually consume:
- $13 per developer per active day is the stated average across enterprise deployments.
- $150-250 per developer per month is the stated monthly range.
- Under $30 per active day for 90% of users — the shape of the distribution, not just its centre.
Those figures describe API-billed usage, not subscription usage, so they are not an apples-to-apples answer to “what will my $20 get me.” But they are the most useful number in either vendor’s documentation for a team trying to budget, because they are the only figures anywhere in this comparison derived from what people actually spent rather than what they were promised.
Set them against Cursor’s Ultra pool and a rough shape emerges. If your developers are near the median at roughly $13 per active day, twenty active days is around $260 of model consumption a month. Cursor Ultra’s $400 pool covers that with room to spare at a $200 sticker. Claude Max at $100 might also cover it, or might not — there is no published number to check it against, which is precisely the problem. This arithmetic is a sanity check, not a prediction: the $13 figure is Anthropic’s own average for Claude Code specifically, and your own consumption depends on model choice, codebase size, and habits far more than on which vendor you picked.
The team sizing table nobody quotes
If you are provisioning Claude Code through the API for a team, Anthropic publishes explicit per-user rate-limit recommendations that scale down as headcount grows, on the reasoning that fewer people use the tool concurrently in larger organisations:
| Team size | TPM per user | RPM per user |
|---|---|---|
| 1-5 users | 200k-300k | 5-7 |
| 5-20 users | 100k-150k | 2.5-3.5 |
| 20-50 users | 50k-75k | 1.25-1.75 |
| 50-100 users | 25k-35k | 0.62-0.87 |
| 100-500 users | 15k-20k | 0.37-0.47 |
| 500+ users | 10k-15k | 0.25-0.35 |
Cursor publishes no equivalent sizing guidance on the pages we checked. For a platform team writing a capacity request, this table is the difference between a number you can defend and a number you made up.
What happens when you run out
The two products fail in structurally different ways, and this matters more day to day than the price difference does.
| Behaviour | Cursor | Claude |
|---|---|---|
| Reset cadence | Monthly, with your billing cycle | Rolling 5-hour window plus a weekly window |
| Weekly reset timing | Not applicable | Fixed day assigned to your account |
| Rollover | “Unused usage does not roll over” | Not published |
| At the wall | Editor notification; enable on-demand usage or upgrade | Message stating when the window resets; usage credits if enabled |
| Overage pricing | “Pay for additional requests at the same API rates” | Usage credits billed at API rates |
| Size of the allowance | Published in dollars for Pro, Pro+, Ultra | Not published for any tier |
The practical shape of this: Cursor’s failure mode is a monthly cliff you can see coming on the Spending tab, and paying through it is a decision you make once. Claude’s failure mode is an intermittent wall that can arrive on a Tuesday afternoon and clear five hours later, sitting underneath a weekly ceiling that resets on a day you did not choose. Neither is worse in the abstract. But if your work is bursty — a big refactor on Monday, nothing until Thursday — the five-hour window is the constraint that will bite you, and if your work is steady, the monthly pool is the one that will.
Two Claude-specific mechanics are easy to miss and expensive to learn by accident. First, the prompt cache lifetime is “an hour on a subscription and drops to five minutes once you’re drawing on usage credits,” and it is five minutes by default on an API key or cloud provider. Coming back to a long session after lunch reprocesses your whole context. Second, agent teams “use approximately 7x more tokens than standard sessions when teammates run in plan mode,” because each teammate carries its own context window. If you turn that feature on and your usage triples overnight, that is why.
The part that is not about money
Price comparisons quietly assume the two things are substitutes. They are not quite.
Claude Code is a terminal agent. It lives where your shell lives, which means it composes with everything a shell composes with — scripts, CI, hooks, remote boxes, tmux. It has no opinion about your editor. If you use Vim, or JetBrains, or you are working over SSH on a machine with no GUI, that is not a compromise, it is the design.
Cursor is an editor. The agent is one part of a product that also includes tab completion, inline edits, and a codebase index, and those parts are tuned together. If you spend your day in an editor and want the agent to be a first-class part of that surface rather than a second window, Cursor’s integration is the reason to pay for it. Cursor also bundles things Claude Code does not ship as part of the subscription — agentic code review through Bugbot, cloud agents, a team marketplace for internal rules and plugins.
There is a real overlap: you can run Claude Code inside Cursor’s terminal, on a Claude subscription, and pay both. Plenty of people do. That is not indecision, it is buying the editor from one vendor and the agent from another.
If you want the same analysis run against the other obvious rival, we did it for Claude Code versus Codex, and the wider field is covered in twelve Claude Code alternatives with the break-even math.
How to choose, concretely
Four rules that follow from the numbers above rather than from taste.
If you are spending over roughly $200 a month on model usage and you work in an editor, Cursor Ultra is the tier where the arithmetic is clearly in your favour: $400 of included API-priced usage for a $200 subscription is a subsidy no other plan on this page matches.
If you work in the terminal, over SSH, or in CI, Cursor’s leverage is irrelevant because you will not be using the editor you are paying for. Claude Code on a Pro or Max plan is the shape that fits.
If you are provisioning for a team and need a defensible budget, Anthropic’s published spend distribution and TPM sizing table give you numbers to put in a capacity request. Cursor gives you an entitlement per seat and no observed-cost data. Which you prefer depends on whether your finance team wants a ceiling or a forecast.
If you are at $20 either way and just want to start, the price is identical and the decision is entirely about whether you want an agent in your terminal or an agent in your editor. Do not let a pricing page make that decision for you.
What we could not verify
In the interest of not padding the table with plausible-looking numbers, here is what is genuinely missing from the public record as of 3 August 2026:
- Anthropic’s numeric session, weekly, and Opus limits for any consumer tier. Not published. Only multipliers.
- The list price of the Max 20x option. The pricing page states “from $100/month” and does not break out the 20x rate.
- Cursor’s included usage for Teams Standard and Teams Premium in dollars. The usage-limits page lists Pro, Pro Plus and Ultra only.
- Cursor’s rollover, rate-limit, and per-user sizing guidance for teams. Not found on the pages we checked.
- Any vendor-published head-to-head benchmark. Neither company publishes one, and any that circulate are third-party.
Frequently asked
Is Cursor cheaper than Claude Code?
At the entry tier they are the same: $20 a month each, with Claude Pro dropping to $17 if you pay annually. Above that tier the comparison cannot be made from list prices alone, because Cursor publishes its included usage in dollars and Anthropic does not publish an included amount at all. On the one dimension that can be compared directly — how much API-priced model usage a subscription includes — Cursor Ultra at $200 for $400 of usage is the most favourable ratio either vendor publishes.
Can I use Claude Code inside Cursor?
Yes. Claude Code is a terminal application and Cursor has a terminal. You would be paying two subscriptions, which is a reasonable thing to do if you want Cursor’s editor features and Claude Code’s agent, and a waste if you only want one of them.
Does Cursor’s included usage roll over?
No. Cursor’s documentation states plainly that “Unused usage does not roll over,” and that usage resets monthly with your billing cycle. For teams, all members reset together on the team billing cycle.
What happens when I hit the limit on each?
On Cursor you get a notification in the editor and can either enable on-demand usage, which bills additional requests at the same API rates, or upgrade the plan. On Claude you get a message telling you when the window resets, and if usage credits are enabled on your account you can continue past the allowance at API rates.
Which is better for a team of ten?
Neither answer follows from price alone at that size, but the available evidence differs in kind. Anthropic publishes a per-user TPM recommendation for a 5-20 person team (100k-150k TPM, 2.5-3.5 RPM) and an observed spend range of $150-250 per developer per month. Cursor publishes a per-seat price of $40 for Teams Standard and $120 for Teams Premium, with the included usage for those seats not stated in dollars on the pages we checked. If your procurement process needs numbers on paper, Anthropic currently gives you more of them.
Sources
Every figure on this page comes from one of the following official pages, all checked on 3 August 2026. Where a page is JavaScript-rendered and does not return content to a plain fetch, we read it in a browser.
| Source | What it establishes |
|---|---|
| cursor.com/pricing | Hobby, Pro $20, Pro+ $60, Ultra $200, Teams Standard $40, Teams Premium $120, Enterprise custom; the 3x / 20x / 5x agent multipliers |
| cursor.com — Usage and limits | Two monthly pools; $20 / $70 / $400 included API agent usage; monthly reset; no rollover; on-demand billing at API rates; Max Mode exclusion |
| claude.com/pricing | Free $0; Pro $17 annual / $20 monthly; Max from $100; Team seats $20 and $100 annual; Enterprise $20/seat; the 5x and 20x usage language |
| code.claude.com — Manage costs effectively | $13 per developer per active day; $150-250 per developer per month; under $30 for 90% of users; TPM/RPM sizing table; 7x agent-team multiplier; prompt cache lifetime |
If any of these figures changes, the page is wrong until we update it. Prices on both sides have moved more than once this year; check the vendor page before you commit a budget to it.
Read next
- Claude Code vs GitHub Copilot: credits, limits and real cost
- Is Claude Code free? The short answer and the real cost