Cursor Pricing 2026: Plans, Limits & What You’ll Really Pay

Cursor’s $20 Pro plan is just the starting point. Here’s how credits, token-based limits and overage actually shape your monthly Cursor bill in 2026 — and when to move to Pro+, Ultra or Teams.

Cursor pricing 2026 at a glance Cursor is priced as a mix of seat fees and metered AI usage. The headline numbers ( $0 Hobby, $20 Pro, $60 Pro+, $200 Ultra, $40 Teams Standard ) only cover the editor and a bundled block of model usage. Enterprise is custom‑priced, and all of these plans layer per‑seat fees with bundled AI usage. Key points for 2026, based on Cursor’s public pricing and docs : Hobby (free) gives access to the Cursor editor with limited AI usage compared to paid plans. Cursor does not publish exact Hobby usage caps; public summaries note that free usage is significantly lower than on paid tiers. Individual plans include Pro at $20/user/month , Pro+ at $60/user/month , and Ultra at $200/user/month . Each bundles a monthly “API agent usage” budget (in dollars) and then charges any overage at model API prices. Teams is $40/user/month . Enterprise is custom‑priced. The Teams card carries two tiers: Standard at $40/user/month and Premium at $120/user/month , the latter documented as 5x Standard limits on Agent. Paid plans no longer use simple “X requests/month” limits. Usage is normalised into a dollar budget based on tokens consumed × model price . Once the bundled budget is hit, Cursor offers to bill extra at cost (usage-based) or upgrade the account , instead of silently downgrading models. When choosing Cursor as part of a broader AI stack, it helps to consider how it fits alongside tools like Claude Code or Copilot — or whether a different editor-first tool belongs in a best AI coding stack for 2026 . If you’re still deciding between editor‑first and agent‑first workflows, this deeper Cursor review for 2026 covers the tradeoffs in real projects. All prices here are in USD and use the latest figures from Cursor’s public pricing pages and documentation, with as-of dates noted in the table below. Cursor plans, models and what you actually get for the sticker price Cursor’s plans break down into free Hobby, Individual (Pro/Pro+/Ultra), a Teams plan at $40/user/month, and custom‑priced Enterprise tiers. For a deeper look at how Cursor compares to terminal-first agents, see this separate Cursor vs Claude Code comparison and the broader Claude AI review if you’re standardising on Anthropic models. Cursor's plan row as it loads: Hobby free, Individual at $20/month on the Pro tier, Teams at $40/user/month on Standard Selecting Pro+ raises the Individual price to $60/month for 3x the Agent limits of Pro Ultra is $200/month, and the Teams card exposes a Premium tier at $120/user/month for 5x Standard's Agent limits Cursor pricing table (2026) Plan As of Headline price Included API agent usage Notes Hobby (Free) 2026-08-13 $0/month Very limited (small quota) Access to the Cursor editor with limited AI usage compared to paid plans. Exact free limits are not fully detailed on the public pricing page; third‑party summaries describe significantly lower quotas than paid tiers. Individual – Pro 2026-08-13 $20/user/month $20/month API agent usage Unlimited tab completions, extended agent limits, access to Background Agents and multiple model providers; usage beyond the included amount is billed at model API prices. Individual – Pro+ 2026-08-13 $60/user/month $70/month API agent usage Higher‑usage individual tier with a larger included usage bucket than Pro. Individual – Ultra 2026-08-13 $200/user/month $400/month API agent usage Usage-heavy individual tier with a large credit pool; effective monthly outlay can be higher once overage is counted. Teams – Standard 2026-08-13 $40/user/month Team usage limits per official Teams rules Includes team features like privacy mode enforcement, admin dashboard with usage stats, centralized billing and SSO; team limits are computed per‑request based on the official Teams usage rules. Teams – Premium 2026-08-13 $120/user/month 5x Standard limits on Agent Published on Cursor’s pricing page as the Premium tier of the Teams plan, selectable next to Standard. Enterprise 2026-08-13 Custom Custom SSO, SCIM, audit logs and advanced security controls, plus analytics, reporting, priority support and account management. Some Reddit threads mention grandfathered request‑based options, but these are not documented as a standard Enterprise feature and should be treated as anecdotal. Hobby: free, but with tight AI limits The Hobby tier is described in public breakdowns as a way to try Cursor’s editor without committing budget. Access to the Cursor editor UI. Limited AI usage relative to paid plans. Restrictions on higher-intensity agent requests and frontier model calls. This configuration is typically sufficient to evaluate the editor and light AI assistance, but not for full-time daily coding or heavy agents. Developers who only need help on occasional refactors may also compare this to lighter-weight tools in the best AI coding tools 2026 shortlist rather than committing to a paid Cursor plan, or even lean on more general assistants like ChatGPT Plus or Pro for ad‑hoc coding help. Individual: Pro, Pro+ and Ultra All Individual plans share the same core features according to Cursor docs: Unlimited tab completions. Extended agent usage vs Hobby. Access to Background Agents and multiple model providers. Model usage billed at underlying inference API prices . Bugbot is offered as a separate product with its own pricing. The critical difference is how much API usage is bundled before overage charges apply: Pro : includes $20 of API agent usage per month. Pro+ : includes $70 of API agent usage per month. Ultra : includes $400 of API agent usage per month, plus “bonus usage” described in documentation. Cursor’s pricing documentation gives rough equivalents for the Pro plan’s included usage, describing ranges on the order of a few hundred requests on mid‑priced models such as Sonnet 4, Gemini or a GPT‑family model, while stressing that actual counts vary with tokens per request. For Pro+, Cursor’s docs estimate that the larger $70 usage pool corresponds to several times the Pro request counts on Sonnet‑, Gemini‑ and GPT‑family models, again with the caveat that real limits depend on token usage per request. For Ultra, the $400 usage pool is described as suitable for significantly heavier workloads, with documentation giving indicative request ranges that scale up the same way for Sonnet‑, Gemini‑ and GPT‑family options; these are framed as approximations rather than hard guarantees. Teams and Enterprise tiers Teams at $40/user/month layers on: Centralised billing and workspace administration. An admin dashboard with usage statistics. Privacy mode enforcement and SSO. Team-oriented workflows such as code review and analytics. Teams Premium–style arrangements and Enterprise add, according to official docs and third‑party explainers: Higher and customisable usage ceilings. SCIM, audit logs and fine-grained controls on which models and MCPs are allowed in production repos. For some large customers, Reddit threads describe grandfathered or negotiated “request-style” options; these are anecdotal rather than standard policy. Team usage is still ultimately tied to the underlying model APIs; the main change is shared administration, governance and team-wide limits rather than purely individual buckets. For product teams, this needs to be weighed against the real cost of an AI MVP so Cursor does not become an unexpected line item. How Cursor’s usage and request limits actually work From request counts to dollar budgets Cursor previously advertised simple “X requests/month” style plans. Community threads describe a transition toward accounting usage in dollar terms and enforcing token-weighted limits instead, with some legacy request-based cases for enterprise contracts discussed anecdotally. Usage splits into two pools: Cursor's own models, and third-party models charged at their API price Cursor’s docs now describe paid plans as including a monthly bucket of API agent usage denominated in dollars, with usage drawn down based on the underlying model’s inference price. What counts as “usage” Learn Cursor’s breakdown and Cursor docs distinguish several usage types: Tab completions : in-line suggestions while you type. These are advertised as “unlimited” on paid plans, though they still run models in the background. Cursor treats them separately from the explicit agent usage bucket. Agent requests : explicit chat, refactor, explain or Background Agent runs. These are billed against the API agent usage budget at the model’s inference price. Auto/Composer and background runs : Cursor’s fast in-editor helpers, routed via a Cursor Router. Third-party breakdowns indicate that routing mode affects whether these draw from a bundled “Auto” budget or are billed directly at model API prices, but exact routing economics are not fully specified in Cursor’s public docs. Tools and MCPs : each tool call can trigger additional model inferences and therefore extra token spend. Token/cost accounting in practice Cursor’s usage accounting follows the underlying model APIs. The cost of a given request depends on: Model choice : frontier models like Sonnet 4 or newer GPT‑family options are priced much higher per token than cheaper alternatives. Heavy usage will drain the budget faster. Tokens in context : including large files, long conversations or repo-wide context multiplies tokens processed. Users on Reddit report hitting monthly limits in as few as 13 large Sonnet 4.x calls when contexts are big. Output length : long generated code or documentation adds to token counts. Chained calls : agents that use tools or search can spawn several model invocations per “single” request. This dynamic explains why a nominal allowance of hundreds of mid‑sized requests on Pro can compress into a much smaller number of interactions if each one pulls in thousands of lines of code. What appears when limits are hit Cursor displays explicit limit notifications inside the editor when usage nears or exceeds the included quota. Learn Cursor’s guide and Cursor docs note: A breakdown of usage (tokens, models, cost) is available in a dashboard. On hitting the plan’s included budget, the account is prompted to either:   • pay overage at cost (usage-based), or   • upgrade to a higher tier with more included usage. Requests are not silently downgraded to cheaper models. If overage is declined and no upgrade is chosen, high-cost requests can be blocked. On Teams/Enterprise, usage can be constrained with organization-level policies; published guidance for administrators emphasises monitoring team dashboards and setting limits where needed. Effective monthly Cursor cost by usage tier The sticker price ($0, $20, $40 and higher individual or team tiers) is predictable; the real bill depends on how aggressively agents and frontier models are used. User reports and documentation examples support three broad bands: Light users: often stay within the $20 Pro bundle. Daily agent users: frequently land around $60–$100/month once overage is included. Power users: can reach $200+/month , prompting a move to Ultra or team-oriented tiers. Persona 1: light daily coder Profile: Codes most days. Relies mainly on tab completions and small, focused prompts. Occasional agent sessions, modest context windows. Cursor’s examples suggest the Pro plan’s $20 agent usage bucket covers hundreds of relatively small calls on mid-priced models. For this persona, a realistic pattern based on those examples is: Total monthly cost : roughly $20–$30 . Overage, if any, comes from sporadic long-context or frontier calls. Upgrade pressure is low as long as prompts stay small and models conservative. Persona 2: serious indie dev / solo founder Profile: Builds and maintains one or more production apps. Uses agents daily for refactors, tests, migration scripts, and doc generation. Frequently pulls in multi-file or repo context. Cursor’s docs and third-party write-ups indicate that this profile usually moves beyond the base Pro budget: With Pro ($20 seat + $20 usage): Reddit and third‑party threads describe overages of $40–$80 once heavy refactors and frontier calls are in play, leading to $60–$100/month effective spend. With Pro+ ($60 seat, $70 usage included): the larger pool can keep total spend in the $90–$120 range for similar workloads, according to those same examples and write‑ups. This is the group for which the Pro+ tier’s higher included usage is positioned in Cursor’s documentation. Persona 3: power user or team lead Profile: Runs multiple agents concurrently. Executes frequent large-scale refactors and long-context reviews. Prefers frontier models (e.g., latest Sonnet or GPT‑family models) and uses tools heavily. User reports on Reddit cite Cursor bills in the $200–$300/month range for such users, even when starting from the $20 Pro seat, due to heavy token consumption on high-end models. On Pro/Pro+ : repeated large Sonnet/GPT-family sessions will regularly blow through the included budgets, driving substantial overage. On Ultra : the $400 agent usage bundle absorbs most of this load; examples in Cursor docs indicate effective monthly costs often settle in the $400–$500+ band once extra usage is counted for very heavy workloads. For small teams where several people behave like this, third‑party explainers suggest that it can be cheaper and easier to manage to move to Teams with centralized administration and higher-usage seats than to run multiple uncapped Ultra seats. When to move from Individual to Teams Learn Cursor and comparison pieces outline a few practical breakpoints: 1–3 developers : typically start on Individual Pro . Lock routing to conservative modes and monitor the dashboard for a month. 4–10 developers : a Teams setup at $40/user with centralized controls is often presented as safer than many separate Pro seats where some developers overshoot. Larger orgs : move to Enterprise when SSO, SCIM, audit logs and strict restrictions on models/MCPs are requirements. Hidden costs that drive Cursor bills up Cursor’s public pricing focuses on seat fees and bundled credits. The real volatility comes from usage patterns that grow token counts without appearing as “one big request”. Long contexts and large refactors The difference between asking an agent to edit 200 lines vs 2,000 lines is roughly an order-of-magnitude change in tokens. Learn Cursor’s guide emphasises that long-context edits, full-file analyses and repo-wide operations consume the budget much faster than small prompts. Reddit users reporting hitting usage limits after a handful of Sonnet 4.x calls are typically including very large contexts in each request. Agents, tools and MCPs Agent workflows often involve: Reading files. Running searches. Calling tools or MCPs (Model Context Protocol plugins). Each of these can trigger additional model requests. From the user’s perspective it looks like a single “Fix this” operation; under the hood it may be several inferences, each billed at model API prices. Auto/Composer routing modes Cursor’s fast in-editor helpers (Auto, Composer) route through a Cursor Router across models. Third-party explainers describe three broad routing stances: Cost : biases towards cheaper models. Balance : mixes cheaper and more capable models. Intelligence : leans into frontier models. Choosing Balance or Intelligence for everyday work can raise the effective per-request cost significantly, even if the editor UI looks unchanged. Background agents and cloud tasks Background Agents and cloud-hosted workflows can continue executing and consuming tokens while a user is not directly interacting with the editor. Cursor bills these like any other agent usage, so a long-running background