Cursor vs GitHub Copilot in 2026: The $10 vs $20 Comparison Is Wrong

I sat down to price these two tools properly and found that the number everybody quotes, $10 for Copilot against $20 for Cursor, is still technically accurate and no longer tells you anything useful.

Both prices are real. Neither one describes what you get. GitHub changed how Copilot bills on June 1 and then changed it again with something called a flex allotment, so the $10 plan now carries $15 of usage. Cursor runs two separate usage pools and publishes a rate for only one of them. And four days ago Cursor launched a plan in India at roughly a third of Pro's price that no comparison article I can find has noticed yet.

So this is a pricing-first comparison. Every figure below came off the vendors' own pages on July 31, 2026. Where I could not verify something, I say so instead of repeating what the other results say.

What GitHub Copilot actually costs now

On June 1, 2026, GitHub retired premium request units and replaced them with GitHub AI Credits. One credit is one cent. Usage is metered on actual token consumption, counting input, output and cached tokens against each model's published API rate, rather than counted as requests.

Then GitHub did something that has confused nearly everyone writing about this. It split each plan's allowance into two parts: base credits equal to the subscription price, and a flex allotment on top that GitHub adjusts over time as model prices move.

Base credits get spent first. Once you pass them the flex allotment applies automatically at the same rates, whether you are working in your IDE, on github.com or in the CLI.

This is where the stale numbers come from. GitHub's own launch announcement says Copilot Pro is "$10/month, including $10 in monthly AI Credits." That post is still live, still ranks, and no longer matches the product. The live plans page says $15. The Max plan does not appear in the announcement at all, because it launched alongside the change rather than being described by it. If you have read three articles this month saying Copilot Pro gives you $10 of credits, that is why.

For teams, GitHub's announcement listed Business at $19 per user and Enterprise at $39 per user, each including credits equal to the price. I read those from the announcement rather than a live business pricing page, so treat them as less fresh than the individual plan figures above.

What Cursor actually costs now

Cursor never sold a flat plan in the way people remember. What it sells is a dollar-denominated pool, and the important detail is that there are two of them.

Look at the Pro+ row. It costs $60 and includes $70 of usage. Cursor prices that pool deliberately above the subscription, the same way GitHub's flex allotment does, and almost every comparison article prints $60 because that is what the plan costs. Ultra is the same story at a larger multiple: $200 buys $400.

The second pool is the one that makes Cursor hard to compare. Composer 2.5 and Grok 4.5, Cursor's own models, draw from a separate Cursor Models pool that the docs describe as generous included usage without publishing a per-token rate for it. Everything from Anthropic, OpenAI and Google draws from the dollar pool at the provider's API price.

Auto mode deserves a flag of its own, because this is the fact most out of date across the web and in my own Cursor review until I corrected it this week. Through 2025, Auto was genuinely free and became the standard advice for avoiding overages. It is now metered. Cursor's docs price Auto Cost per million tokens regardless of which model it routes to, and Auto Balance and Auto Intelligence bill at the API rate of whatever model they select. Auto is still the cheap setting. It stopped being the free one.

When you exhaust a pool, Cursor lets you continue on demand at the same API rates rather than throttling you, and the docs are explicit that requests are never downgraded in quality or speed. That is a genuinely better overage design than most metered products, which quietly slow you down.

The comparison nobody runs: what is free on both

Here is the part that reframes the whole question.

GitHub states that code completions and next edit suggestions remain included on all plans and consume no AI Credits. Cursor gives unlimited tab completions on every paid plan. So on both tools, the thing you interact with a thousand times a day costs nothing beyond the subscription.

What you pay for, on both, is agent work. Chat, multi-file edits, code review, background agents, CLI runs.

That kills the $10 versus $20 framing. The honest comparison is $15 of metered agent budget on Copilot Pro against $20 of metered third-party budget on Cursor Pro plus an unquantified allowance for Cursor's own models. Cursor gives you more, and refuses to tell you exactly how much more. Copilot gives you a smaller number you can actually reason about.

Which of those you prefer says something about how you like to be billed. I would rather have GitHub's smaller, fully specified allowance than Cursor's larger one with an undisclosed component. Other people will reasonably take the opposite view, since in practice Cursor's own models absorb most ordinary work and the pool rarely binds.

What a credit actually buys

Both vendors now bill on tokens, and that quietly broke every "how many requests do I get" answer written before this summer.

Under the old system Copilot sold premium request units, so one request cost one unit and you could count them. Since June 1 it counts input, output and cached tokens against each model's published rate. Cursor works the same way, drawing from your pool at the provider's API price.

The practical consequence is that identical actions cost wildly different amounts. Ask an agent to rename a variable in a small file and you spend very little. Ask it to refactor across a large repository and it reads thousands of lines as context before writing anything, and the same single request costs many times more. Context size is the cost driver now, not request count.

This is why I distrust any article that tells you $20 buys a specific number of requests. From my own usage I have seen frontier-model requests land somewhere between roughly four cents and twenty cents depending on the model and how much context came along, which puts a $20 pool somewhere in the low hundreds of requests. That is an observation from my billing dashboard, not a vendor figure, and your number will differ based on repository size more than on anything else.

Neither company publishes a requests-per-dollar figure, and I think that is deliberate rather than sloppy. The honest version is that they cannot publish one, because the answer depends on your codebase.

What happens when you run out

The two products handle exhaustion very differently, and Copilot's design has a trap in it worth knowing before it appears on an invoice.

Cursor is the simpler of the two. When a pool empties you can continue on demand at the same API rates and pay in arrears, and the docs are explicit that requests are never downgraded in quality or speed. You keep the model you chose. You just start paying for it directly.

Copilot spends base credits first, then applies the flex allotment automatically at the same rates across your IDE, github.com and the CLI. After that, usage bills as overage. GitHub added spending controls on July 2, 2026, and how they behave depends on which kind of budget you set.

A user-level budget always enforces a hard stop. GitHub's docs say there is no option to allow usage to continue past it, so an individual developer who sets one cannot be billed beyond it. Set it to zero and Copilot simply stops consuming credits when the included allowance runs out.

Budgets at the organisation, enterprise or cost centre level work differently, and this is the part to watch. Those have a setting called "Stop usage when budget limit is reached", and GitHub's documentation states it is off by default, followed by the instruction to always enable it when creating a budget. A budget with that toggle off is an alert, not a limit. Charges keep accruing past it. If you are an engineering manager who set a team budget and assumed it capped anything, go and check the toggle.

When a limit does block someone, code completions and next edit suggestions keep working, since those consume no credits on any plan. The blocked user stays blocked until the next billing cycle resets consumption or an administrator raises the budget.

I have gone looking for an equivalent default cap on the individual side and did not find GitHub documenting one. Read that as: if you set nothing, nothing stops the meter.

Where each one wins on capability

Pricing decides less than people think. Two structural facts decide more.

The first is editor coverage. Copilot installs into VS Code, Visual Studio, the JetBrains IDEs, Neovim and Xcode. Cursor is its own editor, forked from VS Code, so adopting it means switching editors. If your team writes Kotlin in IntelliJ or Swift in Xcode, the comparison is over before anyone opens a pricing page. This is the most practical difference between the two products and it routinely gets four sentences in articles that spend six paragraphs on benchmarks.

The second is how each tool handles work that spans many files. Cursor's Composer takes an instruction like "add rate limiting to every route in this directory" and returns one atomic diff across every file it touched. Copilot has closed distance here, but Cursor still does this better, and it is why developers who switched mostly stayed switched.

Everything else is closer than the marketing on either side suggests. Both handle single-file edits well. Both do inline chat competently. Both support MCP servers now.

I should say plainly what I could not confirm. One of the top-ranking comparison pages reports that Copilot solved 56 percent of 500 SWE-Bench Verified tasks against Cursor's 51.7 percent, with per-task timings to two decimal places. I could not trace those numbers to any published benchmark run, and I found other pages repeating them without a source. They may be real. I am not going to pass them along as though I checked them, and you should be wary of any comparison that quotes precise benchmark figures without linking the run.

The plan no comparison article lists

On July 27, 2026, Cursor launched Cursor Start: ₹649 a month, tax inclusive, billed monthly in rupees, payable by UPI, credit card or debit card. India only.

That is roughly $7. It sits between the free Hobby tier and Pro. You get Composer and Grok 4.5, more agent requests than the free plan, always-on cloud agents, the iOS app, plugins, MCP servers, hooks and skills. You do not get access to every model, Bugbot, Auto mode or unlimited paid overages, which stay behind Pro.

Cursor's reasoning is in the launch post: Indian developers asked for pricing that reflected the local market and for local payment methods. India is now Cursor's third-largest market, with its user base there passing three million developers after roughly tripling in a year.

For a large share of the people reading a "which should I buy" article, the correct answer is now a plan that appears in none of them. At ₹649, Start undercuts Copilot Pro's $10 as well, while giving you a real agentic editor rather than an extension. The tradeoff is losing manual frontier-model selection, which matters less than it sounds if Composer already handles your daily work. If you are weighing this against everything else at this price point, my roundup of AI tools under $20 a month covers the same budget band across categories.

Regional pricing keeps turning up as the gap in AI tool coverage. I hit the same thing with Grammarly while writing up every 2026 AI pricing change, where an India-exclusive plan appeared that no comparable article mentioned.

Who owns Cursor now

Anysphere agreed to a $60 billion all-stock acquisition by SpaceX, announced June 16, 2026, expected to close in Q3 2026 subject to regulatory approval. It has been reported as the largest acquisition of a venture-backed startup on record. SpaceX had secured an option to buy the company on April 21.

It follows SpaceX's merger with xAI in February 2026, which explains why Grok 4.5 is now a first-party model inside Cursor alongside Composer.

For a solo developer this changes nothing this year. The editor works the same on August 1 as it did on July 1. For anyone choosing a tool their team will standardise on, it is a live question: your source code will be processed by a company that is mid-acquisition by a satellite manufacturer that merged with an AI lab six months ago. Some legal departments will not care. Some will care a great deal. Better to ask now than after the rollout.

Copilot's ownership story is boring by comparison, and boring is the selling point. Microsoft has been answering enterprise procurement questions for thirty years and has the compliance paperwork to prove it.

So which one should you buy

That last row is the honest answer for most working developers. Thirty dollars a month against a developer salary is not a real decision. The version that goes wrong is buying both and spreading your agent work so thin across them that neither included allowance gets used, which is how you end up paying $30 for what one $20 plan would have done.

If you are earlier in this than the table assumes, my guide to the top AI coding assistants for beginners covers the wider field without the pricing math, and using Claude AI for coding covers the terminal-first alternative to both of these.

How to check this yourself

This post will go stale. Everything in this category does, usually within about six weeks, which I know because I found five wrong prices in my own ElevenLabs review seven weeks after publishing it.

Three habits protect you. Read the vendor's live pricing page rather than its announcement blog, because the announcement is a snapshot of launch day and the page is current, which is exactly the trap the $10 credits figure fell into. Check whether an allowance sits behind the subscription, since the sticker price stopped being the cost when agents got metered. And check what your own checkout page offers, because regional pricing is now common enough that the dollar figure in any comparison article, including this one, may not be the number you are shown.

Sources, all read on July 31, 2026:

• GitHub Copilot plans and pricing
• GitHub: flex allotments and the Max plan
• GitHub: Copilot is moving to usage-based billing
• GitHub Docs: budgets for usage-based billing
• Cursor pricing and billing docs
• Cursor model pricing docs
• Introducing Cursor Start
• CNBC: SpaceX to acquire Cursor for $60 billion
• TechCrunch: Cursor's India push and localised pricing