On June 1, 2026, GitHub quietly rewired how you pay for Copilot. The old "premium requests" quota — a fixed number of advanced-model interactions per month — is gone. In its place is GitHub AI Credits, a usage-based system where 1 credit = $0.01 USD and your bill tracks how many tokens you actually consume. If you opened your billing page recently and saw "AI credits" where a request counter used to be, this is why.
The good news up front: for most developers, day-to-day Copilot doesn't cost a cent more, because code completions stay unlimited. The change only matters if you lean hard on chat, agents and premium models — and if you do, it can now run past your included allowance. Here's exactly how the new billing works, what each plan includes, and how to keep it from surprising you.
Key takeaways
- What changed: premium requests → AI Credits on June 1, 2026. 1 credit = $0.01, consumed by token usage (input + output + cached).
- Still free & unlimited: code completions and next-edit suggestions on every paid plan. Credits only burn on chat, agents, code review, CLI and Spaces.
- Included pool: Pro $15 · Pro+ $70 · Max $200 · Business 1,900 credits ($19)/user · Enterprise 3,900 credits ($39)/user.
- Run out? Overage is pay-as-you-go at $0.01/credit — unless an admin caps it with a budget.
- Right now: existing Business/Enterprise customers get a promo boost (~$30 / ~$70 in credits) through August 2026.
What Actually Changed on June 1, 2026
Under the old model, each message you sent to an advanced model counted as one premium request against a fixed monthly quota, with different models carrying different "multipliers." It was simple to count but blunt: a one-line question and a massive multi-file refactor cost the same one request.
The new model bills by consumption. Every credit is worth $0.01, and GitHub deducts credits based on the tokens a request uses — input, output and cached — priced at each model's published API rate. A quick prompt to a cheap model costs a fraction of a credit; a long agent run on a top-tier model costs several. It's the same shift the rest of the industry already made: you now pay for what you use, not for a round-number allowance. If you've ever reasoned about the price of an API call, this will feel familiar — and if you haven't, our Token Calculator is a quick way to see what "a few thousand tokens" actually costs.
AI Credits by Plan (2026)
Prices are per user per month. "Included credits" is the monthly AI-credit pool bundled with the seat; remember 1 credit = $0.01, so the dollar value and the credit count are the same number ×100.
| Plan | Price / user / mo | Included AI credits | Who it's for |
|---|---|---|---|
| Free | $0 | Limited chat/agents | Trying it out |
| Pro | $10 | $15 (1,500) | Individual devs |
| Pro+ | $39 | $70 (7,000) | Power users |
| Business | $19 | 1,900 ($19) | Teams |
| Enterprise | $39 | 3,900 ($39) | Orgs on Enterprise Cloud |
| Max | $100 | $200 (20,000) | Heavy agent workloads |
Two details are worth pausing on. First, the individual plans bundle more credit value than their sticker price — Pro costs $10 but includes $15 of credits, Pro+ is $39 for $70, Max is $100 for $200. The seat fee buys you the product; the credits are a usage allowance layered on top. Second, the team plans give credits equal to the seat price (Business $19 → 1,900 credits, Enterprise $39 → 3,900), which are dollar-for-dollar rather than discounted.
Promo window (you're in it): through August 2026, existing Business and Enterprise customers get a boosted allowance — roughly $30 (Business) and $70 (Enterprise) in monthly credits — to cushion the transition. It reverts to the standard $19 / $39 pools afterward, so budget for the lower number when you plan for the autumn.
What Uses Credits — and What Doesn't
This is the part that decides whether the change touches your wallet. GitHub split Copilot's features into two buckets:
- Free and unlimited (no credits): code completions and next-edit suggestions. The inline grey-text autocomplete you use constantly, all day, in your editor — it doesn't draw from the pool at all on paid plans. For a huge share of developers, this is Copilot, which is why they'll never notice the billing change.
- Credit-consuming: Copilot Chat, coding agents, code review, the Copilot CLI, and Spaces. These are the model-heavy, multi-turn, large-context features — and the more tokens they push, the more credits they cost. Bigger context windows, longer agent runs and pricier frontier models all spend faster.
A rough way to reason about it: a Business seat's 1,900 credits is $19 of model usage per month. A short chat exchange on an efficient model might cost a fraction of a credit; a long, autonomous agent task that reads a big chunk of your repo and writes a lot of output on a premium model can cost several credits in one go. Light users won't come close to the pool; someone running agents against a large codebase for hours a day can absolutely blow through it. If your team's Copilot use is completion-first, you're fine. If it's chat- and agent-first, do the math before you assume the flat fee still covers you — the Token Calculator lets you sanity-check a typical request in seconds.
What Happens When You Run Out
When the included pool is gone, extra usage is billed pay-as-you-go at $0.01 per credit. There's no hard wall by default — which is convenient for productivity and dangerous for budgets. GitHub's answer is budget controls: admins can set spending limits at the user, cost-center and enterprise level. Set a budget to zero and premium features simply stop when the included credits run out; set a cap and you'll never be surprised by the invoice. Completions keep working either way, because they never touch the pool.
If you administer seats, the practical move is to turn on budgets before the promo allowance expires in September, so a team that got used to the boosted pool doesn't quietly slide into overage when it drops back to the standard amount.
Should This Change Which Plan You Pick?
Mostly, no — the flat seat prices didn't move, and the plan you'd have chosen a month ago is still the plan you'd choose today. What AI Credits change is the ceiling, not the entry price. A few honest rules of thumb:
- Completion-first individual devs: Pro at $10 is still the sweet spot, and the $15 credit bundle is more headroom than most solo users will touch.
- Chat- and agent-heavy individuals: Pro+ ($70 of credits) or Max ($200) exist precisely because power users kept hitting the old caps — now they hit a credit pool instead, and these tiers front-load a bigger one.
- Teams: the Business vs Enterprise decision is still about governance and codebase features, not credits — the pools just scale with the seat price. If you're weighing those two, we break the whole thing down in GitHub Copilot Business vs Enterprise.
- Not sure Copilot is even the right assistant? The usage-based turn makes it worth re-checking against a dedicated AI editor before you commit — see Cursor vs GitHub Copilot, or start from the individual GitHub Copilot plan.
The Bigger Picture: Everyone's Metering Tokens Now
Copilot's move isn't unusual — it's the whole industry converging on token-metered pricing. Once you're paying by tokens, the smart question stops being "which subscription?" and becomes "what does my workload actually cost per token, on which model?" That's exactly the lens that makes tools like the raw model APIs worth comparing: for some heavy, scripted workloads, calling a model directly (for example via the Anthropic API) can be cheaper than a seat-plus-credits plan — and for interactive, in-editor coding, a bundled plan like Copilot is usually the better deal. Knowing your token footprint is what lets you tell the two apart.
The honest take: don't panic about AI Credits. If your team lives in code completions, this is a non-event with a new label on the billing page. If you run agents and chat hard, treat the credit pool like a real budget line: measure your token usage, turn on spending controls, and plan for the standard allowance rather than the promo. And if you're still deciding what to standardize your team on, Pickurai's free wizard narrows the field in six questions.
Frequently Asked Questions
What are GitHub Copilot AI Credits?
GitHub AI Credits are the usage-based currency that pays for Copilot's AI features. One AI credit equals $0.01 USD. They went live on June 1, 2026, replacing the old premium request model. Credits are consumed when you use Copilot Chat, coding agents, code review, the Copilot CLI and Spaces, and the amount depends on token usage — input, output and cached tokens — at each model's published API rate. Code completions and next-edit suggestions do not use credits.
How many AI credits does each GitHub Copilot plan include?
Copilot Free includes only limited chat and agent usage. Pro ($10/mo) includes $15 in credits (1,500), Pro+ ($39/mo) includes $70 (7,000), and Max ($100/mo) includes $200 (20,000). For teams, Business ($19/user/mo) includes 1,900 credits ($19) per user and Enterprise ($39/user/mo) includes 3,900 credits ($39) per user. From June to August 2026, existing Business and Enterprise customers get a higher promotional allowance (about $30 and $70 in monthly credits).
Do GitHub Copilot code completions use AI credits?
No. Code completions and next-edit suggestions — the inline autocomplete most developers use all day — are not billed in AI credits and stay unlimited on every paid plan. Credits are only consumed by the heavier features: Copilot Chat, coding agents, code review, the CLI and Spaces. That's why most light users will never touch their credit pool.
What happens when you run out of GitHub Copilot AI credits?
Once your included monthly pool is used up, extra usage is billed pay-as-you-go at $0.01 per credit. Admins can prevent surprise bills with budget controls at the user, cost-center and enterprise level; set a budget to zero and premium usage stops instead of overspending. Code completions keep working regardless, because they never draw from the pool.
What replaced premium requests in GitHub Copilot?
AI Credits replaced premium requests on June 1, 2026. The old system counted each advanced-model interaction as one "premium request" (with per-model multipliers) against a fixed quota. The new system bills by actual token consumption converted to credits at $0.01 each — more granular and transparent, but it also means heavy users can exceed their allowance and pay overage.
Is GitHub Copilot cheaper or more expensive under AI Credits?
For most developers, nothing changes: the flat seat price is identical and everyday completions stay unlimited. Light chat users rarely exhaust their pool. The people who feel it are heavy users of agents, large-context requests and premium models, whose token consumption can trigger overage at $0.01/credit. Whether it costs you more depends on how much high-token, model-heavy work you do — which you can estimate with a token calculator before rolling it out to a team.