Cursor Pricing 2026 offers six pricing plans : Hobby (free), Pro ($20/month), Pro+ ($60/month), Ultra ($200/month), Teams ($40–$120/user/month), and Enterprise (custom pricing). Every paid plan includes a monthly credit pool equal to its price, which is consumed only when you manually select a premium frontier model (Auto mode usage doesn’t draw from the pool). Annual billing cuts roughly 20% off individual plans. Actual monthly spend can run well above the list price if your team relies heavily on frontier models like Claude Opus or GPT-5-class models, or uses Max Mode on large codebases.
Why Cursor’s Pricing Model Is Harder to Budget Than It Looks
Most generative AI SaaS tools price predictably: pay $X, get $Y of software, budget accordingly. Cursor doesn’t work that way anymore, and understanding why matters more than memorizing the plan names.
In June 2025, Cursor moved away from counting discrete “fast requests” and switched to usage-based billing pegged to the underlying model’s API cost. Instead of a hard cap on the number of premium queries you could run, each paid plan now includes a dollar-denominated credit pool. A quick autocomplete costs a fraction of a cent. A large agentic refactor across a multi-thousand-line codebase using a frontier generative AI model can burn through a meaningful chunk of that pool in a single session.
This is the same underlying economic shift the entire AI tooling category is going through — GitHub Copilot made an almost identical move to token-based “AI Credits” billing in June 2026. When the underlying compute cost varies by 10–50x depending on model and task complexity, flat per-seat pricing eventually becomes financially unsustainable for the vendor, so the cost gets pushed back to usage. For engineering leaders, that means you can no longer forecast AI tooling spend the way you forecast a Slack or Jira bill. You have to forecast it the way you forecast cloud infrastructure — as a function of usage patterns, not headcount.
That’s the framing to keep in mind through the rest of this guide: Cursor’s plan price is a floor, not a ceiling.
Cursor Pricing Plans 2026: Full Breakdown
Here’s every current Cursor tier, what it includes, and who it’s actually built for.
| Plan | Price | Credit Pool | Best For |
| Hobby | Free | Limited (no dollar pool) | Evaluating the editor, students, light personal projects |
| Pro | $20/mo ($16/mo annual) | $20/month | Individual developers coding daily |
| Pro+ | $60/mo | $60/month (~3x Pro) | Developers who regularly exhaust Pro’s credits |
| Ultra | $200/mo | $200/month (~20x Pro) | Full-time, agent-heavy power users |
| Teams (Standard) | $40/user/mo | Split pool: first-party + third-party | Small-to-midsize engineering teams |
| Teams (Premium) | $120/user/mo | ~5x Standard usage | Heavy agent users on a team plan |
| Enterprise | Custom | Pooled org-wide usage | Regulated industries, large orgs, procurement-driven buying |
Hobby: The Real Free Tier
The Hobby plan is a genuinely usable free tier rather than a time-boxed trial. It includes limited Tab completions, limited Agent requests, and a short Pro trial for new accounts. There’s no credit card requirement, and the core VS Code-based editor experience — extensions, Git integration, terminal, themes — works without restriction. It’s the right starting point if you’re evaluating whether Cursor’s workflow fits before committing budget.
Pro: The Default for Individual Developers
At $20/month, Pro is Cursor’s most popular tier and the sensible default for most working developers. It includes:
- Unlimited Tab completions
- Unlimited Auto mode usage (doesn’t touch your credit pool)
- Extended limits on Agent
- Access to frontier models (Claude, GPT, Gemini families) when manually selected
- MCP (Model Context Protocol) support, skills, and hooks
- Cloud Agents for running tasks off your local machine
The catch: that “unlimited” language applies to Tab and Auto mode specifically. The moment you manually pick a premium model say, a specific Claude or GPT variant you’re drawing from a $20 monthly credit pool priced at the model’s real API cost.
Pro+ and Ultra: Headroom for Power Users
Pro+ ($60/month) and Ultra ($200/month) don’t add new capabilities over Pro — they add usage headroom. Pro+ gives roughly 3x Pro’s credit pool; Ultra gives roughly 20x, plus priority access to new features. Neither is worth buying speculatively. The right trigger for upgrading is data: if your Pro credit pool is consistently exhausted before the billing cycle resets and you’re regularly paying overage charges, Pro+ likely pays for itself. Ultra only makes sense for developers running agents continuously, all day, against frontier models.
Teams: Standard vs. Premium Seats
Cursor’s Teams plan (sometimes still referred to by its earlier “Business” branding in older guides) is priced per seat and adds centralized administration on top of Pro-equivalent AI capability:
- Centralized billing and admin dashboard
- Team-wide privacy mode
- SAML/OIDC SSO
- Shared marketplace for internal rules, skills, and plugins
- Usage analytics broken down by user
- Agentic code review integration
As of the June 2026 update, Teams seats come in two flavors. Standard ($40/user/month) splits usage into two separate pools one for Cursor’s first-party models (including its in-house Composer model) and Auto mode, and a separate pool for third-party frontier models like Claude, GPT, and Gemini. This structural change gives every seat meaningfully more effective usage at the same price, because routine work no longer competes with frontier-model usage for the same dollar pool. Premium seats ($120/user/month) provide roughly 5x the usage of Standard for 3x the cost, aimed at developers who run agents heavily enough to hit Standard limits every cycle. Teams can mix Standard and Premium seats freely across the same organization, which is the practical lever for controlling blended cost — put light users on Standard and reserve Premium for your heaviest agent users.
Enterprise: Procurement-Friendly, Not Necessarily Cheaper
Enterprise pricing is custom and negotiated directly with Cursor’s sales team. It adds pooled organization-wide usage (so unused credits from light users offset heavy users instead of being stranded per-seat), invoice and PO-based billing, SCIM seat provisioning, granular repository/model/MCP access controls, audit logs, service accounts, an AI code-tracking API for compliance reporting, and dedicated support. Enterprise is the right conversation to have once compliance requirements SOC 2 mapping, audit trails, data residency, procurement rules that require invoicing rather than credit-card billing become non-negotiable, not simply because you’ve crossed a headcount threshold.
How Cursor’s Credit and Usage-Based Billing Actually Works
This is the section most pricing guides gloss over, and it’s the part that actually determines your bill.
The Core Mechanic
Every paid Cursor plan includes a credit pool denominated in dollars, equal to the plan price (Pro = $20, Pro+ = $60, Ultra = $200). Credits are consumed based on:
- Which model processes the request — frontier reasoning models cost meaningfully more per token than lighter models, because Cursor is passing through real API economics from model providers.
- Token volume — input tokens, output tokens, and cached tokens are all metered separately, with output tokens generally costing several times more per unit than input tokens.
- Context size — pulling multiple large files into a prompt (via @ references) or enabling Max Mode for extended context windows increases the tokens processed, and therefore the cost, of that single request.
What’s Effectively Unlimited
Two categories of usage are excluded from the credit pool on paid plans:
- Tab completions Cursor’s inline autocomplete, powered by its own fast proprietary model
- Auto mode when you let Cursor select a cost-efficient model automatically rather than manually specifying one
This is the single most important cost-control lever available to any team on Cursor. If your developers default to Auto mode for routine work and reserve manual model selection for genuinely hard problems, a $20 Pro seat can comfortably cover a full month of typical usage. If developers habitually hand-pick the most capable frontier model for every task including trivial ones that same seat can burn through its credit pool in the first one to two weeks.
What Happens When You Run Out
Once a plan’s credit pool is exhausted, you have two options:
- Pay-as-you-go overage, billed at the same underlying API rates with no markup, so usage continues uninterrupted
- Upgrade to a higher tier with a larger included pool
Overages are opt-in in the sense that you can disable on-demand billing entirely in account settings, which hard-caps your spend at the plan price and simply pauses premium-model access once credits run out — a meaningful control for cost-conscious teams and finance-sensitive startups.
Bring-Your-Own-API-Key
Cursor also supports connecting your own API keys for supported providers, letting you bypass Cursor’s built-in credit system and pay the model provider directly at their published rates. This can be more economical for organizations that already negotiate volume API pricing with a provider, though certain core features (like Tab completions) always run on Cursor’s own infrastructure regardless of key configuration.
The June 2026 Teams Pricing Update: What Changed
Cursor made a structural change to Teams pricing that’s worth calling out separately, since it materially affects per-seat economics for any organization already on — or evaluating — a Teams contract.
What changed:
- Standard Teams seats now draw from two separate usage pools instead of one combined pool: first-party models (Composer and Auto) and third-party frontier models (Claude, GPT, Gemini, etc.). This means routine, first-party-model work no longer competes with frontier-model usage for the same dollar allowance.
- A new Premium seat tier was introduced at $120/user/month, delivering roughly 5x the usage of a Standard seat for 3x the price — a genuinely better ratio for teams whose heaviest users were previously spilling into overage every cycle.
- Cursor states these changes lower effective cost for the large majority of teams, since more total usage is now available at the same headline price.
- The change applied immediately for new customers, with existing/renewing customers transitioning as of July 1, 2026.
What this means practically for a buyer: if you evaluated Cursor Teams before mid-2026 and concluded the per-seat economics didn’t work for your agent-heavy developers, it’s worth re-running the numbers. The split-pool structure and the new Premium tier specifically target the complaint that drove a lot of the original backlash — that a handful of heavy users on a team plan would burn shared or individual credit pools well before the billing cycle reset.
Cursor vs. GitHub Copilot: 2026 Pricing Comparison
GitHub Copilot is the most common alternative evaluated alongside Cursor, and it went through a strikingly similar pricing evolution — moving to usage-based “AI Credits” billing on June 1, 2026, replacing its old premium-request-unit model.
| Tier Type | Cursor | GitHub Copilot |
| Free | Hobby ($0) | Copilot Free ($0) |
| Entry individual | Pro ($20/mo) | Copilot Pro ($10/mo) |
| Power-user individual | Pro+ ($60/mo) | Copilot Pro+ ($39/mo) |
| Top individual tier | Ultra ($200/mo) | Copilot Max ($100/mo) |
| Team/Business seat | Teams Standard ($40/user/mo) | Copilot Business ($19/user/mo) |
| Team/Business (heavy) | Teams Premium ($120/user/mo) | — |
| Enterprise | Custom | Copilot Enterprise ($39/user/mo) |
| Billing model | Dollar-credit pool tied to model API cost | Token-based AI Credits tied to model API cost |
The practical difference isn’t the sticker price — it’s depth of integration.
Copilot is materially cheaper at every tier and supports a broader range of IDEs (VS Code, JetBrains, Neovim, Visual Studio, Xcode). Cursor costs roughly double at the entry tier but is purpose-built as an AI-native editor: its Composer feature for multi-file agentic edits, deeper codebase indexing, and more flexible manual model selection tend to be the deciding factors for teams that pay the premium. If your workflow is primarily inline completions and chat-assisted edits, Copilot’s lower cost is hard to argue with. If your team leans heavily on autonomous multi-file agent workflows and wants to choose between multiple frontier model providers in one tool, Cursor’s premium is usually justified — but only if you actively manage the credit-consumption behaviors described above.
Independent benchmarking bodies like the DORA (DevOps Research and Assessment) program, part of Google Cloud, publish annual data on AI-assisted software development adoption and productivity outcomes that’s useful context when building the ROI case for either tool see the DORA State of AI-assisted Software Development research for methodology and findings on developer AI usage patterns.
Real-World Cost Modeling: What Will You Actually Pay?
Plan prices are the easy part. Here’s how costs play out across common team profiles.
Scenario 1: Solo Developer, Moderate Usage
A developer using Cursor Pro ($20/month), mostly on Auto mode with occasional manual selection of a frontier model for complex debugging, typically stays within the $20 credit pool. Tab completions and Auto mode usage are unmetered, so the credit pool is really only “spent” on the deliberate, harder tasks — which for most individual contributors is a manageable minority of daily work.
Realistic monthly cost: $16–$25 (annual billing brings the base rate to ~$16/month; light overage is possible but not typical).
Scenario 2: Full-Time AI-Native Developer
A developer running Agent mode continuously, doing multi-file refactors, and manually selecting frontier models for most tasks will likely exhaust a Pro credit pool well before the billing cycle resets. This profile is exactly who Pro+ or Ultra is designed for.
Realistic monthly cost: $60–$200, depending on whether Pro+ headroom is sufficient or the workload justifies Ultra.
Scenario 3: 10-Person Engineering Team on Teams (Standard)
At $40/user/month, a 10-person team’s base cost is $400/month before any overage. Because Standard seats now split first-party and third-party usage pools (post-June 2026 update), most teams with a mix of routine and complex work will fit comfortably within included usage, with occasional overage from your heaviest 1–2 users.
Realistic monthly cost: $400–$600/month, assuming a typical mix of usage intensity across the team.
Scenario 4: 50-Person Engineering Org, Mixed Standard/Premium
A 50-person org with 40 Standard seats and 10 Premium seats (for your heaviest agent users) breaks down as:
- 40 × $40 = $1,600
- 10 × $120 = $1,200
Base total: $2,800/month, before any residual overage.
This is a meaningfully more predictable structure than treating every seat as a single tier and eating unpredictable overage charges from your top 20% of users. It mirrors what several FinOps-focused vendors have observed: AI coding tool spend across a 50-person team, inclusive of Cursor, Copilot, or Claude Code alongside production API usage, commonly lands in the $5,000–$15,000/month range before any underlying cloud infrastructure cost — a figure worth putting in front of finance early rather than discovering it after rollout.
Scenario 5: Enterprise with Pooled Usage
For a large, regulated organization, the value of Enterprise isn’t a lower per-seat rate — it’s pooled usage that lets light users’ unused allowance offset heavy users’ overage, invoice-based billing that fits existing procurement workflows, and audit/compliance tooling that a self-serve Teams plan doesn’t provide. Cost here is genuinely negotiated and should be modeled against your actual usage telemetry, not the public Teams rate.
Hidden Costs and Budget Risks to Watch For
Several cost drivers don’t show up on the pricing page and are worth flagging to any technical buyer or finance stakeholder before rollout.
- Max Mode is expensive by design — it expands the context window for harder reasoning tasks, which means significantly more tokens processed per request. A handful of Max Mode sessions can consume a disproportionate share of a monthly credit pool.
- Large-codebase context pulls add up — referencing multiple large files in a single prompt scales token cost linearly with what you include, a habit that’s easy to underestimate until the bill reflects it.
- Model choice compounds across a team — a five-person team defaulting to the most expensive frontier model for every task will burn credits multiple times faster than a team disciplined about reserving premium models for genuinely hard problems, and the effect multiplies with headcount.
- Bugbot and other add-ons are billed separately from core editor plans in some configurations — code-review-focused AI tooling is increasingly sold as its own line item rather than bundled, so confirm current terms directly with Cursor’s sales team before assuming it’s included in a Teams or Enterprise quote.
- Overage is silent unless you configure alerts — without dollar-threshold notifications, an engineering team can run well past its included usage before anyone notices on the invoice.
Best Practices for Controlling Cursor Costs at Scale
For engineering leaders rolling Cursor out beyond a handful of early adopters, these are the practical levers that keep spend predictable:
- Default to Auto mode — since Auto mode and Tab completions don’t draw from the credit pool, making Auto the team default for routine work (reserving manual model selection for genuinely complex tasks) is the single highest-leverage cost control available.
- Configure spend alerts in the Admin Dashboard — admins can set dollar-threshold alerts delivered via Slack or email before overages occur, giving engineering managers a chance to intervene before a bill surprises finance.
- Review per-user usage breakdowns regularly — usage analytics available on Teams and Enterprise plans surface which individuals or squads are driving disproportionate spend, far more actionable than a single aggregate invoice line.
- Mix Standard and Premium seats deliberately — don’t put your entire team on Premium “just in case.” Start everyone on Standard, monitor usage for a full billing cycle, and move only your genuinely heavy agent users to Premium.
- Disable on-demand overage for cost-sensitive pilots — if you’re running an initial pilot with a fixed budget, turning off pay-as-you-go billing hard-caps spend at the plan price and gives you a clean, bounded number to report back to stakeholders.
- Treat model selection as a policy, not a preference — publish internal guidance on when frontier models are actually warranted (complex multi-file refactors, security-sensitive code, architecture decisions) versus when Auto mode is sufficient (routine CRUD, boilerplate, straightforward bug fixes).
- Benchmark against your actual DORA metrics — before committing budget at scale, correlate Cursor usage with actual delivery metrics using a recognized framework rather than relying on anecdotal productivity claims.
How to Choose the Right Cursor Plan: A Decision Framework
| If your situation is… | Choose… |
| Evaluating the editor before committing budget | Hobby |
| Individual developer, daily use, mostly Auto mode | Pro |
| Individual developer regularly exhausting Pro’s credits | Pro+ |
| Full-time agent-heavy power user, frontier models all day | Ultra |
| Team of 3+ needing centralized billing, SSO, shared rules | Teams Standard |
| Team with a subset of heavy agent users hitting Standard limits | Teams Standard + Premium seats mixed |
| Compliance, audit, invoice billing, or pooled org-wide usage required | Enterprise |
The most common and costly mistake is provisioning the most expensive tier “just in case” a team might need it. Start conservative — Pro for individuals, Teams Standard for organizations — run one full billing cycle, and let actual usage data drive upgrade decisions. Cursor’s own admin analytics make this a low-effort exercise, and it’s the difference between a defensible line item and a line item finance starts questioning at renewal.
Conclusion: Making the Right Cursor Pricing Decision in 2026
Cursor pricing in 2026 rewards teams that treat it like infrastructure spend rather than a flat software subscription. The plan price you see on the pricing page — $20 for Pro, $40 for a Teams seat — is a starting point, not the final number, because actual cost is driven by model choice, task complexity, and how disciplined your team is about defaulting to Auto mode.
For most individual developers, Pro on annual billing remains the right default, with Pro+ or Ultra reserved for genuinely heavy, data-justified usage. For engineering teams, the June 2026 split-pool structure and new Premium seat option make Teams meaningfully more predictable than it was a year earlier — but only if you actively mix Standard and Premium seats based on real usage data rather than provisioning everyone at the top tier by default.
The technical decision-makers who get the most value from Cursor are the ones who set up spend alerts, publish clear internal guidance on model selection, and revisit their plan mix every billing cycle instead of setting it once and forgetting it. Treat Cursor pricing the way you’d treat any other variable infrastructure cost — instrument it, monitor it, and let usage data drive the upgrade decision — and the tool pays for itself many times over in developer throughput.
