Cursor vs Copilot 2026: The Real Cost After Cursor Moved to the X Subscription

TL;DR

The Cursor vs Copilot price question has a new answer. Cursor no longer sells its $20 Pro plan on its pricing page: since October 12, 2026 it’s sold through the X Subscription, where Premium costs $30 a month and covers Grok and Cursor’s own Composer models, while Claude, GPT and Gemini are billed on top at API list price. GitHub Copilot went the other way on June 1 and now includes more model usage than you pay for: Pro is $10 with $15 of AI credits, Pro+ is $39 with $70, Max is $100 with $200. If you want Claude or GPT in your editor, Copilot is cheaper at every usage level I modeled, by $20 to $130 a month. Cursor’s price case now rests on its weekly Grok and Composer pool, which costs nothing extra once you’ve paid for the plan.

Pricing, plan contents and model rates last verified: October 16, 2026.

The Sticker Price Changed Twice This Year

When this comparison first ran in the spring, the headline was $10 against $20, and the argument was that heavy agent users blew past both. Copilot capped you at 300 “premium requests” on Pro, and Cursor Pro drained a $20 credit pool. Both of those systems are gone now.

GitHub moved first. On June 1, 2026 every Copilot plan switched from request counts to AI credits, at $0.01 per credit, drawn down at per-token rates that depend on the model. Code completions and next-edit suggestions stay free and unlimited on paid plans. The part most comparisons skip is that each paid plan now includes more usage than its price: the Copilot plans page lists $15 of credits on the $10 Pro plan, $70 on the $39 Pro+ plan, and $200 on the new $100 Max plan.

Cursor’s change came on October 12. Its pricing page now sells “The X Subscription”, a bundle of Cursor, Grok and X Premium, with the line “Subscriptions are only sold directly through X Subscription Corp.” The tiers are Plus at $8, Premium at $30, Super at $100 and Ultra at $200. Each comes with a weekly usage pool that refreshes every week, covering Cursor’s own models only. The page is blunt about the rest: “Third Party model usage in Cursor is not included in the monthly prices shown and must be purchased separately.”

That flips the comparison. Copilot’s subscription now subsidizes Claude and GPT usage. Cursor’s subscription subsidizes Grok and Composer, and treats Claude and GPT as a pass-through cost.

What Each Plan Actually Includes

Cursor’s pricing docs spell out which models sit in the weekly pool: Grok 4.7, Grok 4.6, Grok 4.5 and Composer 2.5, Cursor’s in-house coding model (the Composer 2 review covers where that line came from). The same pool is shared across Agent in the editor, the CLI, Cloud Agents and the Grok apps. Claude, GPT and Gemini are available on Premium and above “at the model’s API list price from the first request,” paid from prepaid credit that you top up manually or with Auto Top-up. When the weekly pool runs dry you can wait for the reset, keep going on prepaid credit, or upgrade, and the docs say requests are never downgraded in quality or speed.

Copilot’s per-token rates match Anthropic’s list prices. GitHub’s models and pricing page charges $2 input and $10 output per million tokens for Claude Sonnet 5.5 and $4 / $20 for Claude Opus 5.5, the same numbers on Anthropic’s own pricing page. So both tools charge list price for a Claude token. The difference is that Copilot hands you $5 to $100 of that usage free each month, and Cursor gives you none.

The Real Cost Formula, Worked Out

With list-price billing on both sides, the comparison becomes arithmetic. For a given monthly amount of Claude or GPT usage, measured in dollars at list price:

• Copilot: plan price, plus anything beyond the included credits (billed at $0.01 per credit once you set an additional-usage budget). Pick the cheapest of Pro, Pro+ and Max.
• Cursor: $30 for Premium (the cheapest tier with third-party models) plus the full usage amount. Higher tiers only enlarge the Grok and Composer pool, so they never lower the Claude bill.
• Teams: Copilot Business at $19 a seat with $19 of credits, against a Cursor Teams Premium seat at $30, which adds a Cursor Token Rate of $0.25 per million tokens on third-party requests.

To turn dollars into something tangible I used one illustrative Claude Sonnet 5.5 agent session: 300K fresh input tokens, 1.2M cache hits and 40K output tokens. That’s an assumption, chosen to resemble a mid-sized multi-file task where the agent re-reads context. Your own sessions will be bigger or smaller.

"""Monthly cost of Cursor vs GitHub Copilot for the same frontier-model usage."""

COPILOT = {"Pro": (10, 15), "Pro+": (39, 70), "Max": (100, 200)}  # price, included $
CURSOR_PREMIUM = 30
COPILOT_BUSINESS = (19, 19)
CURSOR_TOKEN_RATE = 0.25  # $/M tokens, Teams and Enterprise only

# One illustrative Claude Sonnet 5.5 agent session ($/M: in 2, cache hit 0.10, out 10)
FRESH_IN, CACHED_IN, OUT = 0.3, 1.2, 0.04  # millions of tokens
SESSION_USD = FRESH_IN * 2 + CACHED_IN * 0.10 + OUT * 10
SESSION_TOKENS = FRESH_IN + CACHED_IN + OUT


def copilot_best(usage):
    costs = {name: price + max(0, usage - incl) for name, (price, incl) in COPILOT.items()}
    name = min(costs, key=costs.get)
    return name, costs[name]


print(f"Illustrative session: {SESSION_TOKENS:.2f}M tokens, ${SESSION_USD:.2f} at list price\n")
print(f"{'Usage $/mo':>10} {'~sessions':>9} {'Copilot best':>18} {'Cursor Premium':>15} {'Gap':>7}")
for usage in (0, 15, 30, 50, 70, 100, 150, 200, 300):
    name, cop = copilot_best(usage)
    cur = CURSOR_PREMIUM + usage
    print(f"{usage:>10} {usage / SESSION_USD:>9.0f} {name + f' ${cop:.0f}':>18} {f'${cur:.0f}':>15} {f'${cur - cop:.0f}':>7}")

print("\nPer seat on a team (Copilot Business vs Cursor Teams Premium seat):")
for sessions in (10, 40, 80):
    usage = sessions * SESSION_USD
    price, incl = COPILOT_BUSINESS
    cop = price + max(0, usage - incl)
    cur = CURSOR_PREMIUM + usage + sessions * SESSION_TOKENS * CURSOR_TOKEN_RATE
    print(f"  {sessions:>3} sessions/mo: Copilot ${cop:7.2f}  Cursor ${cur:7.2f}  x10 seats: ${cop * 10:8.2f} vs ${cur * 10:8.2f}")

Running it on October 16 printed:

Illustrative session: 1.54M tokens, $1.12 at list price

Usage $/mo ~sessions       Copilot best  Cursor Premium     Gap
         0         0            Pro $10             $30     $20
        15        13            Pro $10             $45     $35
        30        27            Pro $25             $60     $35
        50        45           Pro+ $39             $80     $41
        70        62           Pro+ $39            $100     $61
       100        89           Pro+ $69            $130     $61
       150       134           Max $100            $180     $80
       200       179           Max $100            $230    $130
       300       268           Max $200            $330    $130

Per seat on a team (Copilot Business vs Cursor Teams Premium seat):
   10 sessions/mo: Copilot $  19.00  Cursor $  45.05  x10 seats: $  190.00 vs $  450.50
   40 sessions/mo: Copilot $  44.80  Cursor $  90.20  x10 seats: $  448.00 vs $  902.00
   80 sessions/mo: Copilot $  89.60  Cursor $ 150.40  x10 seats: $  896.00 vs $ 1504.00

Two things stand out. The gap widens as usage grows, because each Copilot tier front-loads more included credit than it costs: at $200 of Claude usage a month, Copilot Max costs $100 and Cursor Premium costs $230. And the team numbers are worse for Cursor than the solo ones, since the $0.25-per-million Token Rate adds about 38 cents to every 1.54M-token session. The script treats Copilot Business credits per seat, which is the conservative case: GitHub’s docs say each license contributes its credits to a shared pool, so a team where some members barely use Copilot covers the heavy users for less.

The model has blind spots, and they all favor Cursor. It counts none of the Grok and Composer pool. Copilot bills Grok 4.7 at $2 input and $6 output per million tokens, while Cursor includes it, so a developer happy to run Composer 2.5 or Grok all day pays $30 flat on Cursor and real credits on Copilot. It also ignores Copilot’s 10% discount on usage routed through Auto model selection, which nudges things further toward Copilot for anyone who lets Auto pick the model.

Model Quality: Where the Money Actually Goes

Both tools now carry the same frontier lineup. The Copilot plans page lists Claude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5, the GPT-5.6 and GPT-6 families, Gemini 4 Argon, Grok 4.7 and Kimi K3 across its individual plans. Cursor’s models page lists the same Claude, GPT and Gemini generations as third-party options, with many hidden by default. The old “Cursor has Opus, Copilot doesn’t” argument no longer holds. If you’re picking a model rather than a tool, the ranking of coding models by tier is a better starting point than either vendor’s menu.

Context size has evened out too. Cursor’s docs list Claude 5.5 models at up to 1M tokens with extended context at the same per-token rates, which used to be its headline edge. Copilot’s pricing page now has a long-context tier for GPT-5.6 Sol above 272K input tokens, billed at $8 input and $30 output per million.

What separates them is the agent harness and where it runs. Copilot runs as an extension in VS Code, Visual Studio, JetBrains IDEs, Xcode, Neovim and Eclipse, and its cloud agent takes work assigned on GitHub and can deliver it as a pull request. Cursor is its own VS Code fork, with Agent, a CLI and Cloud Agents sharing one pool. My read is that the harness gap has narrowed enough that price and IDE fit should decide it for most people. For a broader look at how terminal agents stack up against Cursor’s editor-first approach, see the OpenCode vs Claude Code vs Cursor comparison, and the AI coding tools guide covers the wider field.

When Copilot Is the Right Call

• You want Claude or GPT models as your daily driver. Copilot includes $15 to $200 of that usage; Cursor bills all of it.
• You work across several IDEs, or your team is split between VS Code and JetBrains.
• Your organization is on GitHub Enterprise and wants per-seat billing at $19 or $39 with credits included.
• You live in pull requests. Copilot code review and the cloud agent come with every paid plan.
• You want a hard ceiling. Without an additional-usage budget, Copilot stops when credits run out instead of charging.

One caveat on the individual plans: since April 24, 2026, GitHub uses interaction data from Copilot Free, Pro and Pro+ for model training by default, a change it announced on March 25. Business and Enterprise are exempt, and you can opt out in the privacy section of your Copilot settings. Check that setting before you paste proprietary code into a personal account.

When Cursor Is Worth the Extra Cost

• You’re content running Composer 2.5 or Grok for most work. That usage is inside the $30 Premium price, so heavy users of those models pay nothing extra.
• You want one pool shared across editor agent, CLI and cloud agents, refreshed weekly so one heavy day doesn’t burn the month.
• You already pay for X Premium or Grok. The bundle folds both into the Cursor price.
• You prefer Cursor’s editor and agent UX enough to pay roughly $20 to $130 a month more for Claude-heavy work.

If Claude is the main reason you’d pick Cursor, the math above says you’re paying twice: once for the subscription, once for the tokens. A direct Claude plan is the more efficient way to buy those models; the Claude Code Pro vs Max breakdown covers what each tier includes.

Pricing Comparison Table

The Copilot and Cursor-with-Claude rows come from the script output above. The Composer/Grok row is the scenario the script deliberately leaves out.

GitHub Copilot Features in 2026

As of October 2026, the Copilot plans page lists:

• Agent mode and MCP server integration on every plan, including Free
• Code review on pull requests and the cloud agent on all paid plans
• Delegation to third-party coding agents, including Claude by Anthropic and OpenAI Codex, on Pro+ and Max (in preview)
• Copilot CLI and custom instructions across plans

The old Copilot Extensions built as GitHub Apps are gone. GitHub shut them down on November 10, 2025 in favor of MCP servers, so third-party integrations now come through MCP.

The model menu keeps shifting under the credits. GitHub’s mid-October deprecation notice retires GPT-5.5, GPT-5.4, Grok 4.5 and several smaller models on October 19, 2026, pointing GPT-5.5 and GPT-5.4 at GPT-5.6 Sol. At standard context Sol ($4 input, $20 output per million) is cheaper than GPT-5.5 but pricier than GPT-5.4, so anyone pinned to 5.4 will see agent sessions cost more after that date.

BYOK on Cursor: What Still Works

Bring-your-own-key is narrower than it was in 2024. Cursor’s API keys docs say custom API keys only work with chat models, and Tab completion keeps using Cursor’s built-in models. On individual plans, requests made with your own key don’t draw from included usage; on Teams and Enterprise the $0.25-per-million Cursor Token Rate still applies to BYOK traffic. Cursor’s models page lists no own-key support on the Plus plan.

To set one up, generate a key in the Anthropic Console and add it under API keys in Cursor’s settings. Since Premium already bills Claude at list price, a personal key mostly changes whose invoice the tokens land on. It’s useful if your employer pays the API bill, and much less of a cost lever than it used to be.

If You’re Already on Cursor Pro

Existing subscribers weren’t forced over. The pricing docs state that “Hobby, Start, Pro, Pro+, Ultra, and Teams Standard and Premium seats continue for existing customers,” with two monthly usage pools (Cursor models and other models) and on-demand usage instead of top-ups. Max Mode, which extends context, remains a legacy-plan feature. Launch coverage reports that the standalone plans are no longer sold to new customers, and the pricing page offers none of them.

If you’re on legacy Pro and mostly use Claude through Cursor, that monthly “other models” pool is the thing to keep: cancelling and re-subscribing would put you on Premium, where every Claude token is extra. If you mostly use Composer, Premium’s weekly pool may serve you better than the old monthly one.

FAQ

Is Cursor better than GitHub Copilot? For Claude- or GPT-heavy work at the same budget, Copilot is the better deal in 2026, because its plans include $15 to $200 of model usage and Cursor’s include none. Cursor is the better deal if you’ll run its Composer and Grok models most of the time, since that usage is inside the subscription.

How much does Cursor cost now? On the current pricing page, Plus is $8 a month (Grok and Cursor’s own models, no third-party models), Premium is $30, Super is $100 and Ultra is $200. Teams seats cost $30, $100 or $200 per user. Claude, GPT and Gemini usage is billed on top at API list price on Premium and above.

Can you still buy Cursor Pro for $20? Not from the pricing page, which since October 12, 2026 sells only the X Subscription tiers. Cursor’s docs say Pro, Pro+ and Ultra continue for existing customers, and launch coverage reports they’re closed to new sign-ups.

Does GitHub Copilot have a free tier in 2026? Yes. Copilot Free includes 2,000 completions and 50 chat requests a month, with agent mode and MCP support. Pull-request code review and the cloud agent need a paid plan, and Free users get models picked by Auto.

How many credits does Copilot Pro+ get? 7,000 AI credits a month, worth $70, for $39. One credit is $0.01, and credits are spent at each model’s per-token rate, so the number of agent sessions they cover depends on the model and context size. Unused credits reset on the first of the month.

Can you use Cursor with a GitHub Copilot subscription? No. They’re separate products with separate billing. You can run both, but you’d pay for both.

Sources

• Cursor pricing: X Subscription tiers, third-party models billed separately at API list price
• Cursor docs: plans and pricing: weekly pool models, prepaid credit, Cursor Token Rate, legacy plans
• Cursor docs: models and pricing and API keys: model list, context windows, BYOK limits
• GitHub Copilot plans: Free, Pro, Pro+ and Max prices, included credits, features
• GitHub Docs: Copilot plans: Business and Enterprise seat prices and credits
• GitHub Docs: models and pricing: per-token rates behind AI credits
• Anthropic API pricing: Claude Sonnet 5.5 and Opus 5.5 list prices
• GitHub: Copilot interaction data usage policy: training-by-default change from April 24, 2026
• GitHub changelog: Copilot Extensions deprecation and mid-October model deprecations
• TechMyMoney: X Subscription bundles Grok, Cursor and X Premium: launch coverage, standalone plans closed to new customers (reported)

Bottom Line

A year ago Cursor cost twice as much as Copilot and you paid the premium for a better agent. In October 2026 the structures point in opposite directions. Copilot bundles more Claude and GPT usage than its sticker price, and Cursor bundles Grok and Composer while passing everything else through at list price. My take: if you want frontier Claude or GPT models in an editor, Copilot Pro+ at $39 is the default pick, and Max at $100 makes sense once you’re past roughly $100 of usage a month. Pick Cursor Premium if you’ve tried Composer 2.5 on your own codebase and it holds up, because that’s where the $30 buys real headroom.