Cursor looks like a $20 code editor. It behaves like metered cloud infrastructure. That gap is the whole story of Cursor pricing, and it’s why so many users, from solo developers to whole engineering teams, open their billing page to a number they didn’t expect.
Underneath the sticker price sits a usage-credit system that meters every AI request, so what you actually pay depends on which models you run and how hard you run them. Manage that well and Cursor is cheap. Ignore it and the bill climbs fast. Most guides explaining this are written for career software engineers, and worse, nearly all of them still tell students to grab a “free year” that Cursor shut down in June 2026.
This is the plain-language, accurate version, written to help you control the cost, not just read the price list: every current plan, how the credit system really works, what each model actually costs, how to cut your bill solo or across a team, the correct student situation, and a straight answer on which tier to pick. (For context on how fast this company is moving, Cursor went from roughly $100 million in annualized revenue in January 2025 to about $4 billion by June 2026, and that growth runs on expensive AI model calls, which is exactly why its pricing has changed twice in a single year.)
What Is Cursor, and What Are You Actually Paying For?
Cursor is an AI-first code editor built by a company called Anysphere, but for budgeting purposes it’s better understood as a managed AI service you pay for by usage. It’s a fork of Visual Studio Code, the most popular code editor in the world, rebuilt so AI sits at the center of the workflow instead of hanging off the side as a plugin. You can ask it to write code, refactor across many files, run tests, and increasingly hand it a task and let it work as an autonomous agent. (New to coding entirely? Our primer on what PHP is is a gentle place to start understanding what these tools are editing.)
Four things drive what you pay. The Agent handles complex, multi-file tasks and is the biggest cost driver. Tab is the AI autocomplete. Model selection decides which underlying AI you’re using, and the gap between a cheap model and a frontier one is enormous. Context window is how much of your code the AI reads at once. More context, more expensive request.
Here’s the part that matters for your wallet. You’re not really paying for Cursor the app. You’re paying for model usage. Every meaningful request is an API call to a model from Anthropic, OpenAI, or Google, and those calls cost real money. If you’re weighing AI tools more broadly, our roundup of the best no-code AI platforms covers the wider landscape Cursor sits in.
Cursor isn’t a niche tool. It reports more than a million daily active users, a majority of the Fortune 500 as customers, and roughly 60% of its revenue now comes from enterprises. So when you weigh up what Cursor, the AI code editor, offers in features and pricing, keep that scale in mind. This is infrastructure, and it’s priced like infrastructure.
Cursor Pricing 2026: Every Plan and Price
Cursor’s pricing page lists six tiers — four for individuals and two for teams — plus custom Enterprise. Here’s the full breakdown.
| Plan | Price | Best for |
|---|---|---|
| Hobby | Free | Trying Cursor, light occasional use |
| Pro | $20/mo | Individual developers, daily coding |
| Pro+ | $60/mo | Daily agent users (3x usage) |
| Ultra | $200/mo | Agent power users (20x usage) |
| Teams — Standard | $40/user/mo | Teams needing shared billing and SSO |
| Teams — Premium | $120/user/mo | Heavy-agent team members (5x Standard) |
| Enterprise | Custom | Large orgs needing pooled usage, compliance |
Hobby is free, needs no credit card, and gives you limited Agent requests and limited Tab completions. It’s built for evaluation. You’ll feel the limits inside any real coding session, but it’s genuinely useful for kicking the tires.
Pro at $20/month is the popular one. You get unlimited Tab completions, extended Agent limits, cloud agents, access to all frontier models, and a $20 pool of usage credits for premium model calls. For most individual developers, this is the right home.
Pro+ at $60/month is Cursor’s officially recommended tier for daily agent users. Same features as Pro, with 3x the usage. Ultra at $200/month pushes that to a 20x usage multiplier and targets people who run agents as their primary way of working.
On the business side, Teams Standard runs $40 per user per month. It adds centralized billing, SAML/OIDC SSO, usage analytics, a team marketplace for shared rules and skills, and Bugbot code reviews. In June 2026, Cursor split the Standard seat’s usage into two separate pools, one for its own models and one for third-party APIs like Claude and GPT. That handed every seat more total headroom at the same price. The same update added Teams Premium at $120 per user per month, giving heavy users 5x the Standard usage.
Enterprise is custom-priced. It adds pooled usage across the org, invoice and PO billing, SCIM seat management, access controls, and audit logs. On the compliance side, Cursor is SOC 2 Type II certified, and Enterprise adds an AI code tracking API and granular admin controls over which models and integrations your team can use. Team-wide privacy mode guarantees your code isn’t used to train any model, usually the first box a security team wants ticked before approving a tool. Annual billing saves about 20% on all paid tiers. Cursor Pro business pricing scales cleanly from a solo $20 seat up to an org-wide rollout.
The Bugbot Add-On (AI Code Review)
Separate from the core plans, Cursor sells Bugbot, an AI code-review tool that checks your pull requests. It has its own four-tier pricing:
| Tier | Price | What you get |
|---|---|---|
| Free | $0 | Limited reviews per month, unlimited Cursor Ask, auto-fix, GitHub integration |
| Pro | $40/user/mo | Unlimited reviews up to 200 PRs/month, Bugbot Rules, 14-day trial |
| Teams | $40/user/mo | Everything in Pro, plus unlimited reviews across all PRs, analytics dashboards, advanced rules |
| Enterprise | Custom | 30-day org-wide trial, advanced reporting, priority support |
If code review is part of your workflow, this is a real line item to budget for on top of your Cursor seat.
How Does Cursor Pricing Actually Work? The Credit System in Plain English
This is where people get burned. It’s worth slowing down.
In June 2025, Cursor replaced its old system, a fixed allotment of “500 fast requests,” with a usage-credit pool. Your $20 Pro subscription now buys $20 worth of model usage. Not unlimited anything. A pool.
Two modes decide how fast that pool drains. Auto mode lets Cursor pick a cost-efficient model for the task, and it’s effectively unlimited on paid plans, because it doesn’t draw down your pool at full rates. Manual model selection is the opposite. When you deliberately choose a frontier model like Claude Opus or a top GPT version, you pay that model’s full API rate and the pool empties fast. This agent-driven usage is the same cost pattern you’ll see across low-code AI agents generally.
Why build it this way? A flat per-request price can’t survive the cost gap between a one-line autocomplete and a multi-file refactor running an expensive model across your whole codebase. One costs a fraction of a cent. The other can run several dollars in a single pass. Anysphere itself spends an estimated $0.40 to $0.70 on model inference for every dollar of revenue, so it has to track real compute cost or lose money on heavy users.
Here’s what that means in practice. A typical Pro user who leans on Tab completions and Auto mode rarely exhausts the $20 pool in a month. A user who runs frontier-model agents all day can burn through it in an afternoon. Same subscription, wildly different bills.
When the pool runs dry, you get two choices. Upgrade to a higher tier with more included usage, or turn on pay-as-you-go overage billing at API rates and keep working. The surprise-bill complaints almost all trace back to one gap: the sticker price feels like “unlimited,” but the credit pool means “metered.” Understanding how Cursor pricing works is really just understanding that one distinction.
What Each Model Actually Costs
The credit pool drains at different speeds depending on which model you pick. This is the single biggest lever on your bill, so it’s worth seeing the actual numbers.
When you let Auto mode run, Cursor bills at flat rates: about $1.25 per million input tokens, $6 per million output tokens, and $0.25 per million cached tokens. Those rates don’t draw from your monthly pool on a paid plan, which is why Auto mode feels close to unlimited.
The moment you manually pick a frontier model, you pay that model’s real API rate, and the range is enormous. Here’s what the popular models cost inside Cursor as of mid-2026, per million tokens:
| Model | Input | Output | Best for |
|---|---|---|---|
| Gemini 2.5 Flash | ~$0.30 | ~$2.50 | Fast, cheap, routine work |
| GPT-5 Mini | ~$0.25 | ~$2 | Budget everyday tasks |
| Claude Haiku 4.5 | ~$1 | ~$5 | Quick edits, low cost |
| Gemini 3.1 Pro | ~$2 | ~$12 | Balanced reasoning |
| Claude Sonnet 4.6 | ~$3 | ~$15 | Strong general coding |
| Claude Opus 4.8 | ~$5 | ~$25 | Hardest multi-file reasoning |
Two things jump out. Output tokens cost two to five times more than input tokens across every model, so long AI-generated answers cost more than the prompts you send. And the spread between the cheapest and priciest model is huge. By one estimate, Claude Opus burns credits roughly 20 times faster than Gemini Flash, so the same $20 that covers around 700 Flash requests might cover only about 34 Opus prompts.
Model names and rates change fast in this market, so treat these as examples rather than gospel. Cursor keeps live rates on its models-and-pricing docs page. The pattern, though, is stable: lightweight models are cheap, frontier models are expensive, and output is where the money goes.
Cursor Student Pricing: What Actually Changed in 2026
If you’ve read an older guide telling you to verify a .edu email for a free year of Cursor Pro, stop. That information is out of date.
Cursor discontinued its free-year student program to new sign-ups on June 25, 2026. The old offer gave verified university students a full year of Cursor Pro at no cost, worth about $240, through SheerID verification. Cursor says the program had become a target for fraud and held it back from reaching students globally, so it closed the door to new applicants.
Two routes replaced it. Undergraduates will get credits and discounts through Cursor’s on-campus and online events, starting fall 2026. Master’s students, PhD candidates, academic researchers, and educators can request credits through an official form that’s live now, though Cursor doesn’t publish the amounts.
Already claimed the free year before June 25? You keep your rate until the plan expires. After that it renews at the standard $20 a month unless you cancel, so set a calendar reminder before your renewal date. The Cursor student picture changed overnight, and most of the web hasn’t caught up.
Students still have options in the meantime. GitHub Copilot offers a free verified-student tier, and Cursor’s free Hobby plan stays open to everyone for light use. Neither replaces a full year of Pro, but both keep you coding while the fall event credits roll out.
Which Cursor Plan Should You Actually Pick?
The plan table is the easy part. Matching it to your real usage is where people overspend. Here’s the honest framework.
“I’m just trying it, learning to code, or editing the occasional file.” Start on Hobby (Free). Upgrade only when the limits interrupt your work mid-session.
“I code a few hours most days, mostly autocomplete with the occasional agent task.” Pro ($20) is your tier. Most Pro users never exhaust their credit pool, so overage charges are unlikely.
“I run AI agents heavily, every day.” Step up to Pro+ ($60). It’s Cursor’s own recommendation for daily agent users, and the 3x headroom is cheaper than paying overages on Pro.
“Agents are my entire workflow, all day.” Ultra ($200), with its 20x multiplier, is built for you.
“We’re a team that needs shared billing, SSO, and admin controls.” Teams Standard ($40/user), with Premium ($120/user) for the handful of heavy-agent members. Enterprise if you need invoicing, pooled usage, and compliance controls.
For a Smart Admin — someone who manages a WordPress site or builds with no-code tools and only occasionally dips into real code — the free Hobby tier is very likely enough. If you’re tweaking an exported app or writing the odd snippet, don’t buy a $20 subscription you’ll barely touch.
Whatever tier you land on, three habits keep costs predictable. Default to Auto mode. Reserve frontier models for genuinely complex tasks that need the extra reasoning. And watch the usage dashboard, where you can set spend thresholds before a bill catches you off guard.
Managing Cursor Costs Across a Team
For an individual, Cursor’s cost is easy to eyeball. Across a team it becomes a real budgeting exercise, because two developers on the same plan can run up very different bills depending on how they work.
Start by forecasting usage. Estimate how many agent requests each engineer runs per day, then multiply out. A ten-person team leaning on frontier models can burn through thousands of requests a month, which is exactly the scenario that produces a surprise invoice.
The June 2026 Teams update helps here. Cursor now splits each Standard seat’s usage into two pools, one for its own Composer and Auto models and one for third-party APIs like Claude and GPT. Defaulting your team to Composer 2.5, Cursor’s first-party model, keeps most work inside the generous first-party pool and spares the third-party credits for tasks that genuinely need them. That one habit can meaningfully cut a team’s bill.
For heavy users, the Premium seat at $120 costs three times a Standard seat but includes five times the usage. Cursor expects it to cover 99% of heavy users for a full month without overages, and you can mix Standard and Premium seats freely. The admin dashboard now recommends which users should move up or down a seat type based on what they actually use.
Admins also get rebuilt spend controls. You can set dollar-threshold alerts that fire before a bill runs over, not after, and route them to Slack or email. For a business treating Cursor as real infrastructure, turning those alerts on is the difference between a predictable monthly cost and a quarterly surprise.
How to Cut Your Cursor Bill
Whether you’re solo or running a team, five habits keep Cursor costs under control.
Pick the right model for the task. Default to Auto mode or Composer 2.5 for routine work, and save frontier models like Claude Opus or GPT-5 for genuinely hard, multi-file problems. This one choice moves your bill more than anything else.
Watch your usage dashboard. Turn on the always-visible usage summary in settings. By default Cursor only warns you once you pass 80% of a limit, which is often too late to change course. Seeing your consumption in real time lets you catch a runaway session early.
Trim your context. Every file you load into a request becomes input tokens you pay for. Reference only the files the model actually needs rather than pointing it at your whole codebase, and use Max Mode only when a task truly needs the expanded context, since it adds roughly a 20% surcharge.
Be deliberate with agents. A multi-step agent task makes a separate model call for each step, and each one costs money. Scoping the task clearly before you start, and planning with a cheaper model before switching to an expensive one to write the code, keeps the call count down.
Reuse and structure your prompts. Keep prompts concise, break large refactors into smaller chunks, and reuse earlier answers instead of regenerating them. None of this costs quality, and all of it saves credits.
Cursor vs GitHub Copilot: The Price Comparison
Cursor’s biggest rival is GitHub Copilot, and the price gap is real. Copilot’s 2026 lineup runs Free, Pro at $10/month, Pro+ at $39/month, Max at $100/month, Business at $19/user/month, and Enterprise at $39/user/month.
Copilot Pro is half the price of Cursor Pro. The two tools do different jobs, though. Copilot is autocomplete and chat layered into your existing editor, and it’s excellent at that. Cursor’s Composer and Agent handle multi-file refactors and complex, multi-step tasks in a way Copilot’s Chat doesn’t match. You pay more for that depth.
AI-tool pricing is converging on this metered model across the board — the same usage-based shift we covered in our guide to AI voice agent pricing. The whole category is drifting the same direction. GitHub switched Copilot to usage-based AI Credits on June 1, 2026, the same metered model Cursor adopted a year earlier. Flat monthly pricing for AI coding tools is quietly disappearing.
The honest read for a Smart Admin: if you already live in VS Code and want affordable autocomplete, Copilot at $10 is hard to beat. If you want a purpose-built AI editor for heavier building and agentic work, Cursor earns its premium. Neither is “unlimited” anymore, so watch usage on both.
Why Cursor’s Pricing Keeps Changing (and Probably Will Again)
A little company context explains the volatility. Anysphere was founded in 2022 by four MIT students, and Cursor became the fastest B2B software company ever to reach $1 billion in annualized revenue, crossing that mark in November 2025 and roughly doubling to $2 billion by February 2026.
The catch behind that growth is thin margins. Because Cursor spends an estimated 40 to 70 cents on inference per revenue dollar, its pricing has to track real compute cost or it loses money. That’s the engine behind every change: request-based pricing at launch, usage credits in June 2025, the Teams two-pool split plus a new Premium seat in June 2026. The Cursor company has repriced roughly once a year, and there’s little reason to expect that to stop.
Investor Bill Gurley captured the risk in early 2026, noting that AI coding valuations had reached a point where being right about the product doesn’t protect you from being wrong about the price. The same caution applies to you as a buyer. When a tool’s pricing is tethered to a business burning cash on model calls, the model can shift under you.
So treat Cursor as metered infrastructure you monitor, not a fixed subscription you set and forget — a mindset worth carrying into any decision about how you build a software product. Assume the pricing can change again, and keep the usage dashboard open.
Conclusion
Cursor pricing in 2026 comes down to a few clear choices. Free to try, Pro at $20 for most individuals, Pro+ at $60 for daily agent users, Teams or Enterprise for organizations. The number on the button matters less than the credit system beneath it. You’re metered, not unlimited, so default to Auto mode and keep an eye on your usage.
The student free year ended in June 2026, so check Cursor’s official student page for the current event-based routes rather than trusting an old blog post. As usage-based billing becomes the norm across every AI coding tool, the smartest move is to treat these editors as infrastructure spend you actively watch, not a flat cost you forget.
Frequently Asked Questions
Cursor’s paid individual plans are Pro at $20/month, Pro+ at $60/month, and Ultra at $200/month. Teams start at $40 per user per month for Standard and $120 for Premium, with Enterprise priced custom. There’s also a free Hobby tier. Annual billing saves about 20% on the paid plans.
Yes, the Hobby plan is free with no credit card required. It includes limited Agent requests and limited Tab completions. That’s enough to evaluate Cursor and fine for light, occasional use, but you’ll hit the limits during any sustained coding session. If you use Cursor daily, you’ll want Pro.
No. Cursor closed its free-year student program to new sign-ups on June 25, 2026, citing widespread fraud. Students who already redeemed it keep their rate until the plan expires. Replacements include event-based credits for undergraduates starting fall 2026 and a credit-request form for master’s students, PhD candidates, researchers, and educators.
All three share the same features. The only difference is usage capacity. Pro ($20) includes a base credit pool, Pro+ ($60) triples it, and Ultra ($200) applies a 20x usage multiplier. If you mostly use Auto mode, Pro is plenty. Move up only if you consistently exhaust your credits before the month ends.
Almost always because you manually selected a frontier model, like Claude Opus or a top GPT version, for heavy agent work. That drains your credit pool at full API rates, and once the pool is empty, on-demand overage billing kicks in. Switching to Auto mode and watching the usage dashboard prevents most surprises.
It depends on what you need. GitHub Copilot Pro costs $10/month, half of Cursor Pro, and is excellent for autocomplete and chat inside your existing editor. Cursor costs more but offers deeper AI integration and stronger multi-file agentic editing. For heavy building, Cursor earns the premium. For affordable everyday assistance, Copilot wins.
Cursor bills manually selected models at their real API rates, per million tokens. As of mid-2026 that ranges from budget options like Gemini Flash (around $0.30 input / $2.50 output) up to Claude Opus (around $5 input / $25 output). Auto mode is billed at flat discounted rates and doesn’t draw from your monthly pool, so it’s the cheapest way to work. Check Cursor’s models-and-pricing docs for current numbers, since they change often.
Default everyone to Auto mode or Cursor’s first-party Composer model, which draws from a separate, generous usage pool. Reserve frontier models for hard tasks. Turn on admin spend alerts so you’re warned before a threshold is crossed, use the dashboard’s seat recommendations to match seat types to real usage, and forecast requests per engineer before you scale up.
