As of October 2026, Cursor's plans for new customers are Free, Plus at $8 a month, Premium at $30, Super at $100 and Ultra at $200, with Teams seats from $30 per user per month and custom Enterprise pricing. Prices exclude tax. The plans are sold as part of The X Subscription, launched on October 12, 2026, which bundles Cursor with Grok and X Premium. Cursor is now owned by SpaceX.
The headline prices hide the part that decides your real bill. Every paid plan includes a weekly usage pool for Cursor's own models, Grok and Composer, shared with Grok. Third-party models such as Claude and GPT are not in that pool: on Premium and above they are charged at API list price from prepaid credit, and Plus doesn't offer them at all. If you subscribed before October 12, your legacy plan (Pro $20, Pro+ $60, Ultra $200, Teams $40 or $120 per seat) carries on unchanged unless you switch, and switching is permanent.
The current plans
This is the lineup on cursor.com/pricing and in xAI's X Subscription announcement:
Plan | Price | Included usage | Models | Notable extras |
|---|
Free | $0 | Small starter allowance; limited agent and chat requests | Limited | Good for evaluating the editor |
Plus | $8/month | Shared weekly pool (the baseline, "1x") | Grok models only | Entry plan; no third-party models |
Premium | $30/month | 4x Plus usage | Latest Grok and Composer; third-party models billed separately | Cursor Pro benefits, Bugbot |
Super | $100/month | 15x Plus usage | Same as Premium | Priority model access at peak times |
Ultra | $200/month | 50x Plus usage | Same as Premium | Earliest access to new products and models |
Teams | From $30/user/month | Pooled, 4x to 50x Plus depending on seat | Third-party models at API list price | SSO (SAML/OIDC), usage analytics, admin controls, Bugbot |
Enterprise | Custom | Negotiated | Negotiated | Invoice billing, SCIM, audit logs, granular spend controls |
Notice that the pricing page describes usage only as multiples of Plus, never as a number of requests or dollars. The included pool covers Cursor's own models: Grok 4.7, 4.6 and 4.5, and Composer 2.5.
How the usage pool actually works
"How many requests do I get?" no longer has a simple answer. Usage is measured by the model compute you consume, and it drains at different speeds depending on what you run.
Each paid plan gets one weekly pool for Cursor models, and Cursor, Grok Bot and the Grok apps all draw from it. It refreshes every week, the next reset date appears under Usage at grok.com/dashboard, and unused allowance does not roll over. Claude, GPT and other third-party models sit outside the pool entirely. On Premium and above they are billed at the provider's API list price from your prepaid credit, starting with the first request.
Four things decide how fast the pool empties. The model matters most, since larger models and long reasoning cost more per request. Context size is next: agent runs that read many files send more tokens. Subagents are the trap, because Cursor's docs warn that they can run a named third-party model even when the picker shows Auto, Grok or Composer, and those requests bill as third-party usage. Auto mode, by contrast, always counts as a Cursor-model request against the pool when it is in Cost mode, whichever model serves it.
Composer 2.5 requests carry no Cursor Token Rate on any plan, which makes Composer the cheapest way to use the pool. Max Mode isn't included in the current plans.
What happens when you run out
When the weekly pool is empty on The X Subscription, Cursor gives you three options: spend prepaid credit, wait for the weekly reset, or upgrade to a plan with a bigger pool. Prepaid top-ups are charged at API rates and last until used or 365 days after purchase; they don't reset with the pool. Optional Auto Top-up buys more credit automatically when you run low, and a monthly additional usage limit caps how much extra you can spend.
You run an agent task
↓
Cursor model (Grok/Composer)? → draws from the weekly pool
Third-party model (Claude/GPT)? → charged to prepaid credit at API list price
↓
Weekly pool empty?
↓
Prepaid credit available → keeps working at API rates
No credit → wait for reset, top up, or upgrade
Legacy plans work differently. Usage is split into two monthly pools, and at the limit you can turn on on-demand (pay-as-you-go) usage, billed in arrears, or upgrade.
Should you leave a legacy plan?
If you subscribed before The X Subscription, you are on a legacy plan, and according to Cursor's legacy plans documentation it keeps the same price and features unless you change or cancel it. Cursor maps each one to a new plan:
Legacy plan | Price | Closest new plan |
|---|
Hobby | Free | Free |
Start (India only) | ₹649/month | Plus ($8) |
Pro | $20/month | Premium ($30) |
Pro+ | $60/month | Super ($100) |
Ultra | $200/month | Ultra ($200) |
Teams Standard | $40/user/month | Teams Premium seat ($30) |
Teams Premium | $120/user/month | Teams Super seat ($100) |
Cursor says each new paid plan includes at least twice the Cursor-model coding usage of the legacy plan it replaces, plus Grok and X benefits. The catch is third-party models. Legacy Pro and above include an "Other Models" pool for Claude, GPT and others. The new plans don't, so you pay for those from prepaid credit.
That makes the decision fairly mechanical. If most of your Cursor usage is Claude or GPT, stay on legacy: the included Other Models pool is worth more to you than extra Grok usage. If you mostly use Composer, Auto or Grok, or you actually want Grok and X Premium, switching makes sense. Either way, take it seriously. Switching can't be undone, even by Support, and it also unifies your Cursor and Grok accounts and moves billing to grok.com.
How Cursor compares on cost
Each of these tools meters usage differently, so the sticker price is only half the comparison. Windsurf, note, was renamed Devin Desktop by Cognition on June 2, 2026, with plans and pricing carried over at the time.
Tool | Free | Entry paid | Mid tier | Top individual | Team | How usage is metered |
|---|
Cursor | Yes | Plus $8 (Grok only) | Premium $30 | Ultra $200 | From $30/user | Weekly pool for Cursor models; third-party models at API list price from prepaid credit |
GitHub Copilot | Yes | Pro $10 | Pro+ $39 | Max $100 | Business $19/user, Enterprise $39/user | Monthly GitHub AI Credits ($0.01 each), metered by tokens; completions don't use credits |
Claude Code | No | Pro $20 ($17/month annual) | Max 5x $100 | Max 20x $200 | Team $25/seat ($20 annual); Premium seat $125 ($100 annual) | Five-hour and weekly limits shared with Claude chat |
Devin Desktop (formerly Windsurf) | Yes | Pro $20 | — | Max $200 | $80/month per team plus $40 per full seat | Allowance refreshes daily and weekly; extra usage at API pricing |
If you want Claude or GPT models as cheaply as possible, GitHub Copilot is the answer. Pro at $10 includes 1,500 AI credits a month (1,000 base plus a 500-credit flex allotment), and inline completions don't consume credits. GitHub moved Copilot to this credit model on June 1, 2026, replacing premium requests. Be aware that when credits run out, Copilot no longer falls back to a cheaper model; usage stops unless additional spending is allowed.
The cheapest entry overall is Cursor Plus at $8, but only if Grok models are enough for your work. For heavy agent use on Claude models, Claude Code Max caps your spend through usage limits rather than per-token charges; Claude Code for .NET developers shows how it fits a .NET workflow.
And if you want Cursor with Claude or GPT, budget the plan price plus API-rate credit. A $30 Premium plan can cost a lot more than $30 in a month of heavy Claude usage.
Which Cursor plan to pick
If you are trying Cursor for the first time, start on Free and move to Plus once you know Grok works for your stack. A professional developer using agents daily belongs on Premium at $30. Super at $100 is for people running agents most of the day or hitting the weekly limit early, and Ultra at $200 for those running many parallel agents who want early model access. Companies that need SSO, central billing and analytics want Teams, or Enterprise for SCIM and audit logs. And if you are an existing Pro user who relies on Claude or GPT, you are probably better off staying on legacy Pro.
Whatever you pick, start one tier lower than you think you need. Watch usage for two weeks, and upgrade only if you consistently hit the limit before the weekly reset.
Keeping the bill down
- Default to Composer or Auto. Both draw from the included pool, and Composer 2.5 carries no Cursor Token Rate.
- Choose third-party models deliberately: Claude or GPT for hard problems, not for renaming a variable.
- Set a monthly additional usage limit, and leave Auto Top-up off until you know your pattern.
- Check the usage dashboard weekly at grok.com/dashboard, or the Spending tab on legacy plans.
- Keep context lean. Point the agent at the right files, start new chats for new tasks, and don't attach whole folders.
- Watch subagents, which can call third-party models that bill outside the pool.
- Bring your own key where it helps. On individual plans, requests with your own API key don't draw from included usage or prepaid credit; you pay the provider directly. On Teams and Enterprise, a $0.25 per million token Cursor Token Rate still applies to models that carry it.
Why Cursor stopped counting requests
Today's model traces back to a pricing change that went badly in mid-2025. Until then, Pro cost $20 a month and was capped at 500 requests, even though different models cost very different amounts to run. On June 16, 2025, Cursor moved Pro from request limits to compute-based limits and introduced the $200 Ultra plan, with messaging that suggested "unlimited" usage. In practice, the unlimited part applied only to Auto, which wasn't made clear, and many users hit limits quickly or saw unexpected charges.
On July 4, 2025, Cursor published an apology saying the changes "were not communicated clearly, and we take full responsibility", and offered refunds for unexpected usage charges between June 16 and July 4. C# Corner covered the episode in Cursor Addresses Pricing Confusion With Apology, Refunds and New Transparency Measures. After the fix, Pro included unlimited Tab and Auto, $20 of frontier model usage per month at API pricing, and the option to buy more at cost.
The underlying logic has held through every change since: newer models consume far more tokens per request, so flat request counts stopped making sense, and Cursor, GitHub Copilot and most competitors now meter by compute. The practical consequence for you is simple. Don't compare these tools on plan price alone; compare the plan plus what your preferred models will cost on top of it.
cursor pricingcursor planscursor premium plancursor ultracursor usage limitscursor x subscriptioncursor legacy planscursor vs copilot pricingcursor vs claude code costwindsurf pricing
Join the conversation! Your thoughts help the community grow.