Cursor Pricing 2026: What Changed and What It Really Costs

Look up "Cursor pricing" today and you'll still find threads arguing about a change that landed in June 2025. That's unusual. Pricing pages rarely keep people talking a year later. But Cursor didn't just raise a number — it swapped the whole billing model, did it abruptly, and a lot of paying users felt the floor move. The plan table tells you the sticker price. The credit system tells you what you'll actually be charged. Those are two different stories, and the second one is where the bill gets written.

Current Cursor Pricing (June 2026)

Cursor runs six tiers, from a free Hobby plan to a $200/month Ultra plan, plus team and enterprise options. Annual billing knocks roughly 20% off the monthly rate. The prices below were verified against cursor.com/pricing in June 2026 — confirm there before you commit, because Cursor has shown it will restructure mid-year.

Plan	Monthly	Annual (~20% off)	What you get
Hobby	Free	Free	~2,000 completions + limited agent requests, no card; 7-day Pro trial
Pro	$20/mo	~$16/mo	$20 monthly credit pool; unlimited Auto mode + Tab
Pro+	$60/mo	~$48/mo	Everything in Pro, ~3× premium-model usage
Ultra	$200/mo	—	Everything in Pro, ~20× premium-model usage + priority access
Business (Teams)	$40/user/mo	~$32/user/mo	Standard seat; admin, SSO, analytics. Premium seats ~$120/user
Enterprise	Custom	Custom	Pooled usage, access controls, audit logs, support

A separate Bugbot add-on handles AI code review on usage-based billing. The Hobby plan is fine for kicking the tires, but the included allotment runs out fast in real work. Pro at $20 is where most solo developers land. The leap to Pro+ at $60 looks steep on paper — whether it's worth it comes down to the credit math, which is the part the table can't show you.

What Changed in June 2025 — and Why the Backlash Sticks

Before June 2025, a Cursor Pro subscription gave you a fixed monthly allotment of "fast requests." You could count them. You knew where the ceiling was. Then Cursor replaced that with usage-based credit billing tied to the actual API cost of the model you run. Heavier models, longer contexts, and MAX mode all burn more of your included amount. Same $20, but the ceiling now floats depending on what you ask for.

The rollout went badly, and Cursor has said so itself. The change shipped quickly and was poorly communicated; the word "unlimited," by Cursor's own admission, was used in ways that turned out to be conditional; and some users hit overage charges they didn't see coming. On July 4, 2025, Cursor posted a public apology, acknowledged the confusion, and offered refunds for surprise charges incurred roughly between June 16 and July 4, 2025. A month later, in August 2025, Teams pricing moved onto the same variable, API-based billing.

Here's the part worth being precise about: the company's apology, the refund window, and the billing change are documented facts. The feelings about it are community sentiment, and they're still loud. On Reddit and Cursor's own forums, some longtime users describe the credit prompts and upgrade nudges in harsh terms — one recurring characterization is that the experience started to feel like "nagware." That's their framing, not ours. We're reporting that the sentiment exists and runs deep enough to still surface in search a year later; we're not endorsing it as a verdict on the product. Cursor remains a capable editor with a large, active user base. What lingers is a trust gap about billing predictability, and that gap is exactly why "cursor pricing" is still a hot query.

The Credit System in Plain English

Forget requests for a second and think in dollars, because that's how Cursor now thinks. Your monthly fee includes a credit pool measured in money — at Pro, that's a $20 pool. Different actions draw it down at different rates, and a couple of things don't draw it down at all. Once you understand which is which, the whole structure stops being mysterious.

• Auto mode is unlimited and free of the pool. When you let Cursor choose the model, it routes to a cost-efficient one and that usage is included — it does not subtract from your credits. For most everyday work, this is the lane you live in.
• Tab completions are effectively unlimited. The inline autocomplete that fires as you type is cheap and not the thing that drains your balance.
• Manually selecting a frontier model draws credits. The moment you reach for Claude Opus, Claude Sonnet, or Gemini by hand, you're spending the pool at that model's API rate. Bigger model, longer context, MAX mode — faster burn.
• When the pool runs dry, you keep going at cost. On-demand usage past the included amount bills at API rates with no markup, charged in arrears. Nothing stops mid-task; the meter just moves to your card.

That last point is the whole reason team bills can swing. Two developers on identical $20 Pro plans can post very different monthly totals — one stays in Auto mode and never touches the pool, the other hand-picks Opus for every refactor and rolls into overage by the third week. The plan tier sets the included credit; your model habits set the actual cost. An organization full of frontier-model power users will see a different bill than the seat count implies, which is precisely the unpredictability the June 2025 change introduced.

None of this makes Auto mode a trap, either. For code completion, inline edits, and short chat exchanges, Auto mode handles the work well and the credit system barely registers. The friction shows up for the specific group that bought Pro because they wanted reliable, direct control over which frontier model runs on hard multi-file work. For them, "$20/month" is technically true but practically incomplete.

How to Keep the Bill Predictable

If you want the flat-fee experience the plan implies, the levers are straightforward and they all come down to controlling when you spend the pool.

• Default to Auto mode for routine work. Boilerplate, small edits, quick questions — let Cursor route it. You stay off the meter.
• Reserve frontier models for the hardest problems. Save manual Opus or Sonnet selection for the gnarly refactor or the bug that Auto keeps fumbling, not for everything.
• Watch the usage dashboard your first month. Before you upgrade from Pro to Pro+ on a hunch, spend thirty days reading your own burn rate. The dashboard shows where the credits actually go, and the answer is often "fewer places than you feared."
• Set spend expectations for teams up front. Because overage is billed in arrears at API rates, a team that leans on frontier models should treat the seat price as a floor, not the bill.

If Unpredictability Is the Problem

Some developers don't object to paying — they object to not knowing what they'll pay. If the variable credit burn is the actual sticking point for you, two directions are worth a look.

The cleaner escape hatch is a model-agnostic, bring-your-own-key tool, where the editor is free or open-source and you pay only your own provider's API costs with no platform pool in the middle. OpenCode is the clearest example: it's MIT-licensed and open-source, runs against 75+ providers (Claude, GPT, Gemini, DeepSeek, or local models), and bills you nothing beyond what your chosen provider charges. The trade-off is real — it's terminal-first, you manage your own keys, and it's not a beginner's tool — but the cost model is transparent in a way a credit pool isn't. For a broader survey of where it fits against the rest of the field, see our roundup of the best AI coding agents in 2026.

The lower-effort alternative is a competing editor with a simpler usage model. Windsurf Pro runs roughly $15/month (verify at windsurf.com/pricing) and uses a flow-credit system that many developers describe as easier to predict than Cursor's. It's not a drop-in replacement — Cursor's Composer, which coordinates edits across many files from a single prompt, is still often rated the stronger implementation in community comparisons — but if your workflow doesn't depend on that, the gap may not matter.

Tool	Cost model	What you pay	Best for
Cursor	Flat fee + credit pool	$20+/mo, overage at API rate in arrears	Composer-heavy work, Auto-mode defaults
Windsurf	Flat fee + flow credits	$15/mo, simpler structure	Cost-conscious devs who want predictability
OpenCode	Open-source + BYOK	$0 tool; pay only provider API	Power users who want full cost transparency

Who Should Pay for What

Auto-mode developers: Pro at $20/month (~$16 annual) is defensible. You'll rarely touch the credit pool, the editing experience is well-documented, and the billing stays close to flat.

Manual frontier-model users: Pro+ at $60/month is the honest number to budget. Running $20 Pro and hitting the ceiling mid-month is a documented pattern for this group — don't plan $20 and expect $60 worth of manual Opus use.

Cost-conscious developers: If predictability outranks Composer, evaluate Windsurf at $15, or go fully transparent with an open-source BYOK setup like OpenCode and pay only your provider's rate.

Teams: The $40/user Business plan adds admin controls, SSO, and usage analytics — and that last one matters most here, because variable per-seat overage is exactly what you'll want visibility into. Premium seats run about $120/user; price the plan as a floor and watch the dashboard before assuming the seat count is the bill.