Summary: GitHub announced on April 27, 2026 that monthly Copilot subscribers move to usage-based billing on June 1 while annual Pro and Pro+ subscribers may retain premium-request pricing until their terms end, replacing premium requests with AI Credits priced at one cent each. Plan prices stay unchanged, included credits match plan fees, and code completions and next-edit suggestions on paid plans remain unbilled and uncapped. Enterprises receive a June-August grace period with pooled credits, budgets, and overage controls.
GitHub Chief Product Officer Mario Rodriguez broke the news on April 27, 2026: as of June 1, every Copilot plan shifts to usage-based billing. Premium requests are being retired, and AI Credits take their place — consumption of input, output, and cached tokens charged against each model’s published API rates.
There is more at stake than how an invoice is formatted. For the most widely deployed AI coding assistant, the move formally closes the book on flat-rate AI assistance: from here on, each chat question and each agent session comes with a visible price tag.
How Billing Works After June 1
One number anchors the whole system: 1 AI credit equals $0.01. Interactions with models are costed against a per-million-token rate table, then converted into credits drawn down from the allowance bundled with your plan. Sticker prices are untouched, and the credits inside each plan now match its monthly fee dollar for dollar: Copilot Pro costs $10/month and carries $10 in credits, Pro+ costs $39 and carries $39, Business costs $19/user/month and carries $19, and Enterprise costs $39/user/month and carries $39.
Code completions and next-edit suggestions stay unbilled and uncapped across all paid plans. Copilot code review runs on a two-track bill — token consumption in credits alongside GitHub Actions minutes at standard rates — and the model doing the reviewing is picked automatically and never disclosed. The documentation adds a long-context surcharge past an input threshold: GPT-5.5 pricing doubles from $5 input / $30 output to $10 / $45 per million tokens the moment input climbs above 272K.
The Case GitHub Makes for the Change
The announcement goes straight at the flaw built into the old setup: Copilot has evolved “from an in-editor assistant into an agentic platform,” yet premium requests meant “a quick chat question and a multi-hour autonomous coding session can cost the user the same amount” — a model GitHub itself calls “no longer sustainable.” Credits let heavy workloads pay heavy prices while light questions pay light ones.
A preview bill experience is also due in early May on the Billing Overview page, giving individuals and org admins a way to project costs and rehearse a typical session’s real spend before the cutover arrives.
Switching Mechanics and the Enterprise Grace Period
Monthly subscribers are moved over automatically on June 1. Annual Pro and Pro+ subscribers may stay on premium-request pricing until their term ends, though model multipliers climb on June 1 — annual subscribers only; when the term expires they fall back to Copilot Free unless they upgrade, and converting early earns prorated credit for remaining contract value.
Enterprises are handed a three-month cushion: across June, July, and August, Business includes $30/month in credits per user and Enterprise $70. Included usage can be pooled organization-wide so credits don’t sit stranded with idle seats; admins can set budgets at the enterprise, cost-center, and user levels, and every org decides for itself whether overage bills at published rates or spending gets hard-capped. Fallback models disappear — once the credits are gone, they are gone, and budget controls become the backstop.
The sequencing is telling: a mere week earlier, GitHub had tightened limits on Individual plans and paused self-serve Business purchases, framing both as reliability measures. The new announcement pledges, “We will loosen usage limits once usage-based billing is in effect.”
How Developers Took the News
Visual Studio Magazine’s same-day story carried a blunt headline: “you will get less but pay the same price.” Two complaints dominate the community response. One: because included credits match the plan price, heavy users walk away with less usable work for identical money. Two: agent workflow costs swing from predictable to token-dependent — a badly configured automation loop can drain a budget as fast as it can retry. And subscribers who joined through the mobile apps hit one more wall: buying additional credits is not an option for them at all.
What Teams Should Do About It
Three moves make sense right away. First, once the May bill preview goes live, push a full typical session from your main project through it and let the data — not vendor arithmetic — set your estimate of real credit consumption. Second, take another pass at model choice: the very same task can cost an order of magnitude more credits on a flagship model than on a cheap one, which promotes model routing from an optimization into a requirement. Third, wire budgets into your process: multi-level admin budgets are already available, and cap modes are the sensible default for overnight automation and agent jobs inside CI.
Unit-cost pressure frames the larger picture. That very week, DeepSeek put out a V4 preview claiming frontier parity, dragging open-source cost floors lower still. By turning to metered billing, GitHub both surfaces what agentic coding really costs and hands the model-selection lever — together with the invoice responsibility — back to developers.