GitHub Copilot pricing in 2026: what one AI credit actually buys

Contents

How much does GitHub Copilot cost?

Between nothing and $100 a month, across seven plans. But the number that decides your bill is not on the pricing page in dollars at all.

G

Since 1 June 2026, Copilot bills in GitHub AI Credits. The subscription price buys an allowance, and how far that allowance stretches depends on which model you point at. Two developers on the same $10 plan can get wildly different amounts of work out of it. Here is the full ladder as it stands today:

Plan	Price	Included credits
Copilot Free	$0	None; 2,000 completions a month
Copilot Student	Free	Verified students, teachers, OSS maintainers
Copilot Pro	$10/user/month	$15 (1,500 credits)
Copilot Pro+	$39/user/month	$70 (7,000 credits)
Copilot Max	$100/user/month	$200 (20,000 credits)
Copilot Business	$19/granted seat/month	$19 baseline (1,900 credits)
Copilot Enterprise	$39/granted seat/month	$39 baseline (3,900 credits)

Two details in that table are easy to skim past and expensive to miss.

The first is granted seat. Business and Enterprise do not bill per employee, they bill per seat an admin actually grants. A 200-person engineering org that grants 60 seats pays for 60. That is more forgiving than most per-seat developer tooling, and it means the cost of a Copilot rollout is something you control directly rather than something your headcount decides.

The second is that the included credits on the individual plans are worth more than the plans cost. Pro is $10 and carries $15 of credits. That is not a rounding artefact, and it is not what GitHub originally announced. I will come back to it, because it is the most under-reported thing about this pricing.

What actually changed on 1 June 2026

GitHub replaced premium request units with AI credits. The sticker prices did not move — its announcement is explicit that Pro remains $10, Pro+ $39, Business $19 and Enterprise $39 — but the meter underneath them was swapped out entirely.

Under the old model you bought a count of premium requests. A request was a request regardless of how much work it involved, which meant a one-line question and a forty-file refactor drew down the same allowance. Under the new model you are billed on token usage: input, output and cached tokens, priced per model at published API rates and converted into credits.

	Before 1 June 2026	After
The unit	Premium request units	AI credits, $0.01 each
What it measures	One request, whatever its size	Input, output and cached tokens
Model choice changes cost	No	Yes, by up to fifteen times on output
When you run out	Fall back to a cheaper model	Agentic features stop
Code completions	Included	Still included, still unmetered

That is a fairer meter and a much less predictable one. It is also why the reaction was loud. The top Reddit thread on Copilot pricing calls the change a cost increase disguised as flexibility, and the sentiment across developer forums through June was consistently hostile. Some of that is the ordinary friction of any metered product replacing a flat one. Some of it is a specific, legitimate complaint I will get to below.

One change did unambiguously remove something you used to have. Previously, exhausting your premium requests dropped you to a lower-cost model so you could keep working. GitHub’s announcement states that fallback experiences are no longer available and usage is now governed by available credits and admin budget controls. The soft landing is gone. You now hit a wall instead of a slope.

There is one more piece of context worth knowing, because it explains why some people could not buy the product at all this summer. GitHub paused new sign-ups for Student, Pro, Pro+ and Max over what it described as abuse patterns, and reopened them gradually from 16 June 2026. If you tried to subscribe in early June and could not, that is why.

How AI credits actually work

Here is the line that makes the whole model computable, buried in GitHub’s billing reference:

1 AI credit = $0.01 USD

Everything else follows from that. Your Pro plan does not include a mysterious allowance, it includes 1,500 credits, which is $15 of model spend at published API rates. Pro+ includes 7,000. Max includes 20,000. And because the per-model rates are published too, you can work out what any given piece of work will cost before you run it.

Model	Input /1M	Cached input /1M	Output /1M
GPT-5 mini	$0.25	$0.025	$2.00
Gemini 3.6 / 3.7 Flash	$0.75	$0.075	$3.75
Claude Haiku 4.5	$1.00	$0.10	$5.00
Claude Sonnet 5	$2.00	$0.20	$10.00
GPT-5.4	$2.50	$0.25	$15.00
Claude Sonnet 4.6	$3.00	$0.30	$15.00
Claude Opus	$5.00	$0.50	$25.00
GPT-5.5	$5.00	$0.50	$30.00

Read the output column, because on agentic work output tokens dominate. A million output tokens on GPT-5 mini costs $2.00, or 200 credits. The same million on GPT-5.5 costs $30.00, or 3,000 credits. That is fifteen times the price for the same token count, and it is entirely under your control via the model picker.

It also means a Pro subscription can be exhausted by a single sustained session. One million output tokens on a Claude Opus model is $25.00, or 2,500 credits, against the 1,500 credits a Pro month contains. You can spend more than a month’s allowance inside one long agent run without doing anything unusual.

What does not cost you anything

This is the part the angry threads mostly skip, and it changes the picture for most people.

GitHub’s documentation states that code completions and next edit suggestions are not billed in AI credits and remain unlimited for all paid Copilot plans. That is the grey inline autocomplete you accept with Tab a hundred times a day. It is the feature that made Copilot famous, it is what most subscribers use it for, and it is uncapped at $10 a month.

Credits are consumed by the agentic surfaces: chat, agent mode, code review, the cloud agent, the CLI, and Copilot Apps. So the honest summary is that Copilot’s pricing bifurcated. If you use it as smart autocomplete, the June change barely touched you and $10 buys the same thing it always did. If you use it as an autonomous agent, you are now on a metered API plan wearing a subscription’s clothing.

What one real build costs in credits

I run every coding tool through the same brief: a subscription-tracker web app with six specific requirements, given verbatim, no follow-up prompts. It is how I compare tools on something other than their own marketing. Copilot did it in about a minute and produced 468 lines, and it scored the same 6/6 on requirements as every other tool I have given it to.

That run was on the free tier, so I have no measured credit drain to report from it, and I am not going to invent one.

What I do have is the same brief run through Claude Code, where the bill was $2.56 in direct Anthropic API billing. Because GitHub converts token spend to credits at a published $0.01 each, that is the closest honest estimate available of what a comparable agent build would draw:

$2.56 of model spend is 256 credits. Copilot Pro includes 1,500. One small app, built once, is about a sixth of the month.

Treat that as an order of magnitude rather than a measurement — different model, different harness, different token efficiency, and Copilot’s own agent may well be leaner or heavier. But the shape is right, and the shape is the point. Five or six agent builds of that size is a Pro month. If your mental model is still “a subscription I pay once and use freely”, the arithmetic will surprise you the first time, which is precisely what happened to a lot of people in June.

Scale it up and the tiers start to make sense. Pro+ at $39 carries 7,000 credits, so roughly twenty-seven builds of that size. Max at $100 carries 20,000, or about seventy-eight. Those are not small numbers if your agent work is occasional. They are alarmingly small if you are running agents continuously.

The credits are worth more than the plan costs

GitHub’s April announcement said monthly plans would include credits aligned to their price — Pro gets $10 of credits for $10. That is not what the pricing page says today.

Read live on 16 August 2026, Pro is $10 with $15 monthly total credits, Pro+ is $39 with $70, and Max is $100 with $200. Every individual tier now includes more model spend than it charges, and the gap widens as you go up: $1.50 of credits per dollar at Pro, $1.79 at Pro+, and $2.00 at Max.

I have not seen this stated anywhere else, and Google’s own AI Overview for this keyword still hedges it as “$10–$15 in monthly AI credits”, which is what happens when a summariser reads an April announcement and an August pricing page and cannot reconcile them.

Two practical consequences. First, if you are going to run agents at all, the higher tiers are not merely bigger, they are better value per dollar of actual model access — Max gives you a third more credit per dollar than Pro does. Second, any article quoting Pro as including $10 of credits is describing the announcement rather than the product. Check the date on anything you read about this, including this post.

The cliff teams hit this September

If you administer a Business or Enterprise org, this is the section that matters, and it is time-sensitive as I write it.

When GitHub moved to usage-based billing it gave existing organisation customers expanded credits as a transition cushion: Business accounts get $30 a month of credits against a $19 baseline, and Enterprise gets $70 against $39. Those promotional amounts run through August 2026.

Org plan	Credits through Aug 2026	Baseline from Sept	Change
Copilot Business	$30/seat	$19/seat	−$11 per seat
Copilot Enterprise	$70/seat	$39/seat	−$31 per seat

No price changes. The seat cost stays at $19 and $39. What changes is that a Business seat’s monthly credit pool drops by $11 and an Enterprise seat’s by $31, which means whatever usage pattern your team settled into over the summer was running on a cushion that is about to deflate.

If you have been watching credit consumption since June and concluding your team fits comfortably inside the allowance, re-run that maths against the baseline numbers before September rather than after. A team that has been finishing the month at 70% of its Business allowance is at 110% of the real one.

One exception worth checking: GitHub stated that customers on annual plans keep premium request pricing until their subscription expires. If your org bought an annual commitment before June, you may still be on the old model entirely, and the credit arithmetic in this post will not apply to you until renewal.

Where Copilot bills go wrong

Four specific failure modes, all of them documented rather than speculative.

Risk	What GitHub says	What to do about it
No fallback model	”Fallback experiences will no longer be available”	Watch the pool mid-month, not at month end
Spend limits undisclosed	Vary by “usage patterns, billing history, and verification state”	Assume your ceiling is lower than you think
No stated rollover	No mention in the FAQ or billing docs	Buy for a normal month, not a peak one
Model choice drives the bill	Rates published per model, no in-product warning	Explore on a cheap model, finish on an expensive one

The fallback is gone, so you stop dead. This is the change that generated the most legitimate anger. Running out used to mean a downgrade to a cheaper model; now it means the agentic features stop until you pay. For an individual that is an annoyance. For a team on a shared pool it is worse, because one person’s heavy session can exhaust an allowance several other people were relying on.

The spending limits are deliberately undisclosed. GitHub’s FAQ says default limits vary by plan tier and account signals including usage patterns, billing history and verification state, and then says plainly that it cannot disclose specifics because it would help bad actors circumvent the safeguards. That is a defensible anti-abuse position and a genuinely awkward one for budgeting. You cannot fully predict where your account’s ceiling sits.

Nothing suggests credits roll over. GitHub’s FAQ and billing documentation make no mention of unused credits carrying into the next month. Absent a statement otherwise, plan on a use-it-or-lose-it allowance, which argues against buying a higher tier for a workload that is spiky rather than sustained.

Model choice is the whole bill, and the picker does not warn you. The difference between drafting with GPT-5 mini and drafting with GPT-5.5 is fifteen times the output cost, and nothing in the interface tells you that at the moment you choose. If you take one operational habit from this post, make it this: use a cheap model for exploration and iteration, and switch to an expensive one only for the work that genuinely needs it.

Which plan should you actually buy?

Copilot Free, if you mostly want autocomplete. 2,000 completions a month is more than casual use requires, it includes the CLI and agent mode, and it needs no card. My own six-requirement build ran on it. Start here and let the ceiling tell you when to move.

Copilot Pro at $10, for almost everyone who codes daily. Unlimited completions and next edit suggestions, model selection, cloud agent and code review, $15 of credits, and access to third-party agents including Claude Code and Codex. That last item is genuinely unusual — a $10 plan that fronts two rival vendors’ agents is better value than it sounds, and it is worth reading alongside our Claude Code vs Copilot comparison and Copilot vs Codex before you buy either separately.

Copilot Pro+ at $39, if you run agents most days. 7,000 credits, premium models including Opus, and a better rate per dollar than Pro. The jump is only worth it if you are actually hitting Pro’s ceiling — check your usage before you upgrade, not after.

Copilot Max at $100, only for continuous agent work. 20,000 credits and the best value per dollar of any tier, but $100 a month is a real commitment for an allowance that appears not to roll over. If you are here, compare it honestly against paying an API bill directly, because at this volume the subscription is mostly a convenience wrapper over metered access you could buy elsewhere.

Students and OSS maintainers: verify your status and take Pro free. It is the same $10 plan, and it is the best deal in this entire category.

If none of those fit, the alternatives are worth a look — we compared the field in the best AI coding tools and in GitHub Copilot alternatives.

Final word

GitHub Copilot’s pricing is not expensive. It is unpredictable, and those are different complaints that got merged into one during June.

The sticker prices are the same as they were, the free tier is real, autocomplete is still unmetered on every paid plan, and the individual tiers now include more model spend than they charge — which is a better deal than GitHub originally announced and better than most of the internet currently believes. If you use Copilot the way most people use Copilot, none of the June drama applies to you.

The unpredictability is real too, and it lands entirely on agentic use. A single long session on an expensive model can outrun a Pro month. There is no soft landing when it does, no published ceiling to plan against, and no apparent rollover to reward restraint. Teams have one more concrete thing to handle: the transition credits expire this month, and September’s allowance is materially smaller than the one you have been budgeting against since June.

Do the arithmetic once. One credit is a cent, your plan is a number of cents, and the model picker decides how fast you spend them. Everything else about this pricing follows from that.