GitHub Copilot's Metered Billing Starts June 1: Every Policy Change Decoded for Individual Developers

If you’ve been using GitHub Copilot on a personal Pro or Pro+ account, June 1 is not a date you can ignore. GitHub is replacing its existing premium request model with token-based metered billing, introducing a new plan tier, restricting models by plan, pausing new sign-ups, tightening usage limits, and adding a “flex allotment” that the company can adjust whenever it wants. Some of these changes are clearly telegraphed in GitHub’s official blog posts. Others are buried in documentation that takes a careful read to fully understand.

This post breaks down every policy change announced since April 20, 2026, explains what each one means for individual developers on personal accounts versus enterprise and business users, and gives you a concrete action checklist to run through before June 1 arrives.

Why GitHub Is Doing This

GitHub’s VP of Product, Joe Binder, put it plainly: agentic workflows broke the original pricing model. A quick chat message and a multi-hour autonomous coding session that fans out across an entire repository now cost users the same flat fee — but the infrastructure cost to GitHub for those two scenarios differs by orders of magnitude. GitHub absorbed the delta for a while. It can’t anymore.

The specific trigger was parallelized, long-trajectory agent sessions. When Copilot users started running /fleet commands and multi-step coding agents, a handful of requests could easily incur costs exceeding the entire monthly plan price. The flat-fee model, designed for a simpler in-editor assistant, was never built to absorb this kind of usage pattern.

The transition to usage-based billing is GitHub’s attempt to align what users pay with what they actually consume. Whether that translates to a better or worse deal for any individual developer depends almost entirely on how they use Copilot — and which plan they’re on.

Change 1: Premium Request Units Are Gone, Hello AI Credits

Starting June 1, the premium request unit (PRU) system goes away entirely. In its place, every Copilot plan gets a monthly allotment of GitHub AI Credits, where one credit equals exactly $0.01 USD.

Unlike PRUs, which counted requests regardless of how large or small they were, AI Credits are consumed based on actual token usage — input tokens, output tokens, and cached tokens — at per-model rates. A short chat question costs almost nothing. A long agentic session with a heavyweight model like Opus 4.7 can cost significantly more.

The practical consequence: your credit burn rate now depends on which model you’re using, not just how many times you’ve clicked. A developer who fires off ten quick completions with GPT-4.1 mini will consume far fewer credits than one who asks Opus 4.7 to refactor a module. This was always true at the infrastructure level — it just wasn’t exposed to users. Now it is.

One critical detail that isn’t prominently advertised: unused AI Credits do not roll over. If you end the month with credits remaining, they expire. This is a straight downgrade from how many developers intuitively think about a subscription: you’re not banking value by using less, you’re just leaving money on the table.

Change 2: The New Individual Plan Lineup (Free → Pro → Pro+ → Max)

On May 12, GitHub updated the individual plan structure in response to user feedback that the original credit amounts wouldn’t be enough. The new lineup, effective June 1, looks like this:

Plan	Monthly Price	Base Credits	Flex Allotment	Total Included
Free	$0	—	Limited	Limited chat + completions
Pro	$10/mo	$10	$5	$15
Pro+	$39/mo	$39	$31	$70
Max	$100/mo	$100	$100	$200

The mechanics work as follows: your base credits are always equal to your subscription price (1:1 ratio) and are guaranteed to stay that way. Your flex allotment is additional usage on top of the base that GitHub adds automatically — but can also reduce whenever it deems appropriate.

The flex allotment is the detail that deserves the most caution. GitHub’s announcement is explicit about it: “The flex allotment is a variable part of your included usage; it is designed to adapt as the economics of AI evolve, including model pricing, new models, and improvements in efficiency.” In plain language: GitHub can lower the flex portion of your plan without changing your subscription price, and the base credits are the only portion contractually locked to your plan cost. You won’t know what the flex amount will be month-to-month — and there’s no minimum guaranteed for it.

For context: under the flex model, a Pro subscriber today gets $15 in total included usage for $10/month — a 50% bonus on top of the base. That’s a good deal while it lasts. But if GitHub reduces the flex allotment to $2 next quarter, you’re back to effectively $12 in total usage for $10, with no plan change and no breach of the stated terms.

Code completions and Next Edit suggestions remain unlimited across all paid plans and do not consume credits. If your primary Copilot use is inline code completion in VS Code without touching chat or agents, June 1 changes essentially nothing for your workflow.

Change 3: Model Restrictions Tightened by Plan

GitHub moved quietly but significantly on model access in April, and the rules are now clearer heading into June.

On the Free plan: Auto mode selects models, but advanced models aren’t accessible directly.

On Pro ($10/month): Opus-class models are gone entirely. Opus 4.7 was removed from Pro plans effective April 20. Opus 4.5 and 4.6 were also removed from Pro+. If you were relying on Opus-tier reasoning inside a $10/month Pro plan — for deep refactoring, architectural analysis, or complex debugging — that option no longer exists at this price point.

On Pro+ ($39/month): Opus 4.7 remains available. This is the floor for developers who need Anthropic’s highest-capability models through Copilot’s interface. The new Pro+ effectively becomes the “serious developer” tier that Pro used to aspire to be.

On Max ($100/month): Full model access with the highest included credit allotment. This tier is aimed at developers running sustained, high-volume agentic workflows — think automated test generation runs, multi-hour coding agents, or heavy use of Copilot’s review and coding modes in parallel.

The model access restructuring is probably the change that will sting most for individual developers who were getting Opus-class access at Pro pricing. That combination no longer exists.

Change 4: Annual Subscribers Have a Worse June 1 Than Monthly Subscribers

This is the policy change that is most likely to catch developers off guard, because it requires reading across multiple announcements to see the full picture.

If you are on an annual Pro or Pro+ plan, you do not transition to AI Credits on June 1. You remain on the PRU (premium request) billing system until your annual plan expires. This sounds like a shield — and it is, partially. But there’s a catch buried in the docs: model multipliers increase on June 1 for annual plan subscribers, even while they remain on the PRU system.

A model multiplier determines how quickly your PRU allotment gets consumed. If Claude Sonnet previously had a multiplier of 1 and it goes to 1.5 for annual subscribers on June 1, your existing PRU allotment now gets you one-third fewer effective requests than it did before. You’re paying the same annual price for demonstrably less usage.

When the annual plan eventually expires, there is no auto-renewal into a paid monthly plan. You drop to Copilot Free, with limited completions and no model access, until you manually choose to re-subscribe to a monthly tier.

What annual subscribers should do: Before your annual plan expires, visit your GitHub Billing settings and convert to a monthly plan. GitHub says it will provide prorated credits for the remaining value of your annual plan when you convert. This keeps you on a paid tier at transition rather than falling to Free, and gets you onto AI Credits billing rather than the increasingly punitive PRU system with higher multipliers.

Change 5: New Sign-ups Paused

Since April 20, 2026, new sign-ups for Copilot Pro, Pro+, and Student plans are paused. GitHub framed this as a reliability measure — serving existing customers better while infrastructure scales to meet agentic demand. Self-serve Copilot Business purchases were also briefly paused.

This has no direct impact on existing subscribers. But if you’re an individual developer who let your subscription lapse and was planning to re-subscribe, or if you’re onboarding a new team member who needs a personal Copilot plan, the door is currently closed. GitHub has not committed to a specific reopening date, saying only that limits will “loosen once usage-based billing is in effect.”

The pause is worth noting as a signal: GitHub’s infrastructure was not sized for the explosion in agentic usage that materialized in early 2026. The move to metered billing is partly a product decision and partly a capacity management response.

Change 6: A Second Hidden Meter — Copilot Code Review Now Burns Actions Minutes

This change is easy to miss in the announcements, but it matters if you use Copilot’s code review feature in your pull request workflow.

From June 1, Copilot code review will consume both GitHub AI Credits AND GitHub Actions minutes. Actions minutes are billed at the same per-minute rates as other GitHub Actions workflows — free up to the plan limit, then charged per additional minute.

For teams and individuals who have Copilot reviewing every PR automatically, this creates a second spending dimension that wasn’t there before. A high-frequency repo with lots of small PRs could accumulate Actions minutes costs alongside the AI Credit consumption for the review itself.

If you use Copilot code review, check your GitHub Actions minute consumption for May as a baseline before June 1. You want to know what “normal” looks like so you can detect the additional billing impact clearly when it starts.

Individual vs. Enterprise: What the Difference Actually Means in Practice

Enterprise and Business users get a meaningfully different June experience than individual developers. Here’s the honest comparison.

For individual developers on personal accounts:

• Credits are per-user and don’t pool with anyone else
• No admin budget controls — you’re on your own for monitoring and capping spend
• No overage protection by default; if you exceed your included allotment, you’re billed at published per-model token rates
• Flex allotment can change without notice
• New sign-ups blocked; annual plan subscribers face multiplier increases before transition

For Copilot Business ($19/user/month) and Enterprise ($39/user/month) users:

• Promotional credits for June, July, and August 2026: Business gets $30 included (vs. standard $19), Enterprise gets $70 included (vs. standard $39) — a meaningful buffer during the transition period
• Credits pool across the organization. If one developer uses less than their share, that unused capacity is available to the team, rather than being stranded and expiring. This is a material advantage over individual plans.
• Admin budget controls at enterprise, cost center, and user levels — admins can cap spend or allow overages at each level
• Admins can decide whether to allow usage after the included pool is exhausted (and get billed at published rates) or hard-stop at the limit

Enterprise teams get the infrastructure to govern this transition. Individual developers get a dashboard and their own discipline.

The pooling difference alone is significant. A 20-person team on Business plans has an effective monthly credit pool of ~$600 (at promo rates), allocated across whoever needs it most. Stranded capacity — unused credits from developers who were on vacation or in meetings all week — circulates back to heavy users. On individual plans, that same team member who barely opened VS Code this week just lost their credits.

The SuperML Take

GitHub’s move to usage-based billing is the right call economically, and it was probably inevitable once agentic AI usage patterns became the norm rather than the exception. When a single coding agent run can cost more than the monthly subscription price, the flat-fee model stops making sense for anyone — including GitHub.

But the rollout has layered on several changes simultaneously — billing model, plan lineup, model access restrictions, sign-up pauses, flex allotments — in a way that makes it genuinely difficult for individual developers to assess whether they’re better or worse off. The answer, honestly, is: it depends on your usage pattern. Light users who mostly rely on inline code completions are probably fine at Pro. Heavy agentic users who want Opus-class reasoning will need at least Pro+ and may find themselves buying overages or upgrading to Max.

The flex allotment is the part of this that deserves the most skepticism from a practical planning perspective. GitHub has been transparent that it can change, and has given a reasonable explanation for why it exists (AI model economics are volatile). But from a developer’s perspective, “we’ll give you more than you’re paying for, and we might give you less later” is not a basis on which to plan a workflow. Treat the base credit amount — the 1:1 match to subscription price — as your planning floor. Anything the flex adds is a bonus, not a guarantee.

The annual plan issue is the most actionable time-sensitive problem. If you’re on an annual plan, you have a worsening deal starting June 1 (higher multipliers on your remaining PRUs), a cliff at expiry (drop to Free), and a path that requires a manual decision (convert to monthly before expiry to keep paid access). GitHub made this process available — prorated credit conversion — but it requires you to take action.

The community response to these changes has been predictably frustrated: the developer discussion threads on GitHub show hundreds of comments from users who feel like they’re getting less for the same price. GitHub’s position is that the included amounts will cover most developers. That may be true for the median user who uses Copilot primarily for completions. For the developer who discovered agentic coding sessions last quarter and has been running Opus-backed refactoring sessions for hours at a stretch — the pricing model just fundamentally changed.

What This Means for Developers

Model selection is now a spending decision, not just a capability decision. Choosing Claude Opus 4.7 for a two-hour agent session versus GPT-4.1 mini for the same task now has meaningfully different credit consequences. Developers need to build an intuition for which model tier the task actually requires. Using a frontier model for simple autocomplete is no longer just overkill — it’s measurably wasteful in a billed sense.

Watch for silent credit exhaustion during long agent runs. Under the old PRU model, running low on requests would cause Copilot to fall back to a lower-cost model and continue. Under AI Credits there is no automatic fallback — when credits run out (or you hit a spending cap), the service stops. A developer mid-way through a multi-hour automated refactoring session who exhausts their monthly allotment will see Copilot go silent with no graceful degradation, potentially leaving incomplete changes in the codebase. This is the failure mode most developers won’t anticipate until it happens to them once.

The math matters more than it used to. At $10/month with $15 in total included credits (base + flex), a Pro subscriber using Copilot Chat backed by Claude Sonnet (roughly $3/million input tokens, $15/million output tokens) can make around 300–500 substantive exchanges per month before hitting the limit. A single long agentic session with Opus 4.7 at higher token rates can burn a meaningful share of the monthly allotment in one afternoon. The spread between “casual chat user” and “agentic power user” is far wider than the PRU model ever surfaced — because PRUs hid the per-token reality behind a request count.

Your pre-June 1 checklist:

• Monthly Pro/Pro+ subscribers: Migration is automatic. Check your GitHub Billing Overview now for the preview bill GitHub promised — it’s the best way to calibrate before the meter actually runs.
• Annual Pro/Pro+ subscribers: Seriously consider converting to monthly before your plan expires. Multipliers increase June 1 while you’re still on PRU billing, and at expiry you drop to Free with no auto-renewal. The prorated conversion path is in Billing settings.
• Heavy Opus users on Pro: Upgrade to Pro+ before June 1 — Opus 4.7 is gone from Pro as of April 20.
• Anyone using Copilot code review on PRs: Audit your GitHub Actions minute consumption for May to establish a baseline before the second billing meter kicks in June 1.
• Heavy agentic users (fleet commands, parallel agents, long refactoring runs): Start using Plan mode (/plan in VS Code or CLI) before executing long sessions. Planning before executing improves task success rate and cuts wasted token consumption on failed approaches.
• Developers near usage limits: Match model to task. GPT-4.1 mini, Gemini Flash, and comparable lightweight models consume credits an order of magnitude more slowly than Opus or GPT-5.5 for the same chat interaction. Save the frontier models for tasks that genuinely need them.

What to Watch

Watch whether GitHub adjusts the flex allotment up or down for June and July. If the flex drops significantly in the second month after the billing transition, it will signal that GitHub is actively using the flex mechanism to manage costs — and that the month-1 allotments were a promotional sweetener rather than a sustainable baseline.

Watch for sign-up restrictions to lift. GitHub said new sign-ups would resume once the usage-based billing transition is in effect. If restrictions don’t ease in June or July, it signals that infrastructure capacity concerns haven’t been resolved by the billing transition alone.

Watch the Copilot Max plan adoption pattern. If Max ($100/month) develops a significant user base, it confirms that agentic-heavy developers were underserved by Pro and Pro+ pricing and were willing to pay for more. If adoption is thin, it suggests the included amounts in Pro and Pro+ are sufficient for most developer workflows — which would validate GitHub’s claims about typical usage patterns.

And if you’re building products that depend on GitHub Copilot’s API — not just the IDE UX — review the models and pricing documentation directly. Model multipliers and token rates apply to API usage as well, and the transition to AI Credits changes how programmatic Copilot usage is billed in ways that may affect your cost modeling.

Sources

• GitHub Copilot is moving to usage-based billing — The GitHub Blog
• Changes to GitHub Copilot Individual plans — The GitHub Blog
• GitHub Copilot individual plans: Introducing flex allotments in Pro and Pro+, and a new Max plan — The GitHub Blog
• Usage-based billing for individuals — GitHub Docs
• Usage-based billing for organizations and enterprises — GitHub Docs
• Models and pricing for GitHub Copilot — GitHub Docs
• Announcement & FAQ: Changes to GitHub Copilot Individual Plans — GitHub Community Discussions
• GitHub Copilot is moving to usage-based billing — GitHub Community Discussion #192948
• Devs Sound Off on Usage-Based Copilot Pricing Change — Visual Studio Magazine
• Microsoft’s GitHub shifts to metered AI billing — The Register