GitHub Copilot Flex Billing: The Complete June 2026 Developer Playbook

GitHub's premium request unit (PRU) model has been on borrowed time since the moment it launched. PRUs were a stopgap, a fixed bucket that didn't map cleanly to how developers actually use Copilot, where a single agentic session can consume ten times what a quick chat question does. On June 1, 2026, GitHub replaces PRUs with AI Credits and a two-layer flex system. Monthly subscribers migrate automatically. Annual subscribers get an immediate usage bump on June 1 with their existing term intact.

The good news first: code completions and next-edit suggestions remain unlimited on all paid plans. The new billing only applies to chat, agentic sessions, and cloud code review, the high-intensity work where PRU limits actually stung. If you mostly use Copilot for autocomplete, this change is noise. If you run agentic workflows or heavy chat sessions, it's worth understanding the numbers before the transition hits.

What actually changes (and what doesn't)

The billing unit changes from premium request units to GitHub AI Credits, where 1 AI Credit = $0.01 USD. Credits are consumed by token usage, input tokens, output tokens, and cached tokens, priced per model according to GitHub's published API rates.

What stays unlimited, consuming zero credits regardless of plan:

• Code completions, the bread-and-butter inline suggestion
• Next Edit suggestions, the jump-to-next-change feature

What now draws from your credit pool:

• Copilot Chat (IDE, github.com, CLI)
• Agentic coding sessions (Copilot agent, Copilot Spaces, Spark)
• Copilot cloud code review
• Third-party coding agents via the Copilot extensibility API

The new plan structure

GitHub is consolidating individual plans into four tiers. Three of them existed before; the new Max tier is the addition.

The flex allotment is the key new concept. Base credits are consumed first and are permanently fixed at subscription price parity, $10 of credits for a $10/month plan. Once base credits are exhausted, the flex allotment kicks in automatically. The flex pool size adapts over time as model pricing and AI economics shift; GitHub has committed to communicating changes in advance.

How AI Credits work

Credits are consumed based on token counts at the model's published API rate. The specific credit cost per request depends on three variables: which model handled the request, how many tokens were in the input (including cached context), and how many tokens were generated as output.

# A typical Copilot Chat exchange
Input tokens (your message + context):  ~2,000 tokens
Output tokens (model response):         ~400 tokens

Using GPT-4o at ~$0.005/1K input, $0.015/1K output:
  Input cost:  2,000 × $0.005 / 1,000 = $0.010 → 1.0 AI credit
  Output cost:   400 × $0.015 / 1,000 = $0.006 → 0.6 AI credit
  Total: ~1.6 AI credits ($0.016)

At 1,000 similar exchanges per month = 1,600 AI credits ($16.00)
Pro plan includes 1,500 total credits, close to exhaustion.
Pro+ plan includes 7,000 total credits, 4x headroom.

The math shows that light Copilot Chat users will stay well within Pro's $15 effective pool. Heavy agentic users, running multi-step sessions that process hundreds of files, can burn credits fast, because agentic sessions accumulate large context windows that inflate input token counts significantly.

Reading your preview bill now

GitHub launched a preview billing experience in early May so you can see your projected June usage before the transition. Find it under Settings → Billing & plans → Usage on github.com. The preview shows your usage broken down by feature and model, so you can identify exactly where tokens are going.

Usage breakdown to examine:
  ✓ Copilot Chat, messages × avg token count
  ✓ Agentic sessions, count × avg session size
  ✓ Cloud code review, PRs reviewed × avg diff size
  ✓ Which models were used (GPT-4o vs Claude vs Gemini)

Red flags:
  ✗ Single agentic sessions consuming >10,000 credits
  ✗ Third-party agents running uncapped
  ✗ Monthly usage trending >80% of your plan's pool by mid-month

If the preview shows you regularly exceeding your current plan's equivalent credit pool, upgrade before June 1 to avoid mid-month service interruptions. GitHub will not automatically upgrade your plan; you'll simply stop getting AI responses once credits are exhausted, unless your admin has enabled overage billing.

Which plan should you pick?

The right plan depends almost entirely on whether you run agentic sessions.

The decision tree is short:

• Autocomplete only, light chat → Pro ($10/month). The $15 effective pool is plenty for a few dozen chat exchanges per day.
• Regular chat + occasional agentic runs → Pro+ ($39/month). $70 in credits covers most developer workflows comfortably.
• Daily agentic sessions, large codebases, or power reviewer → Max ($100/month). $200 in credits leaves meaningful headroom for intensive use.
• Team or organization → Copilot Business with admin budget controls set per user or cost center.

Budget controls for teams

The billing change ships with new admin tooling that addresses the main enterprise concern about usage-based pricing: runaway spend. Admins can now set credit budgets at three levels: enterprise-wide, per cost center, and per individual user. Each level can either hard-cap spend when the pool runs out or enable overage billing at the published per-credit rate.

Recommended setup for engineering teams:

1. Set enterprise-level budget to 120% of expected monthly spend
   (buffer for unplanned agentic work)

2. Set per-user soft budget at 100% of their plan's included pool
  , they get notified at 80% usage, hard-stop at 100%

3. Enable overage billing for senior engineers running heavy agent work
  , let them go over, review monthly

4. Leave junior/intern accounts hard-capped at base credits only

5. Review the breakdown weekly in May (preview period)
   before June 1 to calibrate budgets with real data

The per-user budget control is the feature most enterprise teams have wanted since Copilot's launch. Previously, a single developer running an unconstrained agentic session could consume the entire org's PRU pool. With per-user caps, that's no longer possible.

Your 10-day checklist

June 1 is ten days out. Here's what to do before the transition.

Individual developers:
  [ ] Open Settings → Billing & plans → Usage on github.com
  [ ] Review May preview data, which features consume the most credits?
  [ ] Calculate: will Pro ($15 effective) cover your usage?
  [ ] Upgrade to Pro+ or Max before June 1 if preview shows overages
  [ ] Note: annual plan subscribers get usage bump automatically on June 1

Team admins:
  [ ] Pull per-user usage data from the API or dashboard
  [ ] Identify top-5 credit consumers by feature (chat vs agent vs review)
  [ ] Set enterprise + per-user budget controls before June 1
  [ ] Decide: hard-cap or overage billing for which user groups?
  [ ] Communicate the change to your team, autocomplete is still unlimited

Everyone:
  [ ] Bookmark: github.com/settings/billing (usage tab)
  [ ] Set a calendar reminder for June 8 to review first week of Credits usage
  [ ] Consider installing a Copilot credits monitoring skill (see below)

The transition is designed to be automatic and non-disruptive for monthly subscribers. The main risk is for teams whose usage patterns would put them over their plan's credit pool without them realizing it. A week of preview data in May is enough to calibrate.

One practical note: if you use Copilot's cloud code review feature on PRs, each review consumes both AI Credits and GitHub Actions minutes. Check your Actions usage too, the combined cost may push some teams toward the dedicated code review tools that bill separately rather than through Copilot.

The underlying bet GitHub is making with this billing model is that model costs will continue to fall faster than AI usage grows. If that holds, and the last three years of model pricing suggest it probably will, flex allotments will expand over time, and the effective value of a Pro or Pro+ subscription will quietly improve without a price change. We'll see whether that bet pays off by the end of 2026.

For now: check your preview bill, pick your plan, set your budget controls, and note that your autocomplete is still unlimited no matter what. The core value proposition of Copilot, fast, zero-friction inline suggestions, didn't change on June 1.

Related reading: Claude Code vs GitHub Copilot 2026, GitHub Copilot custom instruction skills, and productivity skills for Copilot and Claude.