Buy the plan your burn rate points at, not the one with the best headline ratio. Copilot bills every tier the same way — a monthly allowance of AI credits, 1 credit = $0.01 — and overage costs the same $0.01 per credit everywhere, which makes the switch points exact: Pro ($10) below 4,400 credits a month, Pro+ ($39) from 4,400 to 13,100, Max ($100) above 13,100. Max’s much-quoted “200 credits per dollar” is real only at saturation, and half of it is a flex allotment GitHub reserves the right to change. For teams, the arithmetic is blunter: Business and Enterprise both charge exactly $5 per seat per month more than the cheapest individual route to the same credits. That $5 is the price of governance, and it is the only thing the seat plans sell you.
The ladder as GitHub publishes it
Every plan’s allowance is quoted as a base allotment plus a flex allotment. The last column is token spend returned per dollar of subscription, at GitHub’s stated rate of 1 credit = $0.01.
| Plan | Price | Base | Flex | Total credits | Token spend per $1 |
|---|---|---|---|---|---|
| Free | $0 | not published | Not included | ”limited chat and agent usage” | — |
| Pro | $10/mo | 1,000 | 500 | 1,500 ($15) | 1.50x |
| Pro+ | $39/mo | 3,900 | 3,100 | 7,000 ($70) | 1.79x |
| Max | $100/mo | 10,000 | 10,000 | 20,000 ($200) | 2.00x |
| Business | $19/seat/mo | not published | not published | 1,900 ($19), pooled | 1.00x |
| Enterprise | $39/seat/mo | not published | not published | 3,900 ($39), pooled | 1.00x |
Prices and allowances verified 24 October 2026 against GitHub’s plans page and the individual billing documentation. Code completions and next edit suggestions are not billed in credits and stay unlimited on every paid plan. GitHub publishes no annual price for any of these tiers; annual billing now appears in the docs only as a legacy grandfathering condition for subscribers who stayed on request-based billing after the June 2026 switch to usage-based billing.
Every tier returns exactly 1.00x on the credits GitHub guarantees
The individual ladder looks like a volume discount: 1.50x, 1.79x, 2.00x. Strip out the flex allotment — the half GitHub describes as variable — and the pattern that remains is the real architecture of the price list.
| Plan | Price | Base credits | Guaranteed token spend per $1 |
|---|---|---|---|
| Pro | $10 | 1,000 | 1.00x |
| Pro+ | $39 | 3,900 | 1.00x |
| Max | $100 | 10,000 | 1.00x |
| Business | $19/seat | 1,900 total | 1.00x |
| Enterprise | $39/seat | 3,900 total | 1.00x |
Every plan returns precisely its own price in guaranteed token spend. Nothing on Copilot’s price list is a volume discount; the whole apparent discount is the flex allotment, and GitHub is unusually candid about what flex is. The individual billing docs say it “is designed to adapt as the economics of AI evolve, including model pricing, new models, and improvements in efficiency,” and the marketing page shortens that to “Flex allotments may change over time.”
The uncomfortable corollary is that the tier with the best headline rate holds the most revocable allowance: flex is 33% of Pro’s total, 44% of Pro+‘s and 50% of Max’s. A Max buyer’s second hundred dollars of monthly capacity is entirely discretionary. This is not hypothetical — the promotional Business and Enterprise allowances of 3,000 and 7,000 credits expired on 1 September 2026, reverting to 1,900 and 3,900 with no change in seat price. Size your commitment on base credits and treat flex as a discount, not a quantity you have bought.
The switch points, computed
Because overage is $0.01 per credit on every plan — the same rate the allowance itself is denominated in — each plan’s cost curve is a flat fee followed by a straight line, and the crossovers fall out exactly. For a monthly burn of B credits, cost is price + $0.01 × (B − allowance).
| Monthly burn | Pro ($10) | Pro+ ($39) | Max ($100) | Buy |
|---|---|---|---|---|
| 1,500 | $10 | $39 | $100 | Pro |
| 3,000 | $25 | $39 | $100 | Pro |
| 4,400 | $39 | $39 | $100 | crossover |
| 7,000 | $65 | $39 | $100 | Pro+ |
| 10,000 | $95 | $69 | $100 | Pro+ |
| 13,100 | $126 | $100 | $100 | crossover |
| 20,000 | $195 | $169 | $100 | Max |
| 25,000 | $245 | $219 | $150 | Max |
Two things fall out of this table that the plan page does not tell you.
Pro stretches much further than it looks. Pro’s allowance is 1,500 credits, but Pro-plus-overage stays the cheapest plan all the way to 4,400 credits — nearly three times its own allowance. Exceeding your allowance is not a signal to upgrade. Exceeding it by 2,900 credits is.
Pro+ is a narrow window. It wins only between 4,400 and 13,100 credits a month. Outside that band it is never the right answer, which is a good deal narrower than a middle tier usually is.
Don’t pre-buy: start on Pro and let the meter upgrade you
The arithmetic above needs a number most buyers do not have before they start — their monthly credit burn. GitHub’s own upgrade mechanics make guessing unnecessary, and they are the most useful under-advertised thing on the billing page.
When you upgrade mid-cycle, GitHub states that “the upgrade cost is only the price difference between your current plan and the new plan,” and usage already consumed in that cycle counts inside the new, larger allowance. So a developer on Pro who has burned 5,000 credits by the 20th can upgrade to Pro+ for the $29 difference, and those 5,000 credits sit inside Pro+‘s 7,000 rather than being billed as overage. Total cost: $39 — exactly what they would have paid by correctly predicting Pro+ a month earlier.
That makes the optimal strategy for anyone unsure of their usage straightforward: start on Pro, watch the meter, and upgrade when you cross. You cannot do better than the minimum of the three curves, and this path reaches it without a forecast. The one thing to avoid is the reverse — buying Max in January because your December was heavy. Unused credits are forfeited at 00:00:00 UTC on the first of each month, on a fixed calendar date independent of your billing date, so an over-bought tier refunds nothing.
Teams: the seat premium is $5 per seat per month
Seat plans return 1.00x flat, which has produced a lot of loose commentary that Copilot Business is poor value. Priced properly — against the cheapest individual route to the same credits, including overage rather than against the next tier up — the premium is small and identical at both tiers.
| Seat plan | Price | Credits | Cheapest individual route to the same credits | Governance premium |
|---|---|---|---|---|
| Business | $19/seat | 1,900 | Pro $10 + 400 overage = $14 | $5/seat/mo |
| Enterprise | $39/seat | 3,900 | Pro $10 + 2,400 overage = $34 | $5/seat/mo |
Five dollars per seat per month — $60 per developer per year — is the entire price of moving from individual subscriptions to a governed deployment. For a 50-developer organisation that is $3,000 a year, which is less than the legal review of whether you need it.
What the $5 buys is specific, and GitHub documents the individual side of the line precisely: on the plan comparison, IP indemnity, enterprise-grade security, user management, usage metrics and SAML SSO authentication are each marked “Not included” for all four individual tiers (Free, Pro, Pro+ and Max), as is pooled usage. On the seat side, GitHub’s documentation states that “the Copilot Business and Copilot Enterprise plans provide the following level of support for content exclusion,” and describes Business as offering “centralized management and Copilot policy control for organization members,” with Enterprise adding “a larger monthly pool of AI credits, plus additional enterprise-grade capabilities.”
Pooling is the part with real cash value on a mixed team. Seat credits are pooled at the billing entity — GitHub’s worked example is 100 Business users sharing 190,000 credits “rather than 100 individual buckets” — so a light user’s unspent allowance subsidises a heavy colleague instead of being forfeited. On individual plans there is no pooling at all, so the light user’s 1,500 credits evaporate on the 1st while the heavy user pays overage. The more uneven your team’s usage, the more of the $5 you get back.
Two admin defaults deserve a calendar reminder rather than a footnote. Additional paid usage is enabled by default for organizations and enterprises — overspend is opt-out, not opt-in — and there is no automatic fallback to a lower-cost model when a budget is exhausted; the user is blocked, and a $0 user-level budget blocks them immediately.
The lever that beats every plan decision
Since June 2026 there are no model multipliers. Models bill at published per-million-token rates converted into credits, which means the spread between the cheapest and dearest model on the same plan dwarfs the spread between the plans themselves.
On a reference task of 200,000 input tokens — 150,000 of them cached — plus 30,000 output:
| Model on Copilot | Rate (in / cached / out per M) | Cost per task | Tasks on Pro ($15) | Tasks on Max ($200) |
|---|---|---|---|---|
| GPT-6 Luna | $0.10 / $0.01 / $0.50 | $0.0215 | ~698 | ~9,302 |
| Claude Haiku 5.5 | $0.10 / $0.01 / $0.50 | $0.0215 | ~698 | ~9,302 |
| MAI-Code-1.1-Flash | $0.20 / $0.02 / $1.20 | $0.0490 | ~306 | ~4,082 |
| Claude Sonnet 5.5 | $2.00 / $0.10 / $10.00 | $0.4150 | ~36 | ~482 |
| Claude Opus 5.5 | $4.00 / $0.20 / $20.00 | $0.8300 | ~18 | ~241 |
| Claude Fable 5.1 | $10.00 / $0.25 / $50.00 | $2.0375 | ~7 | ~98 |
| GPT-6 Astra | $10.00 / $1.00 / $50.00 | $2.1500 | ~7 | ~93 |
Rates verified 24 October 2026. The span from Luna to Fable 5.1 is about 95x on an identical task. The entire climb from Pro to Max buys 13x the capacity for 10x the money. Any plan decision you make is a rounding error next to habitually reaching for a frontier model on work a Flash-class model would finish — which is exactly what the model-choice arithmetic on Claude Code and the coding-tool cost comparison both land on. Two caveats on the cheap end: Claude Haiku 5.5 carries a 100,000-token long-prompt cliff that quintuples every rate in the request, which a large cached context will cross, and GPT-6 Luna’s own surcharge starts at 200,000 tokens. Check your context size before banking the saving.
GitHub also applies a 10% discount on model costs for paid plans using auto model selection — permanent, with no end date published, and applied whichever of the Efficiency, Balance or Intelligence tiers you select. A second, larger discount exists but attaches to a different thing than this page previously said: 30% off model costs when using Copilot Fusion, through 30 November 2026, available on any paid plan rather than on Max alone. It is a discount on a feature you choose to use, not a property of a tier, so it changes no plan’s capacity-per-dollar ranking — reach for Fusion and the 30% follows you down the ladder to a $10 Pro seat.
So which one
- Free — students and casual users. GitHub no longer publishes a credit number for it, only “limited chat and agent usage,” so it cannot be budgeted against.
- Pro, $10 — the default for any individual, and correct far longer than it looks: cheapest up to 4,400 credits a month. Still the lowest-priced credible paid tier in the category, against Cursor at $20 and Claude Code bundled with Claude Pro at $20. The full tier breakdown is in the Copilot review.
- Pro+, $39 — only between 4,400 and 13,100 credits a month. A narrow band; verify you are in it.
- Max, $100 — above 13,100 credits a month, and only if your bottleneck is volume of mechanical work rather than reasoning quality. Remember half the allowance is flex.
- Business, $19/seat — when you need pooled credits, policy control, content exclusion and SSO. You are paying $5 a seat for governance, not buying capacity.
- Enterprise, $39/seat — Business plus enterprise-grade capabilities and a larger pooled allowance, at the same $5 governance premium.
If you are weighing Copilot against the alternatives rather than picking a tier within it, Copilot vs Claude Code covers the published-allowance-versus-unpublished-limit trade, Copilot vs Cursor covers the editor question, and Cursor alternatives covers the wider field. Current plan prices across every vendor sit in the pricing tracker, and you can price a specific workload in the API cost calculator.
What changed
- 29 Oct 2026: Corrected the 30% discount claim. It applies to Copilot Fusion on any paid plan and runs through 30 November 2026 — not to Copilot Max’s auto model selection, and not expiring 28 October. The 2.86x effective return this page previously computed for Max was wrong and is withdrawn; Max returns 2.00x. The permanent 10% auto-selection discount is unaffected. Re-verified against GitHub’s auto model selection and individual billing docs; all seven seat prices, every credit allowance and the $0.01-per-credit rate unchanged, and a new Copilot access plan appears at $0 with a GitHub Enterprise Cloud licence or $10/user/month standalone, with no included allowance.
- 24 Oct 2026: Verified all six plan prices, both credit splits and the per-model rate card against GitHub’s plans page and billing docs — no price or allowance changed.
Frequently asked questions
Which GitHub Copilot plan should I buy?
It is decided by one number — how many AI credits you burn in a month — and the switch points are computable from GitHub's own figures, because overage is priced at the same $0.01 per credit on every plan. Below 4,400 credits a month, Copilot Pro at $10 plus overage is the cheapest option on the list. Between 4,400 and 13,100, Pro+ at $39 wins. Above 13,100, Max at $100 wins. The crossovers are exact rather than approximate: at 4,400 credits, Pro costs $10 + $29 of overage = $39, which is precisely the Pro+ price; at 13,100, Pro+ costs $39 + $61 = $100, precisely the Max price. If you do not know your burn, do not guess — start on Pro and upgrade mid-month, because GitHub charges only the price difference to upgrade and counts your already-consumed usage inside the larger allowance.
Is Copilot Max really the best value at 200 credits per dollar?
Only if you saturate it, and only for as long as GitHub chooses. Max's headline 2.00x comes from 20,000 credits for $100, but 10,000 of those are a 'flex allotment' rather than base credits. Strip the flex from every individual tier and the ratios collapse to something striking: Pro's 1,000 base credits for $10, Pro+'s 3,900 for $39 and Max's 10,000 for $100 are all exactly 1.00x — identical to Copilot Business and Enterprise. So GitHub guarantees every buyer precisely their money back in token spend, and the entire individual-ladder advantage sits in the discretionary half. The tier with the best headline rate is also the one with the most revocable allowance: flex is 33% of Pro, 44% of Pro+ and 50% of Max. The second catch is consumption. Credits do not roll over — GitHub states that unused credits are forfeited at 00:00:00 UTC on the first of each month — so a developer burning 600 credits on Max is getting 0.06x, not 2.00x.
Is Copilot Business cheaper than buying individual Pro seats for my team?
No, on capacity it is more expensive, and the gap is a flat $5 per seat per month at both seat tiers. Business is $19 per seat for 1,900 credits. Buying that same 1,900 credits on the individual ladder costs $14 — Copilot Pro at $10 plus 400 credits of overage at $0.01. Enterprise is $39 per seat for 3,900 credits; the cheapest individual route to 3,900 credits is again Pro at $10 plus 2,400 credits of overage, which is $34. Both seat plans therefore carry a governance premium of exactly $5 per seat per month. That is the real price of the thing you are buying, and at $60 per developer per year it is cheap for any company with a legal department — but it should be a deliberate purchase, not an assumption that the business tier comes with a volume discount. It does not.
What is the flex allotment, and can GitHub take it away?
The flex allotment is the variable half of your monthly credits. GitHub's individual billing documentation separates base credits, which it says are included with your subscription each month and 'never change,' from the flex allotment, which it describes as 'an additional monthly amount on top of your base credits.' The sentence that matters for budgeting is GitHub's own: the flex allotment 'is a variable part of your included usage; it is designed to adapt as the economics of AI evolve, including model pricing, new models, and improvements in efficiency.' The consumer plans page states the same thing more bluntly — 'Flex allotments may change over time.' Base credits are spent first, then flex. There is precedent for the downside: the promotional Business and Enterprise allowances of 3,000 and 7,000 credits expired on 1 September 2026 and reverted to 1,900 and 3,900 with no change in seat price. Budget against your base credits and treat flex as a discount that may be withdrawn.
Does switching models change my Copilot bill more than switching plans?
Far more — it is the largest single lever on the page, and it is free to pull. Since the June 2026 move to usage-based billing there are no model multipliers; models bill at published per-million-token rates converted to credits. On a reference task of 200,000 input tokens (150,000 of them cached) plus 30,000 output, GPT-6 Luna and Claude Haiku 5.5 both cost about $0.0215, while Claude Fable 5.1 costs about $2.04 — roughly 95 times as much for the same task. Copilot Pro's $15 allowance buys about 698 of those tasks on Luna and about 7 on Fable 5.1. No plan upgrade comes close to a 95x swing: the whole Pro-to-Max climb is 13x the capacity for 10x the money. Pick the cheapest model that passes your evals before you pick a bigger plan.
What should an organization watch out for on Copilot Business or Enterprise?
Three things, all of them spending controls. First, additional paid usage is enabled by default for organizations and enterprises, so an admin must actively disable the AI credits paid usage policy to prevent overspend rather than opting into it. Second, there is no automatic fallback to a cheaper model when a budget runs out — the user is simply blocked, and GitHub notes that a $0 user-level budget blocks that user immediately. Third, pooling cuts both ways: seat-plan credits are pooled at the billing entity, so 100 Business seats give a shared pool of 190,000 credits rather than 100 separate buckets, which protects heavy users but also means one team can quietly drain the pool. Adding licences mid-cycle grows the pool immediately; removing them does not shrink it until the next cycle. Copilot code review is also billed twice over — credits for tokens plus GitHub Actions minutes for the agentic infrastructure — and GitHub states its model 'is selected automatically and is not disclosed.'