Cursor vs GitHub Copilot Teams Pricing June 2026: Which Plan Wins After the June 1 Changes

On June 1, 2026, Cursor and GitHub Copilot both rewrote their team pricing within hours of each other. Cursor split every Teams seat into two separate usage pools and added a new Premium seat at $120/month. GitHub flipped the switch on usage-based billing for all Copilot plans, so every seat now meters work in AI Credits. If you manage a dev team, the plan you were budgeting for last week may not be the plan you want this week.

Here is the current pricing on both sides, in plain numbers, with a worked example for a 5-person team and a flat verdict for each team type. This piece covers cost only. For the feature-by-feature breakdown (tab completion, agents, IDE), see our Cursor vs Copilot comparison.

Current prices at a glance

The four team-relevant tiers, with the numbers each vendor published on June 1:

Plan	Monthly price	Annual price (per mo)	Included usage	Best for
Cursor Standard	$40/seat	$32/seat	Two pools per seat (Composer/Auto + Third-Party API)	Most dev teams
Cursor Premium	$120/seat	$96/seat	5x Standard's usage	Heavy agent users
Copilot Business	$19/seat	$19/seat	1,900 AI Credits/user/mo (pooled org-wide)	Price-sensitive teams already on GitHub
Copilot Enterprise	$39/seat	$39/seat	3,900 AI Credits/user/mo (pooled org-wide)	Orgs needing SSO + policy controls

Cursor seat prices and the 5x-at-3x Premium ratio come from Cursor's Teams pricing post (June 1). Copilot per-seat credit allowances come from GitHub's usage-based billing doc for organizations. Copilot Business and Enterprise list prices are unchanged at $19 and $39 per seat; what changed is how the usage inside them is metered.

One quick note before the details. Copilot has no annual discount on the team tiers, so its monthly and annual columns match. Cursor's annual plan knocks 20% off both seat types.

What changed on June 1 for both platforms

Cursor: dual usage pools and a new Premium seat

Cursor's headline change is structural, not a price hike. Standard seats stay at $40/month ($32 annual), and Cursor says they now carry "significantly more usage, with no change in cost." The catch is how that usage is partitioned.

The new piece is the Premium seat: $120/month ($96 annual), built for the handful of people on any team who run agents all day. Cursor prices it at 3x a Standard seat for 5x the included usage, and teams can mix Standard and Premium seats however they want. Cursor expects the Premium Composer pool to cover a full month of heavy agent work for 99% of users.

These prices apply to new customers right away. Existing customers move over on their first billing cycle starting July 1, 2026. So if your team renews in late June, you get a few extra weeks on the old structure before the pools kick in.

Cursor also shipped a real-time dashboard alongside the pricing change. It shows each user how close they are to each limit, split between the Auto/Composer pool and the third-party API pool, and flags when someone should move to a different seat type.

GitHub Copilot: AI Credits billing is live, Copilot Max launches

GitHub's change is the billing model itself. As of June 1, every Copilot plan bills on GitHub AI Credits, where 1 credit equals $0.01. Each plan ships with a monthly pool of included credits, and once a seat burns through them, an admin-set budget decides whether work continues at metered rates or stops.

Code completions are the important exception. GitHub's individuals billing doc states that code completions and next edit suggestions are not billed in AI Credits and stay unlimited on every paid plan. Credits get consumed by the expensive stuff: Copilot Chat on frontier models, agent runs, and Copilot code review.

Two more June 1 items matter for admins. Copilot code review now consumes GitHub Actions minutes on top of AI Credits, per GitHub's billing changelog. And user-level budgets went generally available for organizations and enterprises, so an admin can cap spend per user, not just per org.

GitHub also launched Copilot Max at $100/month with 20,000 total AI Credits. Read the fine print: Max is an individual upgrade for existing Student, Pro, and Pro+ subscribers. There is no "Copilot Max for Teams" tier. For a team, the ceiling stays Copilot Business or Copilot Enterprise. This historical thread on the April individual plan changes tracks how GitHub got here.

Why this article replaces earlier comparisons

Our earlier guide, the updated June 2026 pricing comparison, was written on May 27 and stated that Cursor's pricing had not changed. That was true on May 27 and wrong by June 1. Cursor's dual-pool restructure landed after that piece shipped, so this article carries the current Teams numbers for both platforms. For a Copilot-only breakdown of the individual tiers, the Copilot plan overview goes deeper on Pro, Pro+, and Max.

How each platform's billing works now

Cursor's dual pool model explained

This is the part of Cursor's change that confuses people, so here it is in plain terms. Every Cursor Teams seat now has two separate buckets:

Pool	What it covers	Drains when you...
Composer / Auto	Cursor's own models (Composer 2.5) and Auto routing	Run agents or completions on Cursor's first-party models
Third-Party API	Outside models reached through the API (Claude, GPT)	Send agent or chat work to a non-Cursor model

The rule that matters: running out of one bucket does not touch the other. If your team hammers Claude through the third-party pool and drains it, your Composer/Auto pool is untouched, so first-party work keeps flowing. Before this change, heavy agent runs on outside models could eat into the same allowance you relied on for everyday completions. Now they are walled off from each other.

For a team lead, the practical effect is predictability. You can tell a developer "use Composer for the bulk of your agent work" and know that their experiments with a frontier model on the API side will not starve their day-to-day usage.

Copilot AI Credits explained

Copilot pools by spend, not by feature. There is one credit bucket per seat (1,900 on Business, 3,900 on Enterprise), and every billable action draws from it at the action's token cost. A cheap chat turn on a lightweight model costs a fraction of a credit. A long agent run on a frontier model costs many.

The org-wide pooling is the detail most teams miss. Credits are not locked to each seat. GitHub's org billing doc gives the example of an enterprise with 100 Copilot Business users getting a shared pool of 190,000 credits, not 100 separate 1,900-credit buckets. Power users draw more, light users draw less, and the org-level total is what counts. That smooths out the spiky-user problem without forcing you to over-provision.

Here is the rough conversion to keep in your head:

1 AI Credit            = $0.01 USD
1,900 credits (Business) = $19 of included usage per seat
3,900 credits (Enterprise) = $39 of included usage per seat
Code completions / next edit = unlimited, $0 credits

The key difference: Cursor pools by feature type, Copilot pools by token spend

The two systems answer different questions. Cursor's pools protect a kind of work (first-party vs third-party) from being cannibalized. Copilot's credits protect a budget (dollars of token spend) and let any feature draw from it until the money runs out.

That makes Cursor more predictable for a team with a steady model mix, and Copilot more flexible for a team whose usage swings month to month. Neither is simpler. Cursor asks you to think about which pool a task hits. Copilot asks you to think about how many tokens a task burns.

Worked example: a 5-person dev team

Numbers below are an illustrative scenario, not a measured bill. They show how to run the math with each platform's published rates; your real usage will differ.

Example team: 5 developers, moderate agentic work
Assumptions per developer per workday (22 workdays/mo):
  - ~20 Copilot Chat / agent turns on a frontier model
  - ~2 cloud agent runs (multi-step, larger token spend)
  - Steady code-completion use all day (Copilot: unlimited, $0)

Copilot Business: base plus estimated overage

Base:   5 seats x $19           = $95 / month
Credits: 5 x 1,900              = 9,500 included credits (pooled)
Completions:                     unlimited, $0
Chat + agent runs:               drawn from the 9,500 pool

On Copilot Business, completions cost nothing, so the entire credit pool is available for chat and agent runs. Whether 9,500 pooled credits cover the team depends on model choice. Light-model chat turns are cheap; frontier-model agent runs are where credits go fast. A team that keeps agent runs on mid-tier models can live inside the pool. A team that defaults every agent run to the most expensive frontier model will blow past 9,500 credits and pay metered overage, which is where user-level budgets earn their keep.

Cursor Standard: base plus which pool is at risk

Base:   5 seats x $32 (annual)  = $160 / month
Pools per seat:                  Composer/Auto + Third-Party API (separate)

Cursor Standard costs more at the base ($160 vs $95 for 5 seats). What you buy for the difference is pool separation. The agent runs on Cursor's own Composer 2.5 draw from the Composer/Auto pool. The frontier-model experiments draw from the third-party pool. Neither cannibalizes the other, so a single developer going heavy on Claude through the API will not drain the allowance the rest of the team uses for everyday Composer work.

Cursor Premium: when the 5x usage is worth the step-up

Premium seat: $96/seat (annual) = 3x Standard cost, 5x Standard usage
Mixed team:   3 Standard + 2 Premium
  = (3 x $32) + (2 x $96)        = $96 + $192 = $288 / month

You do not put everyone on Premium. The point of Premium is the one or two people on the team who run agents constantly. Put them on Premium, keep everyone else on Standard, and you get a predictable flat bill instead of overage surprises from your heaviest users. For a team where two developers drive most of the agent spend, a 3-Standard + 2-Premium mix at $288/month buys cost predictability that a metered model cannot match.

Verdict by team type

No "it depends." Here is the pick for each team.

Small team, mostly completions plus light chat: Copilot Business wins on price. At $19/seat with unlimited completions and 1,900 pooled credits per user, a 2-to-5-person team doing standard coding with occasional chat will spend the least here. Completions, the thing most devs use most, never touch the credit pool. If your team's agent usage is light, the 9,500-credit pool on a 5-seat plan is plenty.

Heavy agentic team on frontier models: Cursor Premium wins on predictability. If two or three developers run agents all day across multiple models, Copilot's metered overage gets unpredictable fast and Cursor's flat Premium pools do not. Put the heavy users on Premium at $96/seat (annual), keep the rest on Standard, and your bill stops moving. Predictability beats a slightly lower base price when the base price is not what you actually pay.

Enterprise needs (SSO, fine-tuning, policy controls): Copilot Enterprise is the only option. Cursor does not match Copilot Enterprise on SAML SSO, fine-tuning, and org-wide policy controls. If your security team requires those, the comparison is over at $39/seat. Cursor is not in the running for that checklist.

Already living in VS Code plus GitHub: Copilot. Native Cursor IDE users: Cursor. Tooling gravity is real. If your team's PRs, Actions, and reviews already run through GitHub, Copilot's June 1 code-review-in-Actions integration keeps everything in one place. If your developers already work in the Cursor IDE every day, the native agent experience is the reason they are there, and the dual pools make the cost predictable.

When you have made the call, Cursor's Teams plans are here and you can compare them against GitHub Copilot's plans directly.

FAQ

Is Copilot Max available for teams or only individuals? Individuals only. Per GitHub's June 1 changelog, Copilot Max ($100/month, 20,000 AI Credits) is an upgrade for existing Student, Pro, and Pro+ subscribers. There is no Max for Teams tier. For a team, the top options remain Copilot Business and Copilot Enterprise.

Can Cursor teams mix Standard and Premium seats? Yes. Cursor's pricing post says teams can mix seat types freely. The usual pattern is to put one or two heavy agent users on Premium and leave everyone else on Standard.

What happens when a Cursor team hits both usage pools? The two pools are independent, so you can drain one without affecting the other. Once a pool is exhausted, you are into on-demand usage for that pool's work; the new real-time dashboard shows how close each user is to each limit so you can act before that happens.

Do Copilot Business credits roll over month to month? No. Included AI Credits are a monthly allowance. Unused credits do not carry forward. Credits do pool across the org within a month, so the question is whether the whole team's monthly usage fits the combined pool, not whether each seat does.

Which platform has better spending controls for admins? Both shipped admin controls on June 1, and they are close. Copilot added generally available user-level budgets so admins can cap spend per user across an org. Cursor added a real-time usage dashboard with per-user limit visibility and seat-type recommendations. Copilot's edge is hard per-user budget caps; Cursor's edge is that the dual-pool structure makes overruns less likely in the first place.