Table of Contents
GitHub Copilot switches to usage-based billing on June 1: what to do right now
On June 1, 2026, Copilot replaces premium requests with AI Credits: per-token metering at $0.01 per credit. The interesting consequence is not the price change, it is that the price becomes computable. Under premium requests, "is Copilot cheaper than Cursor for me" had no answer because a request was an opaque unit. Per-token metering gives it a hard one. On GPT-5.5, a heavy agentic developer (10 sessions a day, roughly 20,000 output tokens each) burns about $6.00/day, near $180/month. A Pro plan's $10 included pool covers under two days of that. Cursor Pro is a $20/month flat rate. So the crossover is brutal and specific: if your agentic work runs on frontier models past roughly the first two days of the month, Copilot's new model is the more expensive one, and the April report GitHub published May 12 tells you exactly which side of that line you are on.
This piece is the math and the report-reading procedure to find your number before June 1. The data lives in GitHub account settings; the preview tool runs in the browser, no install.
What is actually changing
Premium requests are out; AI Credits are in
Right now, paid plans include a fixed number of "premium requests" per month. One request, one unit, regardless of model or response length. Simple. That simplicity is gone on June 1.
AI Credits price by the token. You pay for what you send (input) and what Copilot returns (output) at rates that vary by model. A fast, cheap model costs a fraction of a frontier model for the same task. Your bill is now a function of which model you choose, how long your prompts run, and how often you hit agentic features. Click count alone no longer decides it.
1 AI credit = $0.01; your plan includes a fixed monthly pool
The credit math is simple. One credit costs one cent. Your plan price maps directly to your included credit pool:
| Plan | Monthly price | Included AI credits | Credit pool |
|---|---|---|---|
| Copilot Pro | $10/user | $10 | 1,000 credits |
| Copilot Pro+ | $39/user | $39 | 3,900 credits |
| Copilot Business | $19/user | $19 | 1,900 credits |
| Copilot Enterprise | $39/user | $39 | 3,900 credits |
Existing Business and Enterprise customers get a promotional boost through August: $30/month for Business and $70/month for Enterprise. After August, the standard amounts above apply.
Credits do not roll over. Unused credits at month end disappear.
Code completions stay free; agentic features meter by the token
Inline code completions and Next Edit suggestions do not touch your credit pool. You can run completions all day at no cost.
Everything agentic does consume credits:
- Copilot Chat (VS Code, JetBrains, GitHub.com, any IDE integration)
- Copilot CLI
- Copilot cloud agent
- Copilot Spaces
- Copilot Spark
- Third-party agents connected through the MCP protocol
If you mostly accept inline completions, your bill barely changes. If you run multi-step chat sessions on frontier models, June 1 is the date your wallet notices.
Step 1 - Pull your April usage report today
How to download the report (individual vs. admin path)
Individual Pro/Pro+ users: Go to GitHub account settings, find Copilot under billing, and click "Preview your usage" on the announcement banner or "Get usage report" on the premium requests analytics page. GitHub generates the CSV and emails it to you.
Business and Enterprise admins: Same path, but through the organization or enterprise billing settings. You'll see usage across all licensed users, broken out by user and feature.
The report generates asynchronously. Expect the email within a few minutes.
How to read aic_quantity and aic_gross_amount
The CSV contains two columns you care about:
user,feature,model,aic_quantity,aic_gross_amount
alice@example.com,copilot_chat,claude-sonnet-4,148,1.48
bob@example.com,copilot_chat,gpt-5-mini,2200,22.00
alice@example.com,copilot_cloud_agent,gpt-5.5,87,0.87aic_quantityis the number of AI credits consumed for that rowaic_gross_amountis the estimated cost in USD at the new rates (credits times $0.01)
Sort by aic_gross_amount descending to find your biggest spenders fast. If you're an admin, the user column tells you who to have a conversation with about model choices before June 1.
Upload to copilot-billing-preview.github.com for a side-by-side view
copilot-billing-preview.github.com is GitHub's browser-based tool for comparing your current request-based bill against the projected AI Credit bill. Upload your CSV and it produces a breakdown by feature and by user, with discount information included. Your data stays in your browser; nothing is sent to a server.
The tool is the fastest way to get from raw CSV to a clear picture of what you're actually spending.
Known data gaps in the April report
Treat the report as a directional signal, not an invoice. Three known gaps:
-
0x model usage missing. Activity from April 1-24 using 0x model pricing is excluded, roughly 2% of paid-plan activity. Your actual June bill may run slightly higher than the report suggests.
-
Possible April 24-30 duplicates. A backfill gap may have created duplicate rows for that window. If totals look unusually high, check for duplicate user/feature/model combinations.
-
Code review credits missing. Some code review rows show 0 AI credits due to a data issue. Code reviews do consume credits starting June 1, so the report likely undercounts that line item.
Watch May usage as it comes in. It won't carry the same backfill issues.
How much do specific features actually cost
Copilot Chat cost per session by model (worked example)
Take a medium-length Copilot Chat session: 2,000 input tokens, 500 output tokens. The cost swings wildly depending on which model you pick. We ran the math for all three tiers using the published June 2026 rates.
| Model | Input rate | Output rate | 2K input + 500 output | Monthly cost, 20 sessions/day |
|---|---|---|---|---|
| GPT-5 mini | $0.25/M tokens | $2.00/M tokens | $0.0015 | ~$0.90 |
| Claude Sonnet 4.6 | $3.00/M tokens | $15.00/M tokens | $0.0135 | ~$8.10 |
| GPT-5.5 | $5.00/M tokens | $30.00/M tokens | $0.0250 | ~$15.00 |
The session math in detail for Claude Sonnet 4.6:
Input: 2,000 tokens / 1,000,000 * $3.00 = $0.006
Output: 500 tokens / 1,000,000 * $15.00 = $0.0075
Total per session: $0.0135Twenty chat sessions per day on Claude Sonnet 4.6 burns roughly $8.10/month. That fits inside a Pro plan's $10 pool. The same workload on GPT-5.5 costs $15/month and blows past the pool every cycle.
GPT-5 mini is the one that surprises people. At $0.0015 per session, you'd need 600+ sessions a day to exhaust a Pro plan. For quick explanations, test generation, or short refactors, GPT-5 mini is the right default.
Source: GitHub Copilot models and pricing page, 2026-05-12. Rates change when GitHub adds or removes models, so verify before finalizing budgets.
Copilot cloud agent and third-party agents
Agentic tasks cost more than chat because the model generates far more output tokens. A single cloud agent run that scaffolds a feature, writes tests, and opens a PR might produce 5,000-15,000 output tokens. On GPT-5.5, 15,000 output tokens costs $0.45. A few of those per day exhausts a Pro plan inside the first week.
Third-party agents connected via MCP consume credits on the same token-based meter. The rate depends on which underlying model the agent calls.
Copilot CLI and Copilot code review
Copilot CLI sessions run shorter than chat. You're translating a command or explaining a flag, not running a full conversation. CLI usage still counts against your credit pool.
Copilot code review has split billing starting June 1:
- AI credits for the model usage
- GitHub Actions minutes for the compute on private repositories
Public repos don't pay Actions minutes. Private repos draw from your existing Actions plan first, then charge overage rates. Two meters hitting at once is easy to miss, so check your current Actions usage now.
Features that cost zero credits
These run without touching your credit pool:
- Inline code completions (all languages, all IDEs)
- Next Edit suggestions
- Code completions in the GitHub mobile app
If these are your primary Copilot use cases, the June 1 billing change has almost no financial effect on you.
Setting budget controls before June 1
Enterprise and cost-center spending limits
Enterprise admins can set a maximum monthly spend for the entire enterprise or break limits down by cost center. Once a cost center hits its cap, agentic features stop for users in that group until the next cycle, or until an admin raises the cap.
Find the controls in GitHub enterprise billing settings under Copilot. Set them before June 1.
User-level caps
Individual users and organization admins can also set user-level budgets. The two options:
- Hard stop at included credits. Copilot refuses additional credit-consuming requests once the included pool is exhausted. Free to set; no overage charges.
- Allow additional usage up to a dollar cap. Set a monthly ceiling in dollars. Copilot continues working until it hits that ceiling, then stops.
Admins can grant or restrict the ability for users to set their own additional-usage budgets.
What happens when credits run out
No fallback model. Before June 1, exhausting premium requests dropped you to a fallback tier. After June 1, exhausting your credits with no overage budget authorized means credit-consuming features stop until the next monthly reset.
Code completions still work. Those don't touch the pool. Chat, CLI, and agent features go dark. Set a small additional-usage budget or default to GPT-5 mini to make the included pool last.
When it makes sense to look at Cursor or Cline instead
The math for heavy agentic users on frontier models
AI Credits priced to the token make the Copilot vs. alternatives comparison concrete for the first time. "Premium requests" were opaque; per-token metering is not.
Picture a developer running 10 agentic sessions per day on GPT-5.5: scaffolding, code review, feature generation. Each session can easily hit 20,000 output tokens. That's $6.00/day in credits, roughly $180/month. A Pro plan's $10 pool covers less than two days of that workload.
Cursor at $20/month flat vs. Copilot with token overages
Cursor's $20/month Pro plan includes unlimited fast premium requests (with daily caps on the very latest models). For developers running constant agentic sessions on frontier models, that flat rate beats Copilot's per-token meter once you clear the included credit pool.
The tradeoff: Cursor doesn't plug into GitHub PR workflows the way Copilot code review does. If your team uses Copilot code review or Copilot Workspaces, Cursor for chat doesn't fully replace the stack. See our Cursor vs. Copilot breakdown.
Cline as a BYOK option
Cline is a VS Code extension that connects directly to any API: Anthropic, OpenAI, Google Gemini, or local models. You pay the model provider directly, no platform markup. At Claude Sonnet 4.6 direct API rates ($3/$15 per million tokens), you pay the same per-token cost as Copilot's AI Credits but control the context window, system prompt, and model version without GitHub's feature gating.
Strong fit for individual developers and small teams comfortable managing API keys. For enterprise workflows that need GitHub PR integration, policy controls, and SSO, Copilot still has the depth advantage.
See our Cline vs. Cursor comparison if you're deciding between the two, or the best AI coding tools roundup for the full field.
What to do before June 1
Run your April report through the preview tool and find your real number, then the decision is mechanical. If inline completions are most of your Copilot use, do nothing; the change does not touch you. If you run a few chat sessions a day on mid-tier models, set the included-pool hard stop and default to GPT-5 mini, and you stay inside the pool with margin. If you are the heavy agentic case on frontier models, you are past the crossover and the flat-rate math wins: Cursor Pro at $20/month is the cheaper plan once you clear the included pool, with the one real caveat that it does not replace Copilot code review or Workspaces in a GitHub-native PR flow. The recommendation flips back to staying on Copilot if your team depends on that PR integration, in which case the move is intentional model selection (GPT-5 mini by default, frontier models only where they earn it) plus a small additional-usage budget as a floor, not a switch.
FAQ
Will annual plan subscribers switch on June 1?
No. If you're on an annual Copilot plan, you stay on request-based pricing until your current plan term expires. Model multipliers will increase on June 1 for annual subscribers, but you won't move to full AI Credit metering until renewal. At renewal, you can convert early for prorated credits or wait for the plan to expire.
Do rollover credits exist?
No. Unused included credits expire at the end of each monthly billing cycle. There is no rollover.
What replaces the fallback model experience?
Nothing, at least not automatically. Before June 1, exhausting premium requests dropped you to a lower-cost fallback model so Copilot kept working. After June 1, exhausting your credits stops credit-consuming features entirely. The replacement strategy is intentional model selection: use GPT-5 mini for routine tasks, reserve frontier models for work that genuinely needs them, and set a small additional-usage budget if you want a safety net.
Can individual users set their own spending limits?
Yes, up to the ceiling their organization admin allows. Users can set a monthly dollar cap on additional usage beyond their included credit pool. If the organization has disabled user-level additional spending, the option won't appear in personal settings.
Where does Copilot code review billing go: Credits, Actions minutes, or both?
Both, starting June 1. AI credits cover the model usage (tokens in, tokens out). GitHub Actions minutes cover the compute that runs the review job. Private repositories draw on your Actions plan entitlement; public repositories don't consume Actions minutes. Check both billing meters in your GitHub settings before the transition hits.