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 price | Annual price | Who it is for | Included usage | Third-party models |
|---|---|---|---|---|---|
| Free | $0 | Not applicable | Trying the editor | Limited agent and Chat requests | Not available |
| Plus | $8 | $80 | Light use; Cursor’s own models only | The base weekly pool | Not available |
| Premium | $30 | $300 | New agent users | 4x Plus | API list price, from prepaid credit |
| Super | $100 | $1,000 | Daily agent users | 15x Plus | API list price, from prepaid credit |
| Ultra | $200 | $2,000 | Several agents or automations at once | 50x Plus | API list price, from prepaid credit |
| Teams | $30, $100 or $200 per seat | Not listed | Self-serve teams | Matches the seat’s tier | API list price plus the Cursor Token Rate on eligible models |
| Enterprise | Custom | Custom | Organisations needing invoicing, SCIM or pooled usage | Pooled across the organisation | API 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) | Price | Closest current plan, per Cursor |
|---|---|---|
| Hobby | Free | Free |
| Start, India only | ₹649 a month, tax inclusive | Plus at $8 |
| Pro | $20 a month | Premium at $30 |
| Pro+ | $60 a month | Super at $100 |
| Ultra | $200 a month | Ultra at $200 |
| Teams Standard | $40 per user a month | Teams, Premium seat at $30 |
| Teams Premium | $120 per user a month | Teams, Super seat at $100 |
The two generations meter usage differently:
| Legacy Cursor plans | The X Subscription | |
|---|---|---|
| Included usage | Two monthly pools: Cursor Models and Other Models | One weekly pool for Cursor models, shared with Grok |
| Third-party models | Included through the Other Models pool on Pro, Pro+, Ultra and Teams | Not included; billed at API list price from prepaid credit |
| Extra usage | On-demand usage, billed monthly in arrears at API rates | Prepaid top-ups, with optional Auto Top-up |
| Billing portal | cursor.com | grok.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) | Input | Cache read | Output |
|---|---|---|---|
| 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 year | 10 developers | 50 developers | 200 developers |
|---|---|---|---|---|
| All Premium seats | 12 × $30 = $360 | $3,600 | $18,000 | $72,000 |
| All Super seats | 12 × $100 = $1,200 | $12,000 | $60,000 | $240,000 |
| All Ultra seats | 12 × $200 = $2,400 | $24,000 | $120,000 | $480,000 |
| Four Premium seats to one Super | Mixed | 8 × $360 + 2 × $1,200 = $5,280 | 40 × $360 + 10 × $1,200 = $26,400 | 160 × $360 + 40 × $1,200 = $105,600 |
| Legacy Teams Standard, existing teams only | 12 × $40 = $480 | $4,800 | $24,000 | $96,000 |
| Enterprise | Quote | Quote | Quote | Quote |
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.
- Cursor: pricing
- Cursor documentation: Models and Pricing
- Cursor documentation: team pricing
- Cursor documentation: legacy Cursor plans
- Cursor documentation: pooled usage on Enterprise
- Cursor help: usage and limits
- Cursor help: usage-based charges and top-ups
- Cursor help: bring your own API key
- Cursor help: Max Mode on legacy plans
- Cursor help: what The X Subscription is
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.