Enterprise AI Economics

Cursor Pricing in 2026: Plus, Premium, Super and Ultra, Teams Seats and What Usage Really Costs

Cursor's price list changed shape in 2026. New customers buy it as part of The X Subscription: Free, Plus at $8, Premium at $30, Super at $100 and Ultra at $200 a month, with Teams seats at the same three paid tiers and Enterprise by quote. This guide records the plans, weekly usage pool, top-ups, third-party model charges, legacy Pro plans and team costs as Cursor documented them on 14 November 2026.

Cursor pricing starts at $0 for the Free plan, then $8 a month for Plus, $30 for Premium, $100 for Super and $200 for Ultra, with Teams seats at $30, $100 or $200 per user a month and Enterprise by quote (cursor.com, 14 November 2026). Each paid plan includes a weekly pool of usage for Cursor's own models. Claude, GPT and Gemini are billed separately at API list prices.

Anyone returning to Cursor’s pricing page after a few months will not recognise it. Cursor is now sold as part of The X Subscription, which the documentation describes as one subscription for Grok, Cursor and X. The familiar Pro, Pro+ and Teams Standard plans still exist, but only as legacy plans for people who already hold them. The unit of included usage has changed from a monthly budget to a weekly pool, and third-party models have moved from “included up to a limit” to “billed from the first request”.

We read Cursor’s pricing page, its Models and Pricing documentation, the team pricing page, the legacy-plan page and four help-centre articles on 14 November 2026, and every figure here comes from those pages on that date. For what Cursor does with your code, as opposed to what it charges, see our review of whether Cursor is safe for company code.

Cursor pricing plans in November 2026

Plan (cursor.com, US dollars before tax, verified 14 November 2026)Monthly priceAnnual priceWho it is forIncluded usageThird-party models
Free$0Not applicableTrying the editorLimited agent and Chat requestsNot available
Plus$8$80Light use; Cursor’s own models onlyThe base weekly poolNot available
Premium$30$300New agent users4x PlusAPI list price, from prepaid credit
Super$100$1,000Daily agent users15x PlusAPI list price, from prepaid credit
Ultra$200$2,000Several agents or automations at once50x PlusAPI list price, from prepaid credit
Teams$30, $100 or $200 per seatNot listedSelf-serve teamsMatches the seat’s tierAPI list price plus the Cursor Token Rate on eligible models
EnterpriseCustomCustomOrganisations needing invoicing, SCIM or pooled usagePooled across the organisationAPI list price plus the Cursor Token Rate on eligible models

What each step adds, in Cursor’s words:

  • Plus runs the agent on Cursor’s own models at fixed settings: Fast mode off, medium effort, and Grok 4.7 with its 256k context window. It has no Auto mode, cloud agents, automations, Bugbot, Origin code hosting, third-party models or own API keys.
  • Premium adds cloud agents and automations, code hosting on Origin, code review with Bugbot, and third-party models at API list price.
  • Super adds priority model access at peak times.
  • Ultra adds earliest access to new products and models.

The paid plans also carry Grok and X benefits (an X checkmark, fewer adverts, Grok chat and image generation). They are part of the bundle whether or not a developer wants them, and they do not change the coding allowance.

Is Cursor free?

Partly. The Free plan costs nothing and includes “limited” agent requests and “limited” Chat requests; Cursor gives no count. It is a trial tier: no cloud agents, no Bugbot, no third-party models and no way to add your own API key.

The cheapest paid plan, Plus at $8 a month, is cheaper than the old $20 Pro plan but narrower. It is restricted to Cursor’s first-party models, and Cursor’s own FAQ recommends it for “social creators with limited AI usage”, which tells you where it sits. A developer who wants Claude or GPT models inside Cursor needs Premium at $30 a month, plus either a prepaid balance or their own provider key.

Cursor Pro price: what happened to Pro, Pro+ and the old Teams seats

Cursor’s documentation groups everything sold before The X Subscription under “legacy Cursor plans”. They keep working as they are, and existing customers can still move between them.

Legacy plan (verified 14 November 2026)PriceClosest current plan, per Cursor
HobbyFreeFree
Start, India only₹649 a month, tax inclusivePlus at $8
Pro$20 a monthPremium at $30
Pro+$60 a monthSuper at $100
Ultra$200 a monthUltra at $200
Teams Standard$40 per user a monthTeams, Premium seat at $30
Teams Premium$120 per user a monthTeams, Super seat at $100

The two generations meter usage differently:

Legacy Cursor plansThe X Subscription
Included usageTwo monthly pools: Cursor Models and Other ModelsOne weekly pool for Cursor models, shared with Grok
Third-party modelsIncluded through the Other Models pool on Pro, Pro+, Ultra and TeamsNot included; billed at API list price from prepaid credit
Extra usageOn-demand usage, billed monthly in arrears at API ratesPrepaid top-ups, with optional Auto Top-up
Billing portalcursor.comgrok.com

Cursor says each paid plan on the new list includes at least twice as much coding usage with Cursor models as the legacy plan it replaces. The catch is the row above it: the included Claude and GPT allowance disappears. Switching is optional and, in Cursor’s word, permanent. A team that works mostly in Claude models should price both sides before anyone clicks Unify. New customers do not get the choice; they start on the new list.

Cursor usage limits: the weekly pool, top-ups and third-party models

The pool. Every paid plan includes one pool of usage for Cursor models: Grok 4.7, Grok 4.6, Grok 4.5 and Composer 2.5. It is shared across the agent in the editor, the CLI, cloud agents, Grok Bot and the Grok apps, and it refreshes weekly. Different models drain it at different rates, and unused usage does not roll over. Cursor expresses the pool only as multiples of Plus, so there is no published request or token count to plan against. Remaining usage and the next reset date appear in editor settings and in the Grok dashboard.

When the pool is empty. You wait for the weekly reset, upgrade, or keep working from prepaid credit. Cursor models beyond the pool are billed at these token rates:

Cursor model (per million tokens, verified 14 November 2026)InputCache readOutput
Grok 4.7$2$0.50$6
Grok 4.7 (Fast)$4$1$12
Grok 4.7 500k$4$1$12
Grok 4.7 500k (Fast)$6$1.50$18
Composer 2.5$0.50$0.20$2.50
Composer 2.5 (Fast)$3$0.50$15

Third-party models. Claude, GPT and Gemini are outside the pool. On Premium and above they are charged at the model’s API list price from the first request, paid from prepaid credit. Cursor’s list on the day showed, per million input and output tokens, Claude Sonnet 5.5 at $2 and $10, Claude Opus 5.5 at $4 and $20, Claude Fable 5.2 at $8 and $40, GPT-5.6 Terra at $2 and $12, GPT-5.6 Sol at $4 and $20, and Gemini 4 Argon at $2 and $10.

Top-ups. Credit is bought in advance, manually or through Auto Top-up, which is off until you enable it. Each top-up stays available until used or until it expires, currently 365 days after purchase. A monthly additional usage limit caps paid usage even when credit remains. Cursor warns that enforcement is not instant, so usage can briefly exceed a limit.

Auto. The classic Auto mode is now called Cost mode and bills as a Cursor-model request from the included pool, whichever model serves it. On Teams and Enterprise with Cursor Router switched on, the Balance and Intelligence modes bill at the routed model’s list price, so a route to a third-party model is paid usage. Subagents can also call a named third-party model while the picker still shows Auto.

Cursor Ultra, Super and the long-context modes

Ultra at $200 a month buys the largest pool, fifty times Plus and 12.5 times Premium, and earliest access to new models. Super at $100 sits at fifteen times Plus. Cursor recommends Super for daily agent users and Ultra for people running several agents or automations.

Three settings act as cost multipliers inside any plan:

  • Fast variants cost two to six times the standard rate. Composer 2.5 goes from $0.50 and $2.50 per million input and output tokens to $3 and $15 in Fast mode.
  • The 500k context variant of Grok 4.7 doubles the input and output price against the 256k default.
  • Max Mode no longer applies to current plans. Cursor’s help page says Max Mode is available only on legacy request-based plans, where it is billed at the model’s API rate plus 20%.

Ultra does not include third-party models either. A heavy Claude user on Ultra pays $200 a month for a very large Grok and Composer pool and then pays Anthropic’s list price on top.

Cursor Teams pricing and Cursor Enterprise pricing

Teams is priced per seat, and each seat is Premium ($30), Super ($100) or Ultra ($200) per user a month, with the same weekly pool as the matching individual plan. One team can mix tiers, and there is a free seat type with no team allowance. Cursor bills per active paid seat: adding a member mid-cycle creates a pro-rated charge, upgrades apply at once, and downgrades apply at the end of the period. Weekly pools belong to each seat and do not transfer between members.

What Teams adds over individual plans: central billing and administration with an Admin API, usage analytics, a team marketplace for internal rules, skills and plugins, team-wide privacy mode enforcement, custom Chat data retention and SAML or OIDC single sign-on.

Usage beyond a seat’s pool, and all third-party model usage, is paid from one prepaid balance the whole team shares. Admins set a team-wide monthly limit plus per-member defaults and overrides.

The Cursor Token Rate. On Teams and Enterprise, eligible third-party model requests carry an extra $0.25 per million tokens, counted on input, output and cached tokens. Cursor models and Cost mode requests are exempt, and so are third-party models whose cache-read price is below $0.10 per million tokens on every pricing tier. The rate also applies to requests made with your own API key.

Enterprise is custom-priced through sales. Cursor’s comparison lists what it adds: invoice and purchase-order billing, SCIM seat management, granular and group-level spend controls, controls over auto-run, browser and network access, repository, model and MCP access controls, audit logs and service accounts, and priority support. Enterprise can also use pooled usage: the organisation commits to a total amount for the contract period and every member draws from it. Cursor publishes no Enterprise figure, and we do not estimate one.

Cursor cost for 10, 50 and 200 developers

List prices, twelve monthly payments, no tax, no top-ups. Cursor does not list an annual price for Teams seats.

Seats (Teams list, verified 14 November 2026)Per developer per year10 developers50 developers200 developers
All Premium seats12 × $30 = $360$3,600$18,000$72,000
All Super seats12 × $100 = $1,200$12,000$60,000$240,000
All Ultra seats12 × $200 = $2,400$24,000$120,000$480,000
Four Premium seats to one SuperMixed8 × $360 + 2 × $1,200 = $5,28040 × $360 + 10 × $1,200 = $26,400160 × $360 + 40 × $1,200 = $105,600
Legacy Teams Standard, existing teams only12 × $40 = $480$4,800$24,000$96,000
EnterpriseQuoteQuoteQuoteQuote

These are floors. The seat price covers Cursor’s own models up to the weekly pool and nothing else.

The cost lines the seat price leaves out

  • Third-party models, from the first token. Every Claude, GPT or Gemini request is paid from the prepaid balance at list price. For a team that defaults to Claude, this line can exceed the seats.
  • The Cursor Token Rate. As an illustration, a developer who pushes 50 million tokens a month through eligible third-party models adds 50 × $0.25 = $12.50 a month, or $150 a year, before the model’s own price. Fifty such developers add $7,500 a year.
  • Fast and long-context variants, at two to six times the standard rates.
  • Router modes. Balance and Intelligence can send a request to a paid third-party model without the developer choosing one.
  • Seats that sit idle. Pools are per seat and do not transfer, so a Super seat held by an occasional user is $1,200 a year of unused allowance.
  • Expiring credit. Top-ups lapse 365 days after purchase.
  • Bundle value you may not want. Part of each price pays for Grok and X benefits.

The equivalent arithmetic for three other tools is in our guides to Claude Code’s plans and limits, how Codex is billed and GitHub Copilot’s AI credits.

Bring your own API key, and local models in Cursor

Cursor accepts your own keys for five providers: OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock. On individual plans from Premium upward, the provider bills you directly and those requests do not touch included usage or prepaid credit. On Teams and Enterprise the Cursor Token Rate still applies to eligible models. Plus has no own-key option.

The limits, as Cursor documents them:

  • Chat models only. Tab completion keeps using Cursor’s built-in models.
  • Requests still pass through Cursor. The key is sent to Cursor’s backend with every request, because all requests are routed through its servers for final prompt building. Cursor says the key is not stored.
  • Zero Data Retention does not apply to requests made with your own key; the provider’s policy does.
  • No local provider is listed. The bring-your-own-key page names the five cloud providers above and nothing for Ollama, LM Studio or another server on your machine.

Taken together, Cursor is a cloud-routed editor. Even with your own key, prompts travel through Cursor’s servers, so it cannot be the client for an offline or air-gapped model. Developers who want a local model in the loop use a different harness.

When local or self-hosted models are cheaper than Cursor, and when they are not

Cursor’s price has two parts: a seat that covers its own models, and metered charges for everyone else’s. A self-hosted model replaces the metered part with hardware, power and somebody’s time.

Self-hosting tends to win when:

  • Most of the bill is third-party tokens. If prepaid top-ups regularly exceed the seat price, part of that work can move to an open-weight model on hardware you control.
  • A shared server is kept busy. One GPU server used by many developers through the day spreads its cost; one used by two people does not.
  • You already own suitable hardware, or the code is not allowed to leave your network at all.

Cursor tends to win when:

  • Developers are content with the included models. A Premium seat at $360 a year with no top-ups is cheaper than almost any hardware plan.
  • The team is small or usage is uneven. Weekly pools absorb quiet weeks at no extra cost; idle GPUs do not.
  • You need frontier-model quality on hard problems. Open-weight coding models are improving, but they are not interchangeable with the best hosted ones, and retries cost developer time.
  • Nobody can operate a model server.

We quote no hardware prices, because they depend on what you already run. The method is in our guide to on-premises AI platform cost and TCO and the comparison of flat and token-based pricing models. For candidates, start with the local coding models we compare by licence, context length and memory and the on-prem agentic coding tools roundup.

How VDF AI fits

VDF AI does not run, resell, host or integrate with Cursor, and it has no connection to The X Subscription. The comparison that matters for an organisation is less about the seat price than about control: where the model runs, which models developers may use, who can reach which repository, and what is recorded.

VDF Code is VDF AI’s coding assistant for teams that need those answers on their own infrastructure. It provides inline completions, chat in the IDE, edit-mode refactors and pull request review, deployed in your VPC, your data centre or fully air-gapped, with extensions for VS Code, JetBrains IDEs, Neovim and Visual Studio. Models are the ones you approve, policies are version-controlled, and activity is logged for audit. Licensing on-premises is per seat with no token meter; details are on the pricing page.

Sources

Cursor’s pricing page, documentation and help centre, as they read on 14 November 2026.


Pricing an AI editor for a whole engineering team? Compare it with VDF Code on your own infrastructure, or contact us to talk through a deployment.

Frequently asked questions

How much does Cursor cost per month?

On 14 November 2026 Cursor's pricing page listed Free at $0, Plus at $8, Premium at $30, Super at $100 and Ultra at $200 a month, before tax. Annual billing is $80, $300, $1,000 and $2,000 a year for the four paid plans. Teams seats cost $30, $100 or $200 per user a month depending on tier, and Enterprise is custom. Claude, GPT and Gemini models are not included in any of these prices and are billed separately by usage.

Is Cursor free?

There is a Free plan at $0 a month with limited agent requests and limited Chat requests, enough to try the editor. It does not include cloud agents, Bugbot code review, third-party models or your own API keys. Cursor does not publish a number for the free allowance. Customers on the older price list have the equivalent Hobby plan. Anything beyond a trial needs Plus at $8 a month or, for Claude and GPT models, Premium at $30.

What is the Cursor Pro price now?

Pro at $20 a month is a legacy plan. Cursor's documentation says the plans it sold before The X Subscription (Hobby, Start, Pro, Pro+ at $60, Ultra at $200 and Teams Standard and Premium seats) keep working for existing customers, while new customers start on the new list. The closest current plan to Pro is Premium at $30 a month. Switching is optional and permanent, and it trades the included third-party model allowance for a larger pool of Cursor-model usage.

How much is Cursor for teams?

A Teams seat on the current price list is Premium at $30, Super at $100 or Ultra at $200 per user a month, with the same weekly usage as the matching individual plan, and tiers can be mixed. Teams created earlier keep Standard seats at $40 and Premium seats at $120. Third-party models are charged to a shared prepaid balance at API list prices plus a Cursor Token Rate of $0.25 per million tokens on eligible models. Enterprise pricing is by quote.

How do Cursor usage limits work?

Each paid plan includes one pool of usage for Cursor's own models (Grok 4.7, Grok 4.6, Grok 4.5 and Composer 2.5), shared with the Grok apps and refreshed weekly. Premium has four times the Plus pool, Super fifteen times and Ultra fifty times. When the pool is empty you wait for the reset, upgrade, or pay from prepaid credit at the model's token rate. Unused usage does not roll over, and Cursor publishes the pool as multiples, not as request counts.

Can I use my own API key or a local model in Cursor?

Own keys are supported for OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock on Premium and above; the provider bills you, and on individual plans those requests do not draw from included usage. On Teams and Enterprise the $0.25 per million token rate still applies to eligible models. Cursor's documentation lists no local provider, says custom keys work with chat models only, and says every request is routed through Cursor's servers, so the editor is not an offline client.

Filed under
AI coding assistantsAI platform pricingAI platform TCOAI procurementlocal LLMon-premises AI
AI Cost & Energy

Calculate your AI infrastructure savings

Model the cost and energy impact of running AI on-prem versus cloud-only — then see the benchmark data behind the numbers.

Or start free — no credit card →

Keep reading