GitHub Copilot is moving to usage-based billing: a June 1 checklist

Starting June 1, 2026, GitHub Copilot for individual users stops being just “a monthly subscription” and moves to usage-based billing. Your plan still matters, but so do the features you use, the model you choose, and the number of long agent sessions you run.

The good news: code completions and next edit suggestions remain unlimited on paid plans. The less comfortable news: chat, CLI, cloud agent, Spaces, Spark, and third-party coding agents should now be treated as metered usage.

What is changing

GitHub is introducing GitHub AI Credits as the billing unit for Copilot usage. Each model interaction has input tokens, output tokens, and cached tokens. GitHub prices those tokens based on the model, converts the result into AI credits, and subtracts it from your monthly allowance.

The official logic is straightforward:

• 1 GitHub AI Credit equals $0.01 USD;
• a short chat question on a lightweight model may cost a fraction of a credit;
• a long agent session across a large repository will consume more;
• frontier models cost more than lighter models;
• after included credits are exhausted, you can either wait for the next cycle or pay through an additional usage budget.

For paid individual plans, GitHub splits included usage into base credits and flex allotment. Base credits match the subscription price and are meant to stay stable. Flex allotment is an additional variable package that GitHub may adjust over time.

As of June 1, 2026, the lineup looks like this:

• Copilot Pro: $10, 1,000 base credits + 500 flex allotment = 1,500 credits per month.
• Copilot Pro+: $39, 3,900 base credits + 3,100 flex allotment = 7,000 credits per month.
• Copilot Max: $100, 10,000 base credits + 10,000 flex allotment = 20,000 credits per month.

Copilot Free also moves into the usage-based world, but with tighter limits: 2000 code completions per month, an allowance of AI credits, and auto model selection.

Why this matters for developers

Many developers used to think: “Copilot is paid for, so I can ask as much as I want.” That remains true only for part of the product.

If you mostly accept inline completions in your editor, there is no reason to panic. On paid plans, completions and next edit suggestions are not billed in AI credits.

But if your normal day includes:

• long Copilot Chat threads with large context;
• several Copilot CLI commands;
• a cloud agent that works through tasks independently;
• AI code review for pull requests;
• a third-party coding agent connected to Copilot billing;
• a frontier model for every small question,

then the monthly allowance can disappear faster than expected.

The biggest change is not the table of numbers. It is the habit. Copilot now behaves more like a cloud resource: you should not fear it, but you should have a budget, a dashboard, and usage rules.

How to prepare before June 1

Step 1. Understand your real Copilot profile

Do not start by choosing a plan. Start by listing your scenarios. Write down what you typically do with Copilot in a week:

- inline completions in VS Code or JetBrains
- short chat questions about one file
- larger chat questions about a whole module
- Copilot CLI
- agent mode or cloud agent
- code review
- test generation
- legacy-code explanation

Then split the list into two groups.

Lower budget risk: inline completions and next edit suggestions on paid plans. They remain unlimited and should not drive a plan upgrade by themselves.

Higher budget risk: long chat sessions, agentic features, cloud agent, third-party agents, frontier models, large contexts, and repeated “try again, but better” loops.

This list quickly shows whether you need a higher plan or simply better habits.

Step 2. Check usage preview and CSV

GitHub recommends that existing Pro and Pro+ users review projected usage before the transition. On the premium request analytics page, you should see a Preview your usage banner. From there you can download a CSV report or request it through Get usage report.

Two columns matter most:

• aic_quantity — estimated AI credits consumed;
• aic_gross_amount — estimated cost in USD.

You can then open the CSV in GitHub’s billing preview tool. GitHub is clear that this is an estimate, not a final bill. Still, it is good enough for deciding whether Pro is likely to be enough or Pro+ is safer.

Practical rule: do not look only at the average. Look for peak days. One day with several long agent sessions explains future cost better than a calm average week.

Step 3. Choose a plan by workload, not fear

Pro with 1,500 credits can be a reasonable choice if Copilot means completions, short chat, and occasional complex tasks for you.

Pro+ with 7,000 credits makes sense if you regularly use chat, agent mode, larger contexts, and want to think less about every session.

Max with 20,000 credits is positioned for sustained high-volume Copilot work: many agent sessions, frequent frontier-model usage, and active work across IDE, GitHub.com, and CLI.

You do not need to upgrade “just in case” on day one. If your usage budget is set to $0, exhausting included credits should not silently create an extra bill. It is less convenient, but it protects you from surprise spend.

One practical caveat: the GitHub plans page currently warns that new sign-ups for Copilot Pro, Pro+, and student plans are temporarily paused starting April 20, 2026. If you are not already on the plan you want, or you plan to change plans, check current GitHub availability before building your budget around an upgrade.

Step 4. Set usage budget intentionally

After included credits are used, GitHub lets you buy additional usage. The budget is set in dollars, while usage is shown in AI credits. A $10 extra budget equals 1,000 AI credits.

For an individual developer, I would start with one of three modes:

$0 budget. The safest first-month setting, especially if you do not know your pattern yet.

$5–10 budget. A deadline buffer for the days when Copilot is needed now and the monthly package is already gone.

$20+ budget. Reasonable only if Copilot truly replaces part of your daily deep work and you accept unpredictable peaks.

One extra detail: GitHub says purchasing additional AI credits is not available if you subscribe, or have subscribed, through GitHub Mobile on iOS or Android. If you paid through a mobile subscription, check this before June 1.

Step 5. Learn to switch models

The easiest way to reduce cost is not to run the most capable model for every question.

Use lighter models for routine work:

• explaining a compiler error;
• rewriting a small function;
• generating a simple test;
• recalling API syntax;
• finding an obvious lint failure.

Save frontier models for work where complexity is real:

• an architectural decision with several trade-offs;
• a migration plan for a large module;
• security-sensitive review;
• debugging across many files;
• an agent session where a wrong step is expensive.

The analogy is simple: you do not need a truck to buy coffee. The truck is useful when there is something heavy to move.

A separate note on Copilot code review

Copilot code review has a special wrinkle. For most Copilot features, you can see the model being used. For code review, GitHub selects the model automatically and does not expose it directly, so estimating per-token cost before the run is harder.

There is another important detail: starting June 1, 2026, Copilot code review on GitHub-hosted runners will also consume GitHub Actions minutes. That can create two meters: AI credits for the model work and Actions minutes for the agentic infrastructure.

If you are an individual developer, do not run code review automatically on everything. Use it for important pull requests, large diffs, or areas where a second pair of eyes is genuinely valuable.

What not to do

Do not confuse paid completions with paid agent work. Inline completions on paid plans remain unlimited. Other scenarios may become expensive.

Do not make a frontier model the default for everything. It is convenient, but it can burn allowance on tasks where a lighter model would produce the same practical result.

Do not ignore the usage dashboard during the first two weeks. The first days after the transition will show whether your workflow fits the plan.

Do not set a large usage budget without a reason. A budget is not protection. It is permission to spend more after the included package is gone.

Do not judge Copilot only by the monthly subscription price. Look at the whole workflow: time saved, quality, retries, error risk, and actual value.

Conclusion

Copilot does not suddenly become “bad” because of usage-based billing. It becomes more transparent as a paid engineering tool. If you know which features are billed, review usage preview, set a budget, and avoid using frontier models for tiny tasks, the June 1 transition should not hurt.

Short action plan:

1. Check your plan and included AI credits.
2. Download the CSV usage report or review usage preview.
3. Split your scenarios into routine and expensive.
4. Set a usage budget: $0 for a safe start or a small buffer.
5. Use frontier models only where they clearly pay off.

The best strategy is not “use Copilot less.” The best strategy is to use it like an engineering tool with a limit, not like a bottomless magic button.

Official sources:

• https://github.blog/news-insights/company-news/github-copilot-individual-plans-introducing-flex-allotments-in-pro-and-pro-and-a-new-max-plan/
• https://docs.github.com/en/copilot/concepts/billing/usage-based-billing-for-individuals
• https://docs.github.com/en/copilot/how-tos/manage-and-track-spending/prepare-for-your-move-to-usage-based-billing
• https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing
• https://docs.github.com/en/copilot/get-started/plans-for-github-copilot