Cursor Pricing in 2026: What You Actually Pay

Cursor's price list right now, no folklore

Cursor's pricing gets rewritten by the community roughly every quarter, and half of what circulates on Reddit describes a plan structure that no longer exists. So here is exactly what cursor.com/pricing and the official pricing docs say today, pulled the same day this article was published.

Two structural things stand out before we get to any math. First, Cursor prices every paid tier as a subscription that bundles a dollar amount of model usage - not a request count, a dollar amount. Second, the multiplier is not flat: Pro includes usage worth exactly what you pay ($20 in, $20 included), Pro+ includes a bit more than you pay ($70 on a $60 plan), and Ultra doubles it ($400 on a $200 plan). Cursor is openly pricing for commitment: the more you prepay, the better your usage exchange rate.

One sourcing note so you can reconcile this against the page yourself: cursor.com/pricing's default view actually renders the annual-billing rate front and center - $16/month for the Individual plan group and $32/user/month for Teams as of 2026-07-11 - which is Cursor's roughly 20%-off annual pricing. The $20 and $40 figures in the table above are the monthly-billing rates (what you pay without the annual commitment), and the per-tier usage inclusions - the $70 on Pro+, $400 on Ultra, the 5x Agent ceiling on Teams Premium - come from the official pricing docs rather than the marketing page's default tab. If you commit annually your effective monthly rate drops accordingly, so confirm your exact number at checkout.

Included usage is the real price, not the seat price

This is the part most pricing posts skip, and it's the part that decides your actual bill.

Cursor's docs describe the mechanism directly: every plan includes a set dollar amount of model usage, and once you consume it, on-demand usage lets you keep working - billed in arrears at the same API rates. You don't stop when the included dollars run out; the meter just keeps running. The docs add one genuinely useful reassurance, and this one is a verbatim quote: "Requests are never downgraded in quality or speed." You don't get throttled into a worse model. You get billed.

How fast do you burn through it? Cursor's own docs give estimates that are more honest than most vendors manage:

• Daily Tab-completion users: "Always stay within $20"
• Daily Agent users: "Typically $60-$100/mo total usage"
• Power users: "Often $200+/mo total usage"

Read that middle line again, because it's the whole article in one sentence. If you use Cursor's agent every working day - the thing Cursor markets hardest and the reason most people pay for it - the vendor's own estimate says your usage lands at three to five times what the Pro plan includes. A Pro subscriber doing daily agent work should expect the $20 plan to become a $60-$100 monthly line item once on-demand billing tops it up. That's not a gotcha exactly, since the numbers are published. But it does mean the useful comparison was never "$20 vs $10 for Copilot." It's "$60-$100 of realistic monthly spend vs whatever your actual alternative costs."

Long-context and agentic workloads are exactly where the burn concentrates. Agent sessions chew through tokens on every planning step, file read, and retry - a single afternoon of letting an agent refactor across a large codebase consumes usage in a way that autocomplete never will. First-party models (Auto, Composer 2.5, Grok 4.5) get "generous included usage" and are the pressure valve; routing everything to frontier third-party models is how you hit the ceiling by the 15th of the month.

Pro vs Pro+ vs Ultra: pick by your agent habit, not your seniority

The three individual tiers are the same product with different usage tanks, so the decision reduces to one question: how many days per week do you hand work to the agent?

Occasional agent use, mostly Tab and chat - stay on Pro at $20/month ($240/year). Cursor's own guidance says Tab-heavy users stay inside the included $20, so on-demand charges should be rare. This is also the right tier while you're still deciding whether agentic workflows stick for you.

Daily agent use - Pro+ at $60/month ($720/year) is the honest tier, and the math is straightforward. If your realistic usage is $60-$100 and Pro only includes $20, you'd pay $40-$80 of on-demand on top of the $20 subscription anyway - landing at $60-$100 total with none of it prepaid at a favorable rate. Pro+ covers $70 of that for a flat $60. You're not upgrading to get features; you're upgrading because it's arithmetic.

Agent-first development, multiple concurrent sessions - Ultra at $200/month ($2,400/year) includes $400 of usage, the only tier where included usage is double the subscription price. If you're a power user in Cursor's "often $200+/mo" bracket, Ultra converts an unpredictable on-demand bill into a mostly-flat one. Below that bracket it's an expensive comfort blanket.

One honest unknown: Cursor doesn't publish a per-request price table for each frontier model on the pricing page, so you can't precompute exactly how many agent sessions fit in $20 or $70. The practical approach is to run one normal month on Pro, read your usage dashboard, and let your own number pick the tier.

What a team of 8 actually pays

Teams pricing has two seat types, and the spread is wide: Standard at $40/user/month, Premium at $120/user/month with "5x the Standard limits on Agent." There's also a line item that individual plans don't have: Teams and Enterprise pay a Cursor Token Rate of $0.25 per million tokens on third-party model requests (first-party models and Auto are excluded). On heavy agent workloads routed to frontier models, that surcharge is small per request but nonzero at scale - budget for it rather than discovering it.

Here's the annual math at common team sizes, using GitHub Copilot's same-day-verified prices as the anchor: Copilot Pro is $10/user/month and Pro+ is $39/user/month.

The surprise in that table is how close Cursor Teams Standard and Copilot Pro+ have become: $8 per month of difference for an 8-person team ($320 vs $312). At list price, "Cursor is the expensive one" is simply no longer true against Copilot's premium tier - the real gap is structural. Copilot's paid tiers bundle a monthly AI credit allowance ($15 of credits on Pro, $70 on Pro+, $200 on the $100/month Max tier), while Cursor bundles dollar-denominated usage plus the token surcharge on team plans. Also worth stating honestly: Copilot Business and Enterprise prices weren't listed on the plans page we checked - it's a contact-sales motion - so we can't put a verified Business number in this table, and you shouldn't trust posts that do without a date on the screenshot.

The Copilot Pro column is the one that should give a budget owner pause. If your team's honest usage pattern is autocomplete plus occasional chat, eight Copilot Pro seats cost $960 a year against $3,840 for Cursor Teams Standard - a $2,880 annual gap that buys a lot of other tooling. Cursor wins that comparison only if the agent workflows are genuinely load-bearing for your team. For a deeper feature-level comparison, our Claude Code vs Cursor vs GitHub Copilot breakdown covers what each tool's agent actually does day to day, and the head-to-head Cursor vs GitHub Copilot piece goes narrower and deeper on these two.

Where usage-based billing actually bites

A few failure modes show up consistently with metered AI coding tools, and Cursor's structure is no exception. None of them are hidden; all of them are underpriced in people's mental models.

The agent retry loop. Agents fail, re-plan, and retry. Every retry consumes usage. A stuck agent session on a gnarly refactor can quietly spend a meaningful chunk of a month's included usage in an afternoon, and the bill arrives in arrears - you find out after, not during.

Long-context sessions. Pointing the agent at a large monorepo means large context windows on every request. Token consumption scales with what the model reads, not with what it writes, and reading is most of what agents do.

The team surcharge on frontier models. The $0.25 per million token rate on third-party models applies on top of Teams seat prices. Teams that standardize on first-party models (Auto, Composer 2.5, Grok 4.5) avoid it entirely; teams that insist on a specific frontier model for everything pay it on every request.

Budgeting the sticker instead of the estimate. The single most common mistake: approving $20 per seat and being surprised by $60-$100. Cursor published the estimate. Use their number, not the plan price, when you build the budget.

The mitigation playbook is short: default to first-party models for routine work, watch the usage dashboard weekly for the first month, and decide upfront whether overage should be absorbed (on-demand) or capped (upgrade the tier and treat it as flat cost).

When you should not switch to Cursor - or not upgrade

Cursor's pricing rewards a specific user: someone who has already made agentic coding a daily habit and wants predictable-ish costs around it. It punishes a different user: someone paying for capability they use twice a month.

Stay where you are if autocomplete and chat are 90% of your usage - Copilot Pro at $10/month delivers that for half Cursor's entry price, inside the GitHub review and PR flow your team already lives in. Skip the Pro+ upgrade if your usage dashboard shows you inside $20 most months; upgrading "to be safe" costs $480 a year for headroom you demonstrably don't use. And hold off on Teams Premium until Standard seats are actually hitting agent limits in practice - it's a 3x price jump per seat, and the 5x agent ceiling only matters for teams that have already saturated the Standard one. If you're evaluating the broader field before committing to any of this, our Cursor alternatives roundup and the full pricing hub cover the adjacent options with the same live-verification standard.

There's also a legitimate walk-away case on cost volatility alone. If your finance process needs a fixed number per seat per month, a metered tool with in-arrears billing is a genuinely worse fit than a flat-rate one, independent of capability. That's not a knock on Cursor - it's a procurement reality that no feature list fixes.

The bottom line

Cursor's 2026 pricing is more honest than its reputation - the estimates are published, on-demand rates match plan rates, and nothing gets silently throttled. But the sticker prices are the least informative numbers on the page. The real decision inputs are three: your agent-days per week (picks your individual tier), your model routing discipline (decides whether the team token surcharge matters), and whether your budget can absorb variance (decides metered vs flat tooling at all). Verify your own usage for one month before committing to an annual anything - and verify the prices too, because if this page's history proves anything, it's that they move.

Prices verified directly against cursor.com/pricing, the official Cursor pricing docs, and github.com/features/copilot/plans on 2026-07-11.