GitHub Copilot AI Credits: Usage-Based Billing 2026

On June 1, 2026, GitHub Copilot quietly retired the flat-rate model that had defined AI coding tools for years. Premium requests are gone. In their place is a token meter: every chat, agent run, and code review now draws down a balance of GitHub AI Credits, priced by the model you pick and the tokens you burn. June 30 marks the close of the first full month on the new system — and the first round of bills that reflect it.¹²

In one line: GitHub Copilot now bills by usage. Each plan includes a monthly allowance of AI Credits (where 1 credit = $0.01), agentic and chat features consume those credits based on token use, and once they run out you either pay more or stop — there is no longer a free fallback to a cheaper model.¹²

TL;DR

• What changed: Premium request units (PRUs) were replaced by GitHub AI Credits on June 1, 2026. Usage is now metered by token consumption — input, output, and cached tokens — at each model's published rate.¹³
• The unit: 1 AI Credit = $0.01 USD. A quick question to a lightweight model costs a fraction of a credit; a long agent session on a frontier model costs many.²
• Plan prices did not change: Pro is still $10/mo, Pro+ $39/mo, Business $19/user, Enterprise $39/user. A new Copilot Max tier sits on top at $100/mo.¹²
• Included credits (current): Pro 1,500 credits ($15), Pro+ 7,000 ($70), Max 20,000 ($200) — each a "base + flex" allotment.²
• Still free: Code completions and Next Edit suggestions are not billed in credits and remain unlimited on paid plans.¹²
• What's gone: The fallback safety net. Previously, exhausting your premium requests dropped you to a cheaper model so you could keep working. Now, hitting zero stops premium features until you buy more credits or the month resets.¹²
• The backlash: The change drew sharp developer pushback — TechCrunch reported "consternation among devs," and some heavy agentic users reported bills jumping many times over.⁴⁵

What You'll Learn

• What GitHub AI Credits are and exactly how they are calculated
• What every Copilot plan now costs and includes in 2026
• What still costs nothing — and what quietly drained the meter
• Why GitHub abandoned flat-rate pricing
• A worked example showing how fast an agent session spends credits
• How to avoid a surprise Copilot bill
• What this signals about the end of all-you-can-eat AI

What are GitHub AI Credits?

GitHub AI Credits are the billing unit for Copilot usage. When you use Copilot, the interaction consumes tokens — input tokens (what's sent to the model), output tokens (what the model generates), and cached tokens (context the model reuses). Each token is priced by the model you used, and the total is converted into AI Credits, where 1 AI Credit = $0.01 USD.²³

The cost of any single interaction depends on two things: the model and the number of tokens. In GitHub's own words, "a quick question in Copilot Chat using a lightweight model might cost a fraction of an AI credit," while "a long Copilot cloud agent session using a frontier model across multiple files will cost more AI credits, because it's doing more work."²

That is the whole shift in one sentence: cost is now proportional to work, not to a fixed monthly fee.

What changed: from premium requests to AI Credits

Under the old system, every paid plan came with a fixed monthly allowance of premium requests. A premium request was a unit of action — a chat message or a premium-model suggestion — and some models applied multipliers, so one interaction could count as several requests. The legacy allotments were 300 premium requests per month for Copilot Pro, 1,500 for Pro+, and 300 per user for Business.⁶

The flaw GitHub kept running into: a one-line chat question and a multi-hour autonomous coding session could cost you the same premium request, even though they cost GitHub wildly different amounts to serve. AI Credits replace that flat unit with a meter that tracks actual token consumption per model.¹²

Annual Pro and Pro+ subscribers are the exception: they stay on the legacy premium-request model until their plan expires, and their model multipliers actually increased on June 1. At expiry, they move to Copilot Free with the option to upgrade to a monthly paid plan.¹

GitHub Copilot pricing in 2026: every plan and its credits

Base seat prices did not move. What's new is the credit allowance attached to each one. For individual plans, GitHub splits the allowance into base credits (which match your subscription price and "never change") and a flex allotment (a variable top-up "designed to adapt as the economics of AI evolve").²⁷

⚠ Prices change frequently. The values above are for illustration only and may be out of date. Always verify current pricing directly with the provider before making cost decisions: Anthropic · OpenAI · Google Gemini · Google Vertex AI · AWS Bedrock · Azure OpenAI · Mistral · Cohere · Together AI · DeepSeek · Groq · Fireworks AI · Perplexity · xAI · Cursor · GitHub Copilot · Windsurf.

Copilot Max is a new tier built for heavy, sustained agent-driven workflows. Copilot Free and Student keep a smaller credit allowance plus unmetered completions (Free includes 2,000 code completions per month; Student gets unlimited completions).²⁷

For organizations, each seat carries a per-user credit allowance that is pooled at the billing-entity level — so an enterprise with 100 Business seats gets one shared pool of 190,000 credits, letting power users draw more while lighter users offset them.⁸

⚠ Prices change frequently. The values above are for illustration only and may be out of date. Always verify current pricing directly with the provider before making cost decisions: Anthropic · OpenAI · Google Gemini · Google Vertex AI · AWS Bedrock · Azure OpenAI · Mistral · Cohere · Together AI · DeepSeek · Groq · Fireworks AI · Perplexity · xAI · Cursor · GitHub Copilot · Windsurf.

Existing Business and Enterprise customers get the higher promotional allowance for the first three months; after September 1, 2026, it reverts to the standard amounts.⁸

What still costs nothing: completions and Next Edit

The most important detail for everyday users is what the meter does not touch. Code completions and Next Edit suggestions are not billed in AI Credits and remain unlimited on every paid plan.¹²

If you primarily use Copilot the original way — gray-text autocomplete in your editor — your experience and your bill barely change. The meter runs on the newer, heavier surfaces: Copilot Chat, Copilot CLI, the cloud coding agent, Spaces, Spark, third-party coding agents, and code review.²⁸

One feature bills twice. Copilot code review consumes AI Credits for its tokens and GitHub Actions minutes for the agentic infrastructure that runs it, charged at the same per-minute rate as any other Actions workflow.²³

Why GitHub made the change

GitHub's rationale, from CPO Mario Rodriguez's announcement, is blunt: "Copilot is not the same product it was a year ago." It has "evolved from an in-editor assistant into an agentic platform capable of running long, multi-step coding sessions," and "agentic usage is becoming the default," bringing "significantly higher compute and inference demands."¹

The economics broke under the old model. "Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount," Rodriguez wrote — while costing GitHub very different amounts to serve. GitHub had been absorbing that gap. Usage-based billing closes it by aligning price with the actual inference cost behind each request.¹

That is the real story here, and it is bigger than GitHub. The marginal cost of an AI inference does not fall to zero the way traditional software does — every token has a real compute cost. A $10 flat seat cannot fund unlimited frontier-model agent runs. Metering is GitHub conceding that publicly.

How AI Credits get spent: a worked example

Because cost scales with model and tokens, the single biggest lever on your bill is which model you run. To make that concrete, here's an illustrative "heavy agentic session" of 2 million input tokens and 400,000 output tokens — roughly what a multi-step agent can rack up as it re-reads files and context across a long task. (Caching lowers input costs in practice, and real sessions vary widely. Rates are each model's standard published per-million-token prices; GPT-5.x charges a higher rate only for individual requests above 272K input tokens, which agent steps rarely cross.)³

The math is unforgiving: on Gemini 2.5 Pro, Pro's monthly allowance covers roughly two such sessions; on GPT-5.5 or Claude Opus 4.8, a single heavy session can exhaust an entire month's included credits. The same task costs over 3x more depending only on the model you picked. This is why two developers on the identical $10 plan can see wildly different bills — and why model selection is now a budgeting decision, not just a quality one.

The developer backlash

The reaction was loud. When the change was first announced in late April, Visual Studio Magazine summarized the developer mood as "you will get less, but pay the same price."⁵ By late May, TechCrunch was reporting "consternation among devs," with one headline quoting a blunt "what a joke."⁴ GitHub's own announcement discussion thread filled with pushback.¹

As the first metered bills landed at month's end, some heavy agentic users reported costs jumping many times over — anecdotal screenshots of monthly bills rising from tens of dollars into the hundreds or beyond circulated across Reddit, X, and GitHub's forums. These figures are self-reported and reflect extreme agentic usage, not the typical completion-heavy developer, so treat them as the loud tail of the distribution rather than the average. Still, the direction is real: anyone who built a workflow around unlimited agent runs is now paying for what used to be free at the margin.

The losers are clear — power users of agent mode, repository-wide refactors, and frequent premium-model code review. The winners are equally clear: completion-first developers, who keep an unmetered experience at the same price.

How to avoid a surprise Copilot bill

The new model is controllable if you treat it like one. Practical steps:

• Know what's metered. Completions and Next Edit are free. Chat, agents, CLI, and code review are not. If your bill matters, shift routine work toward completions and reserve agents for tasks that justify the spend.²
• Pick cheaper models for routine work. As the table above shows, model choice can triple the cost of the same task. Use a lightweight or mid-tier model by default and escalate to a frontier model only when the problem demands it.³
• Set a budget. Individuals and admins can cap additional usage in dollars. A $0 user-level budget blocks overage entirely; any positive budget draws down at $0.01/credit. When included credits run out, you either authorize more spend or stop — there is no automatic fallback to a cheaper model anymore.²⁸
• Pool and monitor (orgs). Business and Enterprise credits pool across the billing entity, so monitor aggregate consumption and set cost-center or enterprise spending limits before a few power users drain the shared bucket.⁸
• Update your tooling. Older IDE and extension versions may show inaccurate pricing or usage. GitHub lists minimum versions (for example, VS Code 1.120 and Copilot CLI 1.0.48) for correct billing display.⁸

What this signals: the end of flat-rate AI

GitHub Copilot is one of the most widely used AI coding tools on the market, so its move is a bellwether. The flat-rate, all-you-can-eat subscription — the default for AI developer tools since 2022 — is colliding with the reality that agentic workloads cost real money per token. Expect more tools to land on a two-tier shape: a cheap entry plan for light use, and a metered or high-priced power tier for sustained agent work. Copilot's own lineup, with a new $100 Max tier above the $10 Pro plan, already mirrors that split.²

For developers, the takeaway is a mindset shift. The question is no longer "which tool has the best flat plan," but "how much real work does my credit allowance buy, and is Copilot the best place to spend it?" If you're weighing alternatives, it's worth understanding how token counting actually works, keeping an eye on open-source coding agents that price differently, and factoring the broader AI coding governance picture into how your team adopts these tools.

The Bottom Line

GitHub Copilot's switch to usage-based billing is the clearest sign yet that the flat-rate era of AI tools is ending. The headline prices didn't move and your autocomplete is still free — but the moment you lean on agents and frontier models, you're on a meter, and the safety net that used to catch you is gone. The change rewards developers who understand where their tokens go and punishes those who assumed "unlimited" was forever. Learn the meter, pick your models deliberately, set a budget, and Copilot stays affordable. Ignore it, and the first surprise bill will do the teaching instead.