GitHub Copilot Premium Requests Are Legacy: What 20 Engineers Now Pay per Seat

The $0.04 GitHub Copilot premium request is no longer how your team is billed. Since 1 June 2026, Copilot Business and Enterprise draw on pooled GitHub AI Credits worth $0.01 each, and the old meter survives only on annual Pro and Pro+ plans. We priced a 20-engineer team under three usage profiles. At moderate use the effective seat price is $45.30, on Business and Enterprise alike.

The short answer

GitHub Copilot premium requests cost $0.04 each over the allowance, but only on legacy annual Pro and Pro+ plans. Teams now pay $19 or $39 per seat for a pooled credit allowance, then $0.01 per credit. A moderate 20-engineer team pays about $45 a seat on either plan, so Enterprise is never cheaper on usage alone.

GitHub Copilot premium requests are now a legacy meter

Most of what ranks for "GitHub Copilot premium requests" still describes a system that stopped governing team billing five months ago. GitHub announced the change on 27 April 2026, in a post by Mario Rodriguez. "Starting June 1, premium request units (PRUs) will be replaced by GitHub AI Credits," the GitHub blog post said.

The old system was simple to explain. Each plan carried a monthly allowance of requests per user. Business carried 300 per user and Enterprise carried 1,000. Every prompt to a premium model consumed one request times a model multiplier. Overage cost $0.04 a request, as ITPro reported at the June 2025 launch.

The new system bills tokens. Input, output and cached tokens are charged at each model's published API rate, converted into credits at $0.01 each. Plan prices did not move. Business is still $19 per seat and Enterprise is still $39, and each seat now buys the same dollar value in credits.

So the question in the brief, what does a team burn at $0.04 a request, has a sharper version. What does a team burn now, and is anyone still better off on the old meter? Only annual Pro and Pro+ holders can still answer the second question, and the answer for most of them is no.

What a premium request costs at $0.04, model by model

The legacy meter is still live for one group. GitHub's docs say the annual-plan multipliers "apply only to Copilot Pro and Copilot Pro+ subscribers on an existing annual plan who remained on the legacy premium request-based billing model after June 1, 2026." Those multipliers rose on 1 June. The table below converts each one into a dollar cost per overage request.

Legacy annual-plan multipliers, converted to dollars at $0.04 per premium request

Model or feature	Multiplier	Overage cost per request	Requests inside Pro+ (1,500)
MAI-Code-1.1-Flash	0.25	$0.01	6,000
Claude Haiku 4.5	0.33	$0.0132	4,545
GPT-5.3-Codex	6	$0.24	250
Claude Sonnet 4.6	9	$0.36	166
Copilot code review	13	$0.52	115
Claude Opus 4.8	27	$1.08	55

Multipliers from GitHub Docs, model multipliers for annual plans, read 4 November 2026. The page lists five models plus code review. Dollar and count columns are our arithmetic. Pro carries 300 requests, so divide the last column by 5 for Pro.

The 9x Sonnet problem

A legacy annual Pro+ subscriber gets 1,500 premium requests a month. At 9x, that is 166 Sonnet 4.6 prompts. Spread across 22 working days, it is about 7 prompts a day before overage starts. On annual Pro the same allowance covers 33 Sonnet prompts a month.

That is the trap in the legacy meter. A request is counted per prompt, not per token, so a two-line question costs the same as a prompt that kicks off a long agent run. GitHub's docs define it plainly: each time you send a prompt or trigger a response, you make a request.

Copilot code review costs 13 requests

Code review is the multiplier most teams do not see coming. From 1 June, each review on a legacy plan consumes 13 premium requests, or $0.52 in overage. On AI Credits it is metered twice. GitHub says a Copilot review also consumes GitHub Actions minutes at standard rates. If review is a large line for you, our price matrix for AI code review tools compares the dedicated alternatives.

How GitHub Copilot cost works under AI Credits

The current meter has three parts. A seat price, a pooled credit allowance, and a per-credit overage. The allowance is the seat price expressed in credits: 1,900 credits on Business and 3,900 on Enterprise, which is $19 and $39 of usage at $0.01 each.

Credits are consumed at model API rates. On GitHub's models and pricing page, Claude Sonnet 4.6 costs $3.00 per million input tokens, $0.30 cached and $15.00 output. Claude Opus 4.8 costs $5.00, $0.50 and $25.00. Claude Haiku 4.5 costs $1.00 and $5.00.

The pool belongs to the billing entity, not the engineer

"A user's included AI credits are pooled at the billing entity level," GitHub's organisation billing page says. A 20-seat Business team holds one pool of 38,000 credits, or $380. A light user's unspent credits fund a heavy user's agent runs. Credits do not roll over, and the pool resets at 00:00 UTC on the 1st.

That pooling matters more than any multiplier. Under premium requests, allowances were per user, so a light user's spare requests were simply lost. We quantify that below, and it is the single best feature of the new meter for teams.

Budgets do not stop spend unless you tell them to

Paid usage beyond the pool is "enabled by default for Copilot Business, Copilot Enterprise, and Copilot access," according to GitHub's docs. The "Stop usage when budget limit is reached" setting is off by default for organisation and enterprise budgets. Only user-level budgets always hard stop. Code completions and next edit suggestions stay unlimited and never consume credits.

We think this default is the wrong one for most teams. An uncapped meter on an agent product turns a single runaway session into a line item. We covered how that variance behaves in the analysis of agent token cost variance.

The cost model: three usage profiles, priced at GitHub's token rates

GitHub publishes rates per token, not per task. To turn rates into a seat price you need an assumption about how many tokens a unit of work consumes. Ours are stated below so you can replace them with your own telemetry. They are modelling inputs, not measurements.

We use two request shapes. A chat request sends 20,000 uncached input tokens and returns 1,000 output tokens. An agent session is one prompt that runs a multi-step task: 1,000,000 input tokens, 80% served from cache, plus 20,000 output tokens.

Cost of each request shape at GitHub's published token rates

Shape	Claude Sonnet 4.6	Claude Opus 4.8	Same prompt on a legacy annual plan
Chat request (20k in, 1k out)	$0.075 (7.5 credits)	$0.125 (12.5 credits)	$0.36 Sonnet, $1.08 Opus
Agent session (1M in, 80% cached, 20k out)	$1.14 (114 credits)	$1.90 (190 credits)	$0.36 Sonnet, $1.08 Opus

Token rates from GitHub Docs, models and pricing, read 4 November 2026. Request shapes are our assumptions. Cache write charges are excluded, which understates the agent rows. Legacy column applies the annual-plan multiplier at $0.04 per request.

The table explains why GitHub moved. A flat per-prompt price overcharges a short chat by about 4.8x and undercharges a long Sonnet agent session by about two thirds. As agent use grew, the meter priced the expensive work below cost. Our view: token billing is the honest meter, and it is also the less predictable one.

The three profiles below are per engineer per month. They are illustrative, chosen to span a team that mostly chats through one that runs agents daily.

• Light: 150 Sonnet 4.6 chat requests. Cost $11.25.
• Moderate: 300 Sonnet chat requests plus 20 Sonnet agent sessions. Cost $45.30.
• Heavy: 400 Sonnet chat requests, 30 Sonnet agent sessions and 30 Opus 4.8 agent sessions. Cost $121.20.

GitHub Copilot cost for a 20-engineer team

Multiply each profile by 20 and run it through the pool. On Business the pool is $380. On Enterprise it is $780. Anything above the pool bills at $0.01 per credit, so the team pays the larger of the pool or its usage.

Monthly Copilot bill for 20 engineers, by plan and usage profile

Profile	Team usage	Business bill	Enterprise bill	Effective seat price
Light	$225	$380 (pool unused: $155)	$780 (pool unused: $555)	$19.00 Business, $39.00 Enterprise
Moderate	$906	$906 ($526 overage)	$906 ($126 overage)	$45.30 on both
Heavy	$2,424	$2,424 ($2,044 overage)	$2,424 ($1,644 overage)	$121.20 on both

Our arithmetic from GitHub's published allowances and token rates. Usage profiles are illustrative. Excludes features other than credits, which differ between the plans.

Business and Enterprise converge once the pool is spent

This is the finding that should change a procurement conversation. Enterprise costs $20 more per seat and includes $20 more of credits per seat. Credits bill at par either way. So on usage alone, Enterprise is never cheaper than Business, and it costs the same once average usage passes $39 a seat.

That makes the Enterprise decision a feature decision, not a usage decision. If your team needs Enterprise for reasons other than credits, buy it. If the case for Enterprise is "we use a lot of Copilot," it is the wrong case. Heavy usage costs the same on Business, and Business does not strand $20 a seat in months when the team is quiet.

A mixed team shows what pooling is worth

Real teams are not uniform. Take 10 light, 7 moderate and 3 heavy engineers. Their combined usage is $793.20. On Business, the $380 pool covers the start and $413.20 bills as overage, for $39.66 a seat. On Enterprise the bill is also $793.20, because usage just clears the $780 pool.

Now price the same team as if each engineer had a private allowance, the way premium requests worked. Each light user pays $19 for $11.25 of use, stranding $7.75. Across 10 light users that is $77.50 of credit nobody can spend, and the bill rises to $870.70.

A 9% saving will not decide a budget. It does show which way the incentives now point. Under pooling, the cheapest team is one where a few people run agents and most people do not.

Copilot Pro+ and Max break-even under AI Credits

Individual plans carry something team plans do not: a flex allotment on top of base credits. According to GitHub's individual billing docs, Pro includes 1,500 credits for $10, Pro+ includes 7,000 for $39, and Max includes 20,000 for $100. Extra usage bills at $0.01 per credit through a dollar budget.

That gives two clean break-even points. Pro costs $10 plus any usage above $15. Pro+ costs $39 up to $70 of usage. The lines cross at $44 of monthly usage. Pro+ and Max cross at $131, where Pro+ reaches $100 in total.

Run the three profiles through it. Light ($11.25) belongs on Pro at $10. Moderate ($45.30) costs $40.30 on Pro and $39 on Pro+, a coin toss. Heavy ($121.20) costs $90.20 on Pro+ and $100 on Max, so Pro+ still wins. Note that the heavy engineer pays $31 less a month on individual Pro+ than on a Business seat, because of the flex allotment.

That gap is not an invitation to put your team on personal plans. Personal accounts outside the organisation perimeter carry their own costs, set out in the piece on personal AI accounts and the security perimeter. It does tell you GitHub prices individual heavy use more generously than team heavy use.

One engineer, monthly bill: legacy annual plan against AI Credits

Profile	Legacy annual Pro	Legacy annual Pro+	Monthly Pro+ on credits	Cheapest option
Light (1,350 requests)	$52.00	$39.00	$39.00	Monthly Pro on credits, $10
Moderate (2,880 requests)	$113.20	$94.20	$39.00	Monthly Pro+, $39
Heavy (4,680 requests)	$185.20	$166.20	$90.20	Monthly Pro+, $90.20
Agent-only: 100 Opus 4.8 sessions (2,700 requests)	$106.00	$87.00	$159.00	Legacy annual Pro+, $87

Request counts apply the annual multipliers: Sonnet 4.6 at 9, Opus 4.8 at 27, one request per prompt. Max would bill the agent-only user $100. Our arithmetic; profiles are illustrative.

The last row is the concession. A user who sends few prompts and lets each one run a long Opus agent session still does better on the legacy meter. For everyone else, the annual plan now costs more than switching. GitHub's announcement says converting from annual to monthly earns prorated credits for the remaining annual value. If you hold an annual plan and mostly chat, convert this month.

Where this cost model is weakest

This post computes seat prices from token assumptions we chose. That is the weakest point, and it is a big one. Nothing in GitHub's public docs says how many tokens a typical Copilot chat or agent session consumes.

The request shapes are ours, not GitHub's

A 20,000-token chat request is plausible for a prompt that carries open files as context. It could easily be 5,000 or 80,000 depending on the editor, the repository and the feature. Agent sessions vary even more. One user in GitHub's community discussion reported 822 credits gone in a single request, which is seven times our Sonnet agent session. Treat every seat price above as a function of the shape, and rerun it with your own numbers.

We also excluded cache write charges, which GitHub bills for Anthropic models at $3.75 per million tokens on Sonnet 4.6. Including them would raise the agent session cost. The direction of every conclusion holds, but the heavy profile is a floor, not an estimate.

Rates and allowances move faster than posts

GitHub's docs say the annual multipliers "are subject to change." Two Gemini rates on the models page carry promotional prices that expire on 1 December and 31 December 2026. Individual plans also carry a 30% discount on Copilot Fusion through 30 November 2026, which we did not model. The flex allotment that makes individual Pro+ cheap is a separate line in GitHub's table, and a separate line can be withdrawn without changing the headline price. That pattern is common enough that we track it in the post on AI shrinkflation and usage limits.

Finally, this model prices credits only. Enterprise includes features Business does not, and those may be worth $20 a seat to your team. Our claim is narrow: usage alone never justifies Enterprise.

Frequently asked questions

Where to start

Open your organisation's Copilot billing page this week and change one setting. Turn on "Stop usage when budget limit is reached" for the organisation budget, at a figure about 20% above last month's pool. An agent product with an uncapped meter is an open purchase order.

Then pull one month of credit usage by user and sort it. If fewer than a quarter of your engineers account for most of the spend, you are on the right plan with Business, and the pool is doing its job. If you are paying for Enterprise only because usage is high, the numbers above say you are buying credits at par for a premium. For the wider picture of how vendors are moving from seats to meters, start with the guide to AI billing in credits and tokens.

Related reading