GitHub Copilot Usage-Based Billing Explained: Everything You Need to Know

Last updated: June 6, 2026

The billing change matters because GitHub Copilot is no longer just an autocomplete tool. In 2026, teams use Copilot for full conversations, PR reviews, agent mode, terminal tasks, repository reasoning, and long-running cloud agent sessions. A pricing system that treats every advanced interaction as a flat request no longer reflects how much compute each task really uses. That is why GitHub moved to a usage-based model built around AI Credits.

If you manage licenses, budgets, or developer tooling, understanding this change is important before you assign seats or set policies. If you are comparing Copilot Business and Copilot Enterprise, or evaluating seat economics on the pricing page, this guide explains the billing model in plain English.

What Was Request-Based Billing?

Before June 1, 2026, GitHub measured advanced Copilot usage with a request-based billing system. In practice, each premium interaction consumed a billing unit often described by customers as a Premium Request Unit or PRU. You would send a prompt, Copilot would answer, and the request counter would go down.

The old system was easy to explain, but it had an important limitation: not all requests are equal. A short question in chat and a deep multi-step agent workflow could both start as a single prompt, even though the second one might involve much more model work behind the scenes.

How the old model worked

• Each advanced interaction counted as a premium request.
• More expensive models applied a multiplier, so one interaction could deduct multiple request units.
• Some features had fixed request costs that felt predictable at first, but became less intuitive as Copilot became more agentic.
• On legacy annual plans, only the prompts you sent counted as premium requests; autonomous tool actions taken by Copilot during agentic flows did not directly count as separate requests.

That legacy model still matters because it did not disappear for everyone overnight. GitHub's documentation says the old request-based system now applies only to certain existing annual Copilot Pro and Copilot Pro+ subscribers who remained on legacy billing after June 1, 2026. In other words, legacy request billing is now the exception, not the standard.

Think of request-based billing as a quota system for prompts. It was workable when Copilot was mostly chat and suggestion driven, but it became less accurate once Copilot started acting more like an agent.

One reason many teams found the old model confusing was the multiplier logic. A request was not always just a request. A more advanced model could consume more of your allowance than a cheaper model. GitHub even documented special legacy behaviors, such as a higher multiplier for certain code review actions under request-based billing. That made budgeting harder for admins who wanted usage to map directly to real cost.

What Is Usage-Based Billing?

Usage-based billing replaces request counting with a more granular model. Instead of asking, “How many premium prompts did a user send?”, GitHub now asks, “How much model work was actually performed?”

Under the new system, Copilot usage is measured in AI Credits. GitHub calculates how many tokens were used in an interaction and converts that into credits. The published rule is straightforward: 1 AI Credit = $0.01 USD.

Why tokens matter

GitHub describes three token categories that can contribute to usage:

• Input tokens — the prompt, file context, code, and instructions you send to the model.
• Output tokens — the response the model generates.
• Cached tokens — reused context that can still contribute to billing depending on the model and feature.

The final cost depends on two things: the model used and the number of tokens consumed. A quick chat answer on a lightweight model might cost a fraction of a credit. A longer task in agent mode, or a code review that analyzes broad repository context, can cost noticeably more because it uses more tokens and sometimes more capable models.

This is the key conceptual shift: billing is now tied to work performed, not just interaction count. That is why the new model is better suited for agentic products like cloud agents, code review, Spaces, and CLI workflows.

How AI Credits Work Per Plan

Each plan now includes a monthly AI Credit allowance. For organizations, the included credits are especially important because they are pooled across the billing entity rather than locked into individual user buckets.

Plan	List Price	Included AI Credits	How it works
Copilot Pro	$10/month	1,000 base credits	Individual plan. GitHub also describes an additional flex allotment above the base amount on supported monthly usage-based plans.
Copilot Pro+	$39/month	3,900 base credits	Individual power-user plan with higher included usage and access to premium models.
Copilot Business	$19/user/month	1,900 per user, pooled	Every assigned license adds to a shared pool at the org or enterprise billing level.
Copilot Enterprise	$39/user/month	3,900 per user, pooled	Larger pooled allowance with enterprise-grade controls and broader GitHub integration.

Important nuance: on individual monthly plans, GitHub's usage-based billing documentation also describes a flex allotment on top of base credits. That means Copilot Pro and Pro+ users may see a larger total monthly allowance than the base figures above. For Business and Enterprise, GitHub documents 1,900 and 3,900 total monthly AI credits per assigned user respectively, pooled at the billing level.

There is also a short-term transition benefit for existing Business and Enterprise customers. GitHub documented higher promotional amounts from June 1 to September 1, 2026: 3,000 credits per user for Business and 7,000 per user for Enterprise. After that window, the standard pooled amounts return.

What Consumes Credits?

Not every Copilot feature draws from your AI Credit balance, but the advanced ones do. The features most likely to consume credits are the ones that rely on model reasoning, large context windows, or autonomous multi-step execution.

• Copilot Chat in supported IDEs and GitHub surfaces.
• Agent mode when Copilot plans, edits, runs, or iterates across multiple steps.
• Copilot code review, including pull request reviews and supported IDE review experiences.
• Copilot CLI interactions in the terminal.
• Copilot cloud agent sessions working through larger tasks.
• Copilot Spaces and other AI-powered knowledge or workspace experiences.

Why do these features cost credits? Because they involve real model usage. A single code review can inspect multiple files, pull project context, generate explanations, and propose fixes. A cloud agent session can make repeated model calls, reason over repository state, and keep context alive over a longer workflow. Billing those actions by token usage is more representative than charging every action as a flat request.

What makes one task more expensive than another?

• Model choice: frontier models cost more than lightweight models.
• Prompt size: more files, more repo context, and longer conversations increase tokens.
• Agentic depth: multi-step tasks usually involve repeated model calls.
• Review effort: deeper code reviews can consume more credits than quick passes.

What Stays Free?

The reassuring part of this change is that GitHub did not put everyday coding assistance behind a metered wall on paid plans. According to the usage-based billing documentation, code completions and Next Edit Suggestions are not billed in AI Credits and remain unlimited for paid Copilot plans.

That matters because many developers still experience Copilot primarily through inline coding help. If your team mostly uses completions while occasionally using chat or code review, the new system does not suddenly meter every keystroke. The metering applies to the more compute-heavy AI features, not routine autocomplete.

So if your biggest worry is, “Will my developers burn credits just by accepting suggestions all day?” the answer is no. Normal completions remain part of the baseline paid experience.

Why GitHub Made This Change

GitHub has not framed the change as a simple price increase. The bigger story is product evolution. Copilot in 2026 is an agentic development platform, not only a suggestion engine. That creates three pressures that make usage-based billing more logical.

1. Agentic workloads are uneven

Some AI actions are tiny. Others are huge. A flat request system hides that difference. Usage-based billing lets GitHub charge proportionally for small chat answers versus long, multi-file agent sessions.

2. Sustainability matters

Advanced reasoning models and broader context windows are expensive to run. If GitHub wants to keep shipping stronger models and more autonomous workflows, the billing model has to reflect real compute consumption. AI Credits make that easier to sustain over time.

3. Cost fairness improves

Under request-based billing, a light user and a heavy user could burn through quotas in ways that did not cleanly map to actual cost. Under usage-based billing, lighter usage often consumes fewer credits, while heavier workflows pay for the extra model work they actually trigger. That is generally fairer for both GitHub and customers.

For finance teams, the new model also creates a clearer bridge between usage and spend. A budget of $10 is simply 1,000 AI Credits. That is easier to reason about than a system of request counters plus model multipliers.

Impact on Existing Subscribers

The transition is not identical for every customer.

Existing annual Pro and Pro+ subscribers

If you were already on an annual Copilot Pro or Copilot Pro+ plan and chose to remain on the legacy billing model, GitHub allows you to stay on premium request-based billing until your current annual term ends. That is why some people still see legacy request terminology in their account after June 1, 2026.

Once that annual term ends, the legacy arrangement does not continue indefinitely. Teams and individuals should plan for the eventual move to the newer monthly usage-based structure when renewal or plan changes happen.

Business and Enterprise customers

Organizations on Copilot Business and Copilot Enterprise move into the AI Credit framework with pooled usage. Existing customers also receive the temporary promotional credit boost during the first three months of the transition, which helps soften adoption and gives admins time to observe real usage patterns before the standard pooled amounts apply.

If you are an admin, the most important operational change is that budgets now matter more than ever. Once the shared pool is exhausted, additional usage can either continue as paid overage or be blocked, depending on your policy settings.

How to Prepare for the Transition

For most teams, the best response is not panic. It is planning. Here is a practical transition checklist.

1. Audit how your team actually uses Copilot. If usage is mostly completions, the billing impact may be modest. If your engineers rely heavily on chat, code review, CLI, and cloud agents, usage will matter more.
2. Decide which plan fits your usage pattern. Teams that need pooled usage and admin controls should compare Business and Enterprise. Smaller buyers can start with the options on our pricing page.
3. Set budgets before you need them. AI Credits map directly to dollars, which makes budget controls more understandable. A zero-dollar additional usage policy creates a hard cap; a defined overage budget gives flexibility.
4. Update developer tooling. GitHub recommends current IDE, extension, and CLI versions so usage dashboards, pricing displays, and alerts reflect the new terminology correctly.
5. Educate developers on cost-heavy workflows. A short chat prompt is different from a long-running agent session against a huge codebase. Teams should know which workflows are “cheap” and which ones are “premium” in practical terms.
6. Monitor the first billing cycle closely. The first month will tell you whether your assumptions were correct. Watch which models and features drive the most usage.

If you want help choosing a plan or understanding what this means for procurement, budgeting, or pooled seats, contact our team. Because we focus on official Copilot licensing, we can help translate the raw billing model into a cleaner buying decision.

Bottom Line

GitHub Copilot usage-based billing is not just a new name for the old system. It is a structural change from prompt counting to compute-aware pricing. The old request-based model used premium request units and multipliers. The new model uses AI Credits, token measurement, pooled usage for business plans, and direct budget controls.

For developers, the day-to-day experience is still familiar: code completions remain unlimited on paid plans, and advanced AI workflows remain available. For admins and buyers, the difference is better visibility into cost, more realistic charging for agentic usage, and clearer budget management across teams.

If your organization is planning a rollout, expansion, or renewal, now is the right time to compare seat types, estimate credit usage, and map the new billing model to your internal budget process. Start with our pricing overview, review the differences between Business and Enterprise, and reach out through contact if you want help structuring the right plan.