GitHub Copilot Usage-Based Billing: How AI Credits Work & How to Control Costs

Read time: ~8 minutes. What you’ll learn: what actually changed when GitHub Copilot moved to usage-based billing on June 1, 2026, how GitHub AI Credits map to dollars and token usage, how many credits each plan includes, what still costs nothing, how to set a budget so you never get a surprise bill, and how annual subscribers are handled.

Sourcing note: every figure below is from GitHub’s own usage-based billing announcement and Copilot plans docs. A lot of third-party “pricing 2026” posts have the credit numbers wrong (more on that below) — these are GitHub’s stated figures. Links at the bottom.

If you opened your GitHub billing page recently and saw “AI Credits” instead of the familiar premium-request counter, you’re not imagining it. On June 1, 2026, every GitHub Copilot plan moved to usage-based billing. Premium request units (PRUs) are gone. This guide is the practical version: what it means for your bill, what still costs nothing, and how to set a budget so a runaway agent loop doesn’t cost you $200.

1. What actually changed

The old model counted premium requests — a fixed allowance of “premium” model calls per month, then a flat per-request overage. That’s been replaced by GitHub AI Credits, consumed by token usage.

  • Premium requests (PRUs) → GitHub AI Credits. Your monthly allowance is now denominated in credits, not request counts.
  • Usage is metered on tokens. Per GitHub: “Usage will be calculated based on token consumption, including input, output, and cached tokens, using the listed API rates for each model.” So a long chat with a big file context costs more than a short one — exactly like calling a model API directly.
  • More expensive models burn credits faster. Because it’s token-based at each model’s API rate, picking a frontier model for everything drains credits faster than using a cheaper model for routine edits.

The mental model shift: you’re no longer counting “requests,” you’re spending a dollar-denominated credit balance on tokens, just like any metered API.

2. The plans and how many credits you get

Here’s the part the third-party posts keep getting wrong. GitHub’s stated rule: each monthly plan includes AI Credits equal to its price.

PlanMonthly priceIncluded AI Credits
Free$0small monthly allowance
Pro$10$10 in credits
Pro+$39$39 in credits
Max$100(see official plans page)
Business$19 / seat$19 in credits
Enterprise$39 / seat$39 in credits

A few things worth knowing:

  • The credits equal your subscription price on the monthly plans — your $10 Pro plan gives you $10 of metered usage to spend. If you see a post claiming Pro includes “$15” or Pro+ “$70,” that’s wrong or it’s quoting a promo.
  • The real promo: existing Business customers get $30 in monthly credits (instead of $19) through August 2026; Enterprise gets $70 (instead of $39) over the same window. That $70 is where the bogus “Pro+ $70” number in some posts comes from — it’s the Enterprise promo, not a Pro+ figure.
  • Paid plans can buy additional usage beyond the included credits (subject to your budget — see §5).

3. What still costs you nothing (read this before you panic)

This is the single most reassuring fact and it’s easy to miss:

Code completions and Next Edit suggestions remain included in every plan and do NOT consume AI Credits. (Source: GitHub blog)

So the autocomplete-style “ghost text” you use all day — the thing most people think of as “Copilot” — is free and unmetered. Credits are consumed by the premium stuff: chat, agent mode, multi-step tasks, and frontier-model calls. If you mostly use tab-completion, your credit burn will be near zero. If you live in agent mode running long autonomous tasks, that’s where the meter spins.

4. How credits actually get consumed

Since it’s token-based, the cost of any single interaction depends on three things:

  1. The model you pick. Each model has its own per-token API rate. A frontier model can cost many times what a smaller model costs for the same conversation. Choosing the right model for the task is now the biggest cost lever you have.
  2. Context size. Input tokens count — including cached tokens. Stuffing a huge codebase into context every turn costs real credits. Keeping context tight (and letting caching work) keeps the bill down.
  3. Output length + step count. Agent loops that run many steps, each producing output, multiply token usage. A 20-step autonomous task costs far more than a single chat answer.

Practical takeaway: use tab-completion (free) for routine work, reach for chat/agent on the cheapest model that’ll do the job, and save frontier models for genuinely hard problems. This is the same discipline that makes a metered model API affordable — see our breakdown of DeepSeek V4 Pro’s cache/price math for the same logic applied to raw API costs.

5. How to set a budget (so you never get a surprise bill)

This is the step most people search for after the change — “how do I cap this?” GitHub gives you budget controls; set one before you turn an agent loose.

  • Set a budget with alert thresholds. You can configure budgets that alert you at 75%, 90%, and 100% of the limit, so you get warned before you blow through it.
  • Choose: cap or allow overage. Admins can decide whether usage stops at the budget or is allowed to overspend — pick “cap” if a predictable bill matters more than uninterrupted access.
  • Budgets are layered (for orgs). Business and Enterprise admins get budgets at the enterprise, cost center, and user levels, drawing from pooled credits.
  • The $0 trick. Setting a user budget of $0 disables Copilot premium usage for that user entirely — useful for locking down seats you don’t want spending.

Set these in your billing settings on github.com before a big agent run. A $0-or-low budget on a test account is also the safest way to experiment with agent mode without risking a surprise charge.

6. If you’re on an annual plan, you’re (temporarily) exempt

GitHub handled annual subscribers differently:

  • Annual Pro / Pro+ subscribers stay on the old premium-request billing until their plan expires — you are not force-migrated to credits mid-term.
  • But model multipliers increased on June 1 for annual subscribers, so the same premium request can cost more PRUs than before.
  • When your annual plan expires, you transition to Copilot Free, or you can convert early and get prorated credits.

So if your bill math suddenly changed and you’re on annual, it’s the multiplier bump, not the credit system — you’re still on requests for now.

7. See your costs before they hit

GitHub shipped a preview bill experience in early May 2026, available on your Billing Overview page when you log into github.com. It projects your costs under the new model so you can see what a typical month would run before it bills. If you haven’t looked, do — it’s the fastest way to find out whether you’re a “near-zero burn” tab-completion user or an “agent mode is eating my credits” user.

When this bites — and the one-line defense

The usage-based model bites hardest if you: live in agent mode, default every chat to a frontier model, or push huge context every turn — and never set a budget. The Visual Studio dev community’s blunt summary of the change was “you will get less, but pay the same price,” and for heavy premium users that’s directionally fair.

The one-line defense: set a budget with a cap, lean on free tab-completion, and pick the cheapest model that does the job. Do that and usage-based billing is a non-event; skip it and a single runaway agent run can clear your monthly credits in an afternoon.

The takeaway

GitHub Copilot’s June 1, 2026 switch to usage-based billing replaces premium requests with dollar-denominated AI Credits charged on token usage. Your monthly plan includes credits equal to its price ($10 Pro, $39 Pro+, $19/$39 Business/Enterprise), tab-completion stays free, and the premium spend comes from chat/agent/frontier-model usage. The two things to do today: check the preview bill to see your real burn, and set a budget with a cap so you control the meter instead of it controlling you. Annual subscribers stay on the old request model until renewal — just with higher multipliers since June 1.

For the broader “how to keep a coding-agent setup cheap” picture, see Claude Code as a daily driver and the Cursor Composer 2.5 guide; for the raw-API version of the same cost math, DeepSeek V4 Pro.

Sources