Cursor Pricing in 2026: Every Plan, and Why Bills Surprise People

Cursor pricing in 2026: every plan explained

Cursor's current pricing page and models-and-pricing docs list four individual tiers plus Teams and Enterprise:

Annual billing takes roughly 20% off every paid plan. There's also a lower-priced Start plan at ₹649/month, but it's restricted to developers billed in India and covers only Cursor's own first-party models, not third-party ones like Claude or GPT.

Why the credit pool trips people up

The number that actually matters isn't the plan price, it's what that price buys once you leave Auto mode. Every paid plan includes a dollar-denominated credit pool equal to its monthly cost: $20 on Pro, $60 on Pro+, $200 on Ultra. Auto mode, where Cursor picks the model for you, doesn't touch that pool at all and runs unlimited on every paid plan.

The pool only drains when you manually select a specific frontier model, Claude Opus, GPT-5, Gemini, and it drains at that model's underlying API rate, not a flat per-request fee. A simple syntax fix costs a fraction of a cent. An agent run that touches a large codebase and picks an expensive model can burn through several dollars of pool in one session. Superblocks' breakdown of Cursor's pricing (July 2026) names the three things that drain credits fastest: manually picking premium models instead of Auto, enabling Max Mode, and working across large codebases that feed many files into every prompt.

That's a genuinely different mental model from a flat per-seat SaaS price, and it's the single biggest source of "why is my bill higher than I expected" complaints.

How Cursor's usage pools work in 2026

Cursor's docs now describe included usage as two separate pools rather than one number, and both reset with your billing cycle. This is a more granular framing than the single dollar-denominated pool the company described in 2025: the plan prices have not changed, but the docs now track first-party and third-party usage separately, and the difference between them is where the money goes. Cursor's models-and-pricing docs, checked September 18, 2026, split them like this:

• Cursor Models. Cursor's own first-party models: Grok 4.6, Grok 4.5, and Composer 2.5. This pool carries significantly more included usage.
• Other Models. Third-party models from OpenAI, Anthropic, Google and others, charged at that model's API rate. Pro, Pro Plus and Ultra all include this pool. The India-only Start plan does not.

Which pool a request lands in decides most of your bill, because the published per-million-token rates differ by more than an order of magnitude. From that same docs page:

Here is what that spread means in practice. Take one agent run that reads 200,000 tokens of context and writes 20,000 tokens back, and price it three ways at those published rates. On Composer 2.5 it costs about $0.15. On Claude Sonnet 5, about $0.60. On Claude Fable 5.1, about $3.00. Same task, same editor, roughly a 20x spread, decided by a dropdown. Those are my numbers, not Cursor's: the arithmetic is simply the published rate times the token count I assumed, and your real runs will use different token counts. The point is the ratio, and the ratio is why two developers on identical $20 plans can have completely different months.

Two details from the docs rarely make it into comparison posts. Teams that opt in to regional data residency pay a 10% uplift on model pricing for eligible models. And on Teams and Enterprise plans, every third-party request also carries the Cursor Token Rate of $0.25 per million tokens, charged on input, output and cached tokens, including when Auto routes to a third-party model, and including bring-your-own-key usage. Cursor's own first-party models are exempt from it.

The June 2025 pricing change, and why people were angry about it

Before June 16, 2025, Cursor Pro's $20 gave you 500 fast requests a month with unlimited slow requests after that. It was a hard, predictable limit. On June 16, Cursor replaced it with the credit-pool system described above, and initially described the change in terms that made "unlimited usage" sound broader than it actually was, unlimited applied to Auto only, not to manually-selected models.

The result was a wave of surprise bills. Developers who kept selecting premium models by habit, the way the old plan encouraged since requests were flat-rate, burned through their $20 pool in days and then got billed at API rates for the overage. Complaints piled up fast: threads like r/programming's "Cursor: pay more, get less, and don't ask how it works" and r/ChatGPTCoding's "Used to Love Cursor. Now It's Pay More, Get Less" described the change as a silent nerf with no clear documentation of what had shifted.

Cursor responded in a July 4, 2025 blog post titled "Clarifying our pricing", where CEO Michael Truell wrote plainly: "Our recent pricing changes for individual plans were not communicated clearly, and we take full responsibility." The company committed to refunding unexpected charges incurred between June 16 and July 4, and clarified that median Pro usage at the time covered roughly 225 Claude Sonnet requests, 550 Gemini requests, or 650 GPT-4.1 requests before the pool ran out.

The complaints didn't fully disappear once the pool model settled in. A March 2026 thread on r/cursor raised a related concern: that agent workflows can generate large amounts of intermediate planning and context-caching tokens that count against the pool without being obvious to the person typing the prompt, making costs harder to predict even for users who understand the model in theory.

Every pricing change since 2024, and why the history matters to a buyer

A tool's pricing history tells you how often your budget line is likely to move. Cursor's has moved four times in two years:

The first row deserves a confidence label rather than a citation: it comes from a developer's compiled timeline of Cursor's pricing changes quoting old forum posts, and those old pages are not on Cursor's live site to check against. Treat it as context for how the model used to work, not as a number to plan against.

The last row is verifiable in full. Cursor's changelog entry for Start puts the launch at July 28, 2026: ₹649 per month, tax inclusive, billed in INR via UPI or card, monthly billing only, available to developers in India. Start covers the Cursor Models pool and cloud agents, and excludes the Other Models pool, on-demand usage, Bugbot, Auto, Automations and the Cursor SDK. Cursor's India pricing page lists Pro locally at ₹1,800/month on annual billing, or ₹2,273 billed monthly, so Start sits at roughly a third of local Pro.

What a buyer should take from the pattern: the plan names have been stable, and the metering under them has not. Budget with a review date rather than a fixed annual number, and check the pricing page again before any renewal.

What Teams and Enterprise actually cost

Teams pricing changed again in June 2026. Cursor's own post on the update explains the reasoning: a small number of power users on any team drive most of the spend and most of the unpredictable overage, so a single seat type was actually pricing everyone for the heaviest user's habits.

The fix was splitting Teams into two seat types, confirmed on Cursor's team pricing docs:

• Standard seat: $40/user/month billed monthly, or $32/user/month billed annually. Same usage tier as before, now with more included usage in the first-party models pool.
• Premium seat: $120/user/month billed monthly, or $96/user/month billed annually. Five times the usage allowance of Standard, at three times the price, aimed at covering a full month of heavy agent usage for nearly all users who need it.
• Free admin-only seat: $0/month for admins who manage the team without using Cursor themselves.

Teams can mix seat types freely across the org, and billing is per active paid seat rather than a fixed headcount, so removing or downgrading a user adjusts the bill immediately. Enterprise sits above Teams for organizations that need pooled usage shared across the whole team rather than per-seat allowances, plus invoicing and a dedicated account manager, priced only through a sales conversation.

Billing surprises, and how to avoid each one

Most of the "why did this cost more" stories come from a handful of mechanics that are documented but easy to miss. All of these are from Cursor's billing help page and its Teams pricing docs, read September 18, 2026.

On-demand usage is on by default for Teams. Once a seat's included usage is consumed, Cursor keeps working and bills the overage in arrears rather than stopping. That is the right default for not blocking engineers mid-sprint, and it is also why the first month's invoice is the one to read line by line. Turn on a team-wide spending limit before the first full cycle, not after it.

Per-member spend limits are an Enterprise feature. Teams plans can set a monthly team-wide limit through the dashboard. If you need a cap per developer, that lives on Enterprise. A team that specifically wants to stop one heavy user from consuming the shared budget cannot do that on the self-serve tier.

Removing someone mid-cycle does not always stop the charge. Cursor bills per active paid seat, so adding a member mid-cycle creates a pro-rated charge, but removing a member who has already used credits keeps that seat occupied until the cycle ends. Adjustments show up as account credit on a later invoice rather than as an immediate refund. Plan offboarding around the renewal date if seat count is tight.

Prices exclude tax. Every individual plan except the India-only Start plan displays its price before tax, so the number on the pricing page is not the number on the card.

Cursor sells direct only. Cursor states plainly on its pricing page that it does not authorize resellers or third-party sellers, and that subscriptions bought elsewhere may be suspended. If your procurement process routes software through a reseller, that is a conversation to have with Cursor sales before you plan a rollout, not after.

Renewal dates do not move. Adding or removing members leaves the team's renewal date where it was, which matters if you were expecting a seat change to reset the cycle.

What vantage.sh and superblocks.com say about it

Two independent breakdowns are worth reading if you want a second opinion beyond Cursor's own pages. Vantage's Cursor pricing explainer (March 2026) frames the whole 2025 shift as economically rational but poorly executed: moving from flat "fast request" allotments to real token-based billing made sense as frontier models got more expensive to run per task, but the rollout itself was rocky and under-communicated.

Superblocks' breakdown (July 2026) is more bottom-line focused: it argues Cursor is worth the cost for full-time developers specifically because Pro's $20 pays for itself if it saves even an hour of billable time a month, provided you default to Auto mode and reserve manual model selection for genuinely hard problems. Both sources agree on the same underlying point, worth noting since neither has a reason to be generous to the other's framing: the sticker price on Cursor's plans is not the number that determines your actual bill. Usage pattern is.

Cursor vs Windsurf, GitHub Copilot, and Claude Code

Every one of these tools meters something different, so the sticker prices are not directly comparable. The table below is what each vendor published on September 18, 2026. Where a vendor's own page and a third-party roundup disagreed, I used the vendor page.

Three things in that table are worth more than the numbers.

Copilot is the cheapest predictable option, and it is predictable on purpose. GitHub's plan documentation sets Pro at $10/month with 1,000 base plus 500 flex credits, Pro+ at $39 with 7,000, Max at $100 with 20,000, Business at $19 per granted seat with 1,900 credits per user, and Enterprise at $39 per seat with 3,900. Overage is a flat $0.01 per AI credit, credits pool across an enterprise, and completions are excluded from metering entirely. If your finance team wants a number it can multiply by headcount, that is the model that gives them one.

Anthropic publishes a real per-developer cost for agentic coding, and it is not small. Claude Code's cost documentation states that across enterprise deployments the average is around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users staying below $30 per active day. That is the most honest public benchmark I have found for what heavy agent usage actually costs when it is billed at API rates rather than hidden inside a subscription, and it lines up closely with Cursor's own guidance discussed below. Subscription pricing for Claude itself runs Pro at $17/month on annual billing or $20 monthly, Max from $100/month, and Team seats at $20 or $100 per seat on annual billing, per Claude's pricing page. Our fuller breakdown is in Claude Code pricing.

Windsurf's pricing page no longer exists as its own page. As of September 18, 2026, windsurf.com/pricing returns a 308 redirect to devin.ai/pricing, and the plans shown there are Devin's: Free, Pro at $20/month, Max at $200/month, Teams at $80/month for the team plan plus $40/month per full dev seat, and Enterprise on request. If you are comparing Cursor against Windsurf on the strength of a quote from six months ago, re-check it. Our earlier breakdown is at Windsurf pricing, and a wider field comparison is in the best AI for coding.

Worked cost scenarios, with the assumptions stated

These are arithmetic, not survey data. Every assumption is stated so you can swap in your own and rerun it. The per-seat prices come from Cursor's pricing page and Teams pricing docs; the usage bands come from Cursor's own "how much usage do I need" guidance in its models-and-pricing docs, which puts daily Tab users and limited agent users inside included usage, daily agent users at $60 to $100 per month of total usage, and power users running multiple agents at $200 or more.

Scenario one: one developer, mostly Tab and occasional agent work. Assumption: stays in Auto and first-party models, runs agents a few times a week. Cursor's own guidance puts this inside Pro's included usage. Cost: $20/month, or $16/month equivalent on annual billing at the advertised 20% discount. Nothing else to model.

Scenario two: one developer running agents all day. Assumption: Cursor's $60 to $100 band is correct for this person. Pro at $20 plus $40 to $80 of on-demand is the same money as Pro+ at $60, except Pro+ is a known number and on-demand is not. The decision rule is not "which is cheaper" but "which is easier to forecast", and at this usage level Pro+ wins on forecastability. Ultra at $200 only makes sense once a month of real data shows the $200 band, which is Cursor's power-user description, not a starting assumption.

Scenario three: a 10-person engineering team. Assumptions: seven developers use agents moderately, three run them constantly, and the team bills annually. Seven Standard seats at $32 plus three Premium seats at $96 is $224 plus $288, or $512/month, against $640/month at monthly rates. Now add the metering layer most comparisons skip: at the Cursor Token Rate of $0.25 per million tokens, 100 million tokens of third-party model traffic across the team in a month adds $25. That rate is not what makes bills jump. Model selection is. If those three heavy users default to a $10-in, $50-out model rather than a $0.50-in, $2.50-out one, the difference between those two habits is far larger than the entire token-rate line.

Scenario four, for the finance question underneath all of this: 40 developers. Assumption: 30 Standard and 10 Premium seats, annual billing. That is 30 times $32 plus 10 times $96, or $1,920/month, $23,040/year, before any on-demand usage. Cursor's docs note that volume discounts for larger teams are handled by sales rather than published, so treat that as a list-price ceiling rather than a quote. For a broader cross-vendor view, see enterprise AI pricing compared.

How to cut a Cursor bill without dropping the tool

Every lever here maps to something Cursor documents, so each one is checkable rather than folk wisdom.

Default to Auto and first-party models. The Cursor Models pool carries significantly more included usage than the third-party pool, and Grok and Composer are exempt from the Cursor Token Rate on Teams and Enterprise. This is the single largest lever and it costs nothing to pull. One caveat worth reading carefully in the docs: on Teams and Enterprise, Auto bills at the list price of whichever model it routes each request to, and third-party routes still incur the token rate, so Auto reduces cost by choosing well rather than by being exempt from billing.

Reserve premium models for the work that needs them. Given the roughly 20x spread between the cheapest and most expensive published rates, the habit of leaving an expensive model selected between hard problems is expensive in a way that is invisible while it is happening.

Turn on spending limits before the first full billing cycle. Team-wide limits are configurable on Teams. If you need per-developer caps, that requirement points at Enterprise and should be raised during the sales conversation rather than discovered later.

Watch the admin dashboard rather than the invoice. Cursor tracks included and on-demand usage per user and exposes a spending data API, so a team can see the shape of the month before the month is billed.

Mix seat types instead of upgrading everyone. Put the team on Standard, measure one cycle, and move only the confirmed heavy users to Premium. Cursor bills per active seat, so the adjustment applies immediately rather than at renewal.

Take the annual discount once usage is stable, not before. Yearly billing takes roughly 20% off, which is real money at 40 seats, but it is the wrong commitment to make in month one while you are still learning which seats are which.

Trim the context you send. Input tokens are billed at full rate while cache reads are billed at a fraction of it, for example $2 versus $0.20 per million on Claude Sonnet 5 at published rates. Large, unfocused prompts across big codebases are the usage pattern that Superblocks also flags as a top credit drain.

Developers billed in India should check Start. At ₹649 per month it covers the first-party model pool and cloud agents. If the third-party pool, Bugbot, Auto and on-demand are not part of the daily workflow, it is roughly a third of local Pro pricing.

Switching costs: what moves with you and what does not

Pricing decisions are cheap to reverse only if the work inside the tool is portable. For Cursor, a fair amount is.

What moves. Agent instructions are the portable part, and they are the part teams put the most work into: Cursor's rules documentation confirms support for `AGENTS.md` in the project root and, more recently, in subdirectories, which is a plain-markdown format that several other agentic coding tools also read. Teams that write their standing instructions as `AGENTS.md` rather than Cursor-specific rule files keep them portable at no cost. MCP server configuration is likewise just config, and is the layer most likely to survive a tool change, which is the argument in how to choose MCP servers for your team.

What does not move. Bugbot's review history, team usage analytics, the team marketplace of internal rules, skills and plugins, cloud agent and automation setups with shared team context, and any per-seat usage history you have built up for forecasting. None of that has an export path to a competitor. Cursor-specific rule files in `.cursor/rules` carry metadata that a plain markdown file does not.

The commercial switching cost. Annual billing is where the real lock-in sits, not the file formats. A team on monthly billing can leave at the next renewal date. A team that took the 20% annual discount across 40 seats has committed for the year, which is exactly why the discount is worth taking after a usage baseline exists rather than during evaluation.

Who Cursor is genuinely wrong for

Cursor is a strong product and the honest answer is still that several kinds of team should buy something else.

Shops standardized on JetBrains or Xcode. Cursor offers integrations for both, but the product is an editor, and most of what you pay for is the experience inside that editor. A team that will not leave IntelliJ or Xcode is paying for a workflow it will not use. Copilot, which lives inside the IDE you already have, fits that team better.

Teams that need hard per-developer spend caps on a self-serve plan. Per-member spend limits are Enterprise-only. If the reason you are buying is to prevent one person's usage from consuming a shared budget, and Enterprise is out of scope, the tool does not do the thing you need at the tier you are buying.

Organizations whose procurement requires invoicing, wire transfer or a reseller. Self-serve plans take cards only, invoicing is an Enterprise conversation, and Cursor does not authorize resellers at all.

Budget owners who need a number that does not move. Metered usage is the correct model for the underlying economics and a genuinely hard model to forecast in the first quarter. If a fixed per-seat line item matters more than getting the best model on the hardest problems, Copilot Business at $19 with a fixed credit allowance is the more honest fit.

Developers who mainly want autocomplete. If agent runs are occasional and Tab is the real value, Copilot Pro at $10/month covers unlimited completions for half of Cursor Pro's price.

Teams with a hard no-external-inference rule. Cursor's answer to data concerns is privacy mode, which its pricing page describes as a guarantee that code data is not used for training by Cursor or its model providers. That is a training guarantee, not an on-premise deployment. If your requirement is that code never leaves your network at all, privacy mode does not satisfy it and the conversation belongs with Cursor's enterprise team rather than on the self-serve plans.

Is Cursor worth it, and how to budget for it

For an individual developer coding daily, Pro at $20/month is the default starting point, and staying in Auto mode for routine work while reserving manual model picks for the hardest tasks is what keeps that $20 pool from running out mid-month. Pro+ and Ultra exist for people who've already confirmed, from actual usage, that they regularly exhaust Pro rather than as a starting insurance policy.

For a team, the newer split-seat Teams pricing is actually easier to budget than the old single-tier model: put most of the team on Standard, watch real usage for a billing cycle, and move only the confirmed heavy users to Premium rather than guessing upfront. Given how visibly the June 2025 change caught people off guard, any team evaluating Cursor now should also ask, explicitly, what happens on overage and whether a spend limit can be set per seat, rather than assuming the current pricing page is the final word on what a bill will look like three months in.

Where a tool like Coworker MCP fits alongside Cursor

Cursor is a coding assistant. It writes and edits code inside the editor, and its pricing model reflects exactly that: usage tied to how much AI-driven editing and agent work a developer actually runs. Coworker MCP solves a different, adjacent problem: giving that same AI tooling unified context across the rest of a company's systems, the Jira ticket describing the bug being fixed, the Slack thread where a customer reported it, the CRM record tied to the account affected, through one governed connection to 50+ apps rather than a pile of individually-installed servers.

The two aren't competing for the same budget line. A team can run Cursor for the actual coding and Coworker MCP for the context that coding work depends on, the same distinction covered in more detail in Windsurf's pricing breakdown, Cursor's closest direct competitor. If governance is part of what you're evaluating alongside cost, what enterprise MCP deployment actually requires and MCP security cover the parts of that evaluation that don't show up on either company's pricing page. For the basics of the protocol itself, see what MCP is.

Book a demo to see how Coworker MCP connects to the coding tools your team already runs.

A note on where this page fits in search

Cursor's own site is not easy to out-rank for "cursor pricing." At the time of writing, cursor.com holds the top organic result with six of its own sitelinks (pricing, models-and-pricing docs, help, team pricing, terms, and its own pricing-clarification post), and an AI Overview sits just below it citing a spread of sources, including vantage.sh and superblocks.com, without any single one dominating that citation cluster. The realistic goal for a page like this one isn't unseating Cursor's own pricing page on day one. It's being accurate and specific enough, with real sourced numbers rather than a rehash of the pricing page, to earn a place in that same citation cluster over time, the same honest bet we've made on our enterprise MCP coverage where an AI Overview owns a similar amount of the SERP.

Frequently asked questions

How much does Cursor cost per month?

Hobby is free. Pro is $20/month, Pro+ is $60/month, and Ultra is $200/month, each including a credit pool equal to its price for manually-selected models. Teams starts at $40/user/month for a Standard seat or $120/user/month for a Premium seat. Enterprise is priced on request.

Why did my Cursor bill jump after I'd been paying the same amount for months?

Most often it's because you started manually selecting a specific model, like Claude Opus or GPT-5, instead of leaving Auto mode on. Auto is unlimited on every paid plan; manual model selection draws from your monthly credit pool at that model's API rate, and expensive models or large codebases can drain that pool fast.

What actually changed in Cursor's June 2025 pricing update?

Cursor replaced its old 500-fast-requests-per-month limit with a dollar-denominated credit pool tied to real API costs. The rollout wasn't communicated clearly, users saw surprise charges, and Cursor issued a public apology and refunds for unexpected usage billed between June 16 and July 4, 2025.

What's the difference between Cursor Pro and Pro+?

Pro+ costs $60/month, three times Pro's $20, and includes roughly three times Pro's credit pool for manually-selected models. Both plans include unlimited Tab completions and unlimited Auto mode; the difference is entirely in how much manual premium-model usage the monthly pool covers.

How much does Cursor cost for a team of 10?

At the Standard seat rate of $40/user/month, a 10-person team runs $400/month before any Premium seats or overage. Mixing in Premium seats for the heaviest users at $120/user/month raises that proportionally, since Teams bills per active seat rather than a flat headcount fee.

Does Cursor charge for Tab autocomplete?

No. Tab completions are unlimited on every paid plan. The credit pool only applies to manually-selected premium models used through Agent or Chat, not to inline autocomplete.

Is Cursor cheaper than GitHub Copilot?

No, not on sticker price. Copilot Pro is $10/month against Cursor Pro's $20, and Copilot Business is $19 per seat against Cursor Teams Standard at $40. Copilot also excludes code completions from metering entirely and charges a flat $0.01 per AI credit on overage. Cursor costs more and gives you direct control over which frontier model runs each request, which is what heavy agent users are actually paying for.

What is the Cursor Token Rate?

It is a $0.25 per million token charge that applies on Teams and Enterprise plans to third-party model requests, on top of that model's API price. It covers input, output and cached tokens, applies when Auto routes to a third-party model, and applies to bring-your-own-key usage. Cursor's own models, Grok and Composer, are exempt.

Can I set a spending limit in Cursor?

Teams plans can set a monthly team-wide spending limit from the dashboard, and on-demand usage is enabled by default. Per-member spending limits are available only on Enterprise plans.

What happens if I remove someone from a Cursor team mid-month?

Cursor bills per active paid seat, but a member who has already used credits keeps the seat occupied until the billing cycle ends. Adding someone mid-cycle creates a pro-rated charge, and adjustments typically appear as account credit on a later invoice. The team's renewal date does not change either way.

How much does Cursor cost on annual billing?

Yearly billing takes roughly 20% off. On Teams that works out to $32/user/month for a Standard seat and $96/user/month for a Premium seat, per Cursor's Teams pricing docs. Prices for individual plans exclude tax.

What is Cursor Start, and can I use it outside India?

No. Start is a ₹649 per month plan, tax inclusive, available only to developers in India, billed monthly in INR via UPI or card. It launched July 28, 2026. It covers Cursor's first-party model pool and cloud agents, and excludes third-party models, on-demand usage, Bugbot, Auto, Automations and the Cursor SDK.

How does Cursor compare to Windsurf's pricing now?

Check before you quote it. As of September 18, 2026, windsurf.com/pricing redirects to devin.ai/pricing, where the published plans are Free, Pro at $20/month, Max at $200/month, Teams at $80/month plus $40 per full dev seat, and Enterprise on request.

Does Coworker MCP replace Cursor?

No. Cursor is a coding assistant that writes and edits code in the editor. Coworker MCP connects AI tools, including Cursor, to the rest of a company's systems (project trackers, chat, CRM, and more) through one governed connection. Teams typically run both rather than choosing between them.

Related reading

• Windsurf Pricing in 2026: Free, Pro, Teams, and Max
• Enterprise AI Pricing Compared
• How to Choose MCP Servers for Your Team