TL;DR: New Cursor subscriptions start at Free, with paid Plus at $8/month and Premium at $30/month. Existing Pro customers can keep their legacy plan. If you mainly use third-party models, compare their separate usage bill before switching: a larger included pool on a new plan does not include those models.

	New Plus	New Premium	Existing legacy Pro
Monthly base price	$8	$30	$20
Best fit	Light use of included models	Cloud workflows and optional third-party models	Existing users who value their current allowance
Third-party models	Not available	Separately billed	Other Models allowance included
Main trade-off	Restricted feature set	Subscription is only part of the bill	Legacy eligibility, not a new-customer option

Honest take: Keep legacy Pro if its included third-party allowance is doing useful work; choose Premium for a new account that needs third-party models, and upgrade further only after measuring included-model usage.

Which Cursor prices are current on October 31?

Cursor’s public pricing page currently lists Free at $0, Plus at $8, Premium at $30, Super at $100, and Ultra at $200 per month, excluding taxes and applicable fees. This is a dated reading of the official pages, not a report from a paid test account.

Cursor’s Models & Pricing documentation identifies these as part of The X Subscription. It lists annual billing at $80 for Plus, $300 for Premium, $1,000 for Super, and $2,000 for Ultra. Annual billing is a separate commitment; do not compare an annual effective monthly amount with a cancellable monthly charge without labeling the difference.

New individual plan	Monthly billing	Annual billing	Saving versus 12 monthly payments
Plus	$8/month	$80/year	$16/year
Premium	$30/month	$300/year	$60/year
Super	$100/month	$1,000/year	$200/year
Ultra	$200/month	$2,000/year	$400/year

The savings column is arithmetic from those published prices, not a promotional offer we tested. It excludes usage, tax, and future price changes. For example, Premium’s monthly route is 12 × $30 = $360; the annual route is $300.

An annual commitment makes sense only after you know the workflow fits. The amount saved on the subscription can be smaller than an unexamined usage bill, particularly when an agent repeatedly sends long repository context.

Do existing Pro users have to switch?

Existing Cursor customers do not automatically lose legacy Pro. The legacy-plan documentation says current plans continue unless changed or cancelled, and identifies Pro at $20/month, Pro+ at $60/month, and legacy Ultra at $200/month. The same name “Ultra” can therefore appear in different billing systems.

The essential distinction is the allowance. Legacy paid plans use monthly Cursor Models and Other Models pools; the new subscription uses a weekly pool for Cursor models shared with Grok. Third-party usage on the new subscription is billed separately. A label-to-label comparison misses that change.

Our earlier Cursor cost comparison is useful historical context, but use the current account’s plan name and dashboard when making a purchase decision. An old article saying “Pro costs $20” and a new pricing page saying “Premium costs $30” can both be accurate for different customers.

Before comparing alternatives, record your actual base invoice and which pool your usual model consumes. Then ask a narrower question: what would the same completed tasks have cost under the alternative plan? That is more useful than asking whether one plan advertises more usage.

What does the shared weekly pool include?

The new pool covers Cursor models and is shared across Cursor and Grok usage. The subscription overview describes a common workspace and bill. Using another product in the bundle can therefore matter to the remaining allowance you see while coding.

The pricing page advertises Premium as 4 times the Plus usage, Super as 15 times, and Ultra as 50 times. Those ratios do not give a fixed number of coding tasks. Model choice, context, and the work performed by an agent change consumption. We cannot turn them into “100 requests per day” without a documented request definition and a measured workload.

This matters when comparing a short chat answer with a background task that reads files, invokes tools, and retries a test. Both might begin with one message from you. They are not necessarily comparable units of usage.

For a trial budget, keep a brief task diary alongside the dashboard: task type, chosen model, whether it completed, and whether you had to redo the work. The diary is your evaluation method, not a new billing unit. A cheap attempt that produces an unusable patch is not automatically better value than a more expensive successful one.

Does Premium include Claude or other third-party models?

Premium allows third-party models, but their model usage is separately billed from the first request. Plus does not offer them. This distinction is explicit in Cursor’s usage-based charges documentation.

On the new subscription, additional usage is paid with prepaid credit. Auto Top-up is optional and initially off. Buying credit and consuming credit are different events: the purchase is a cash charge, while model requests use the balance. Keep both in your budget worksheet if you need to reconcile invoices with work completed during a month.

The practical consequence is simple. Upgrading from Premium to Super can increase your included pool, but it does not turn a third-party model into an included one. If that model is where your spending occurs, look at its usage first instead of assuming a larger subscription solves the problem.

A team should also distinguish experimentation from routine development. Give a new model a bounded set of representative tasks, review the results, and only then make it a default. Otherwise a plan comparison becomes a comparison between different workloads rather than between prices.

How can you calculate a realistic monthly budget?

Use your subscription charge plus additional model consumption, then account separately for taxes and other charges. The following hypothetical example uses assumed additional spend, not a measured Cursor bill or a prediction of what a typical developer uses.

# USD; illustrative monthly budget, before tax.
plans = {"Premium": 30, "Super": 100, "Ultra": 200}
additional_model_spend = 40
for plan, base in plans.items():
    print(f"{plan}: ${base + additional_model_spend}/month")

Expected output:

Premium: $70/month
Super: $140/month
Ultra: $240/month

The example intentionally holds additional spending constant. It isolates the subscription difference: if the extra $40 is third-party usage, a bigger included-model pool does not erase it. Replace that input with the cost of your own workload before deciding anything.

For a legacy comparison, use the extra amount after your existing allowance, not the gross value of every request. Suppose, purely as a budgeting scenario, your current $20 Pro bill has no overage, while the equivalent new setup would require Premium plus $40 of third-party consumption. The comparison is $20 versus $70, a $50 monthly difference. That scenario is not a claim about the size of Pro’s allowance.

If you switch models as part of the plan change, repeat the task evaluation as well as the arithmetic. A lower bill can come from accepting worse answers, while a higher bill can come from requesting longer outputs rather than receiving better code. Keep those explanations separate.

What changes for teams and BYOK users?

Teams should check the Cursor Token Rate, not assume individual-account economics apply. Cursor documents a $0.25-per-million-token rate on eligible third-party requests for Teams and Enterprise. It covers input, output, and cached tokens; the official page lists excluded models. Individual plans do not pay this rate.

For an eligible request mix totaling 20 million tokens, the rate alone would be 20 × $0.25 = $5, before the model’s own cost. This is a calculation, not an example customer invoice. Apply it only to eligible tokens and check the exclusion list instead of adding it to every request indiscriminately.

Bringing your own API key changes who bills for the model, but it does not make usage free. The BYOK documentation says individual own-key requests are billed by the provider and do not consume the included allowance or prepaid credit. Eligible team requests can still carry the Cursor Token Rate.

That same documentation limits custom keys to chat models; Tab completion continues using built-in models. It also says requests pass through Cursor’s backend for final prompt construction. BYOK is therefore not an offline mode. If your requirement is local inference, start with a deliberately local stack and the hardware guidance at RunAIHome, rather than treating a billing setting as a privacy architecture.

How do you stop unexpected additional spending?

Cursor’s spend-limit instructions distinguish a monthly additional usage limit on the new subscription from an on-demand limit on legacy plans. The new limit applies to paid usage consumed, not credit purchased. Adding credit does not raise that limit.

Open the billing dashboard for the correct subscription, inspect Auto Top-up, and set a deliberate additional-usage limit if you intend to use paid extras. On a legacy account, inspect whether on-demand usage is enabled. Do not change either setting merely to clear an unexplained error; first determine which allowance or limit stopped the request.

Symptom	Check first	Avoid this assumption
Included usage remains, but a third-party request needs credit	Model category and prepaid balance	Every model shares one included allowance
Credit remains, but paid requests pause	Monthly additional usage limit	Buying another top-up must fix it
Provider rejects an own-key request	Provider key, access, and billing status	Upgrading the Cursor subscription repairs the key
A legacy account’s bill exceeds the base price	On-demand usage and team settings	The current public pricing table describes that account

The overage documentation notes that enforcement is not instantaneous. Treat a spend limit as a billing control, not a promise that every in-flight request ends at an exact cent boundary. For sensitive budgets, monitor the account rather than relying only on a notification after a long session.

What should you check before a permanent switch?

The subscription overview says switching is optional and permanent. This is the reason to do the comparison before checkout, not after finding that a favored model no longer draws from the same allowance.

Save the current plan details, note the billing cycle, and compare a representative period of usage. Separate subscription benefits you already pay for elsewhere from benefits you would not otherwise buy. A bundle can reduce total spending if it replaces existing purchases; unused extras have no value in your development budget.

Check who owns the account and billing decision. A developer using an employer-managed workspace should compare the team plan, not purchase a personal subscription to work around a team limit. The resulting split can make costs harder to track without fixing the original workflow.

Finally, review the actual checkout terms for your account. We verified public documentation, not your eligibility, regional checkout, refund amount, or invoice. Those account-specific details are the final inputs to the decision.

Verdict: which Cursor plan should you choose?

For a new customer, Plus is reasonable only if its restricted included-model workflow is enough. Premium is the entry point for the broader feature set and third-party model access, with an additional budget for that usage. Super and Ultra are choices for demonstrably higher included-model consumption, not automatic upgrades for anyone who writes code all day.

Existing legacy users have a different default: keep the working plan while comparing actual costs. A lower advertised price elsewhere, a larger usage multiplier, or the same “Ultra” label is insufficient evidence to switch.

The decision should end with a number you can explain: subscription, additional consumption, and any team or provider charges. If you cannot account for each part, collect one more billing period of evidence before making a permanent change.

Sources

• Current plan prices — Cursor
• Models, annual pricing, and included usage — Cursor
• Legacy Cursor plans
• The X Subscription and switching — Cursor
• Usage-based charges and top-ups — Cursor
• Spend limits — Cursor
• Bring your own API key — Cursor
• Cursor Token Rate and excluded models

Last updated October 31, 2026. Prices exclude tax unless stated otherwise. Verify your account’s plan and checkout terms before purchasing or switching.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe