TL;DR
GitHub Copilot killed flat premium requests and switched to token-based AI credits on June 1, 2026. Your $10/month Pro plan now includes 1,500 credits, enough for ~750 coding chats with GPT-5.4 or ~30 heavy agent runs with Claude Opus. Code completions stay unlimited and free. Light chat users won’t notice the change. Agentic power users on frontier models will hit the credit wall in the first week and need Pro+ ($39/month, 7,000 credits) or the new Max tier ($100/month, 20,000 credits) to keep working.
What Changed on June 1
GitHub flipped the billing model for every Copilot plan today. The old system gave you a fixed count of “premium requests” — 300/month on Pro, 1,500/month on Pro+ — regardless of which model you picked or how many tokens the conversation consumed. All of that is now gone.
Every AI interaction (except code completions and Next Edit suggestions, which stay free) now draws from a monthly pool of AI credits. 1 credit = $0.01 USD. The pool sizes:
| Plan | Monthly Price | Total Credits | Effective Budget |
|---|---|---|---|
| Pro | $10 | 1,500 | $15.00 |
| Pro+ | $39 | 7,000 | $70.00 |
| Max | $100 | 20,000 | $200.00 |
| Business | $19/user | 1,900 | $19.00 |
| Enterprise | $39/user | 3,900 | $39.00 |
The total credits include a “flex allotment” on top of the base. Pro gets 1,000 base + 500 flex, for instance. Business and Enterprise plans also received a promotional boost (up to $70/month in credits) running through August.
I’ve been on Copilot Pro+ since January. The migration email landed two weeks ago, and the first thing I did was open the new preview billing page to simulate my typical week. The number was higher than I expected. More on that in the math section.
How AI Credits Work
Three variables determine your credit burn rate:
The model you pick is the biggest factor. GPT-5.4 nano costs roughly 125x less per output token than GPT-5.5, so model selection is now a direct cost decision. (If you’re still deciding which AI coding tool to use at all, see our OpenCode vs Claude Code vs Cursor comparison.)
Input tokens are everything you send: your prompt, file context, conversation history. Copilot’s agent mode can stuff 50K-100K tokens of codebase context into a single request without you noticing.
Output tokens are what the model generates back. Longer responses, more detailed plans, multi-file edits. All scale linearly with output token count.
Cached tokens (where the model reuses context from earlier in the same conversation) cost 80-90% less than fresh input. Continuing a thread is significantly cheaper than starting a new one.
The Full Pricing Table
GitHub charges the following rates per million tokens for each model. These match the raw API prices with zero markup. Your subscription pays for IDE integration and the free completions layer.
OpenAI Models
| Model | Input / 1M tokens | Cached Input | Output / 1M tokens |
|---|---|---|---|
| GPT-5.4 nano | $0.20 | $0.02 | $1.25 |
| GPT-5 mini | $0.25 | $0.025 | $2.00 |
| GPT-5.4 mini | $0.75 | $0.075 | $4.50 |
| GPT-4.1 | $2.00 | $0.50 | $8.00 |
| GPT-5.2 / 5.2-Codex / 5.3-Codex | $1.75 | $0.175 | $14.00 |
| GPT-5.4 | $2.50 | $0.25 | $15.00 |
| GPT-5.5 | $5.00 | $0.50 | $30.00 |
Anthropic Models
Anthropic models add a cache write cost on top of input and output.
| Model | Input / 1M | Cached | Cache Write | Output / 1M |
|---|---|---|---|---|
| Claude Haiku 4.5 | $1.00 | $0.10 | $1.25 | $5.00 |
| Claude Sonnet 4 / 4.5 / 4.6 | $3.00 | $0.30 | $3.75 | $15.00 |
| Claude Opus 4.5–4.8 | $5.00 | $0.50 | $6.25 | $25.00 |
Google Models
| Model | Input / 1M | Cached | Output / 1M |
|---|---|---|---|
| Gemini 3 Flash | $0.50 | $0.05 | $3.00 |
| Gemini 2.5 Pro | $1.25 | $0.125 | $10.00 |
| Gemini 3.5 Flash | $1.50 | $0.15 | $9.00 |
| Gemini 3.1 Pro | $2.00 | $0.20 | $12.00 |
Real Session Costs: The Token Math
I spent last week logging my credit consumption across different interaction types to see how fast different workflows drain the pool.
A quick chat with GPT-5.4 nano — ~1,000 input tokens, ~500 output — costs 0.08 credits ($0.0008). You could run 18,000 of these on a Pro plan. For simple questions, refactoring hints, and boilerplate generation, the billing change is invisible.
Normal coding chat with GPT-5.4 runs about 2 credits ($0.02) for ~2,000 input tokens and ~1,000 output. That’s 750 chats/month on Pro. Most mid-level users live here.
The math shifts once you turn on agent mode. A GPT-5.4 agentic session with multi-file edits and plan-execute-verify loops (~30,000 input, ~10,000 output) costs 22.5 credits ($0.225). Pro gives you about 67 of these per month, roughly 3 per workday. Tight for heavy users, comfortable for occasional use.
Switch to Claude Opus 4.7 for the same token volume and the bill climbs to 40 credits ($0.40) per session. Pro covers ~37 sessions/month. Heavy users will hit the ceiling by week three.
At the extreme end, a large codebase agent run with GPT-5.5 (100K+ input, 20K output) burns 110 credits ($1.10). About 13 of these per month on Pro before you’re done.
The community reports get more extreme. One developer posted a 622-credit single request ($6.23) that burned 41% of a Pro plan’s monthly allocation in one interaction. Others projected monthly costs climbing into the hundreds or even thousands. These are outliers (large codebases, extended agent sessions, frontier models) but they’re real scenarios that the old flat-rate system absorbed without the user ever knowing.
Who Gets Hit and Who Doesn’t
Developers who live on code completions won’t notice anything. Tab-complete and Next Edit remain unlimited and free across all plans. If that’s your primary Copilot use, the billing switch is a non-event.
Light-to-moderate chat users are similarly fine. Five to ten coding questions a day with GPT-5.4 costs 10-20 credits. Your 1,500-credit Pro budget covers a full month without stress.
Agentic users on frontier models are the ones who feel it. If you run Copilot’s cloud agent three or more times daily with GPT-5.4 or Claude Opus, Pro ($10) won’t last the month. Pro+ ($39) gives breathing room at 7,000 credits. Max ($100) at 20,000 credits is the realistic floor for all-day agent usage.
Anyone who relied on the old “fallback model” behavior also gets caught off guard. When premium requests ran out under the old system, Copilot switched you to a cheaper model. That safety net no longer exists. When credits hit zero, Copilot stops responding entirely, unless you’ve set an overage budget.
What Developers Are Actually Saying
The community discussion on GitHub drew hundreds of responses. Three complaints kept repeating.
The rollover question came up constantly: credits expire monthly with no carryover. Had a light week and saved 800 credits? Gone on the billing date. Developmnet cycles are inherently bursty. Sprint weeks burn credits, planning weeks don’t, and the new system punishes that rhythm.
Business and Enterprise plans got promotional credit bumps through August, up to $70/month for Enterprise. Individual Pro and Pro+ users got the same base allotment with zero promotional buffer. That gap drew pointed comments.
Several developers in the thread named alternatives they’re now evaluating: Cursor at $20/month with more predictable agent pricing, Devin Desktop (formerly Windsurf) at $20/month, and Roo Code paired with OpenRouter for Claude access at lower effective rates. The billing change removed one of Copilot’s biggest retention levers: the simplicity of “pay $10, get Copilot.”
Copilot vs Cursor vs Claude Code After the Change
The billing shift makes cross-tool pricing comparisons messy for the first time. Here’s how the $20-40/month tier compares in practice.
| Copilot Pro+ ($39/mo) | Cursor Pro ($20/mo) | Claude Pro ($20/mo) | |
|---|---|---|---|
| Monthly credits | 7,000 AI credits | Usage-based premium requests | Included usage pool (Sonnet 4.6 default) |
| Code completions | Unlimited (free) | Unlimited | N/A (terminal tool) |
| Agent sessions | Token-metered per model | Flat-rate with soft limits | Token-metered via Anthropic API |
| Model choice | GPT-5.x, Claude, Gemini | GPT-5.x, Claude, Gemini, custom | Claude models only |
| IDE support | VS Code, JetBrains, Neovim | Cursor IDE (VS Code fork) | Terminal + any editor |
| Budget control | Credit budgets, hard cap option | Flat subscription | Fixed subscription or API spend cap |
Cursor’s edge is pricing simplicity: $20/month, agent features included, and the cost doesn’t scale with how many tokens your codebase context demands. You trade IDE flexibility for it. Cursor only works in their VS Code fork.
Claude Code is included with the $20/month Claude Pro subscription (or pay-as-you-go via the Anthropic API). No free completions, but for terminal-native developers doing agent-heavy work, it’s often cheaper per session than Copilot because you’re paying API rates without the credit conversion overhead. Heavy users can upgrade to Max ($100-200/month) for higher limits.
Copilot’s remaining advantage is breadth: widest IDE support, free completions floor, and multi-vendor model access. If your workflow is mostly tab-complete with occasional chat, $10/month is still the best value in the market. Credit costs only become real once you start using agent mode regularly.
How to Keep Your Bill Under Control
Install the copilot-cli-cost plugin first. It shows real-time estimated session cost inside Copilot CLI:
bash -c "$(curl -fsSL https://raw.githubusercontent.com/DamianEdwards/copilot-cli-cost/main/install.sh)"
Once installed, use /cost inside any Copilot CLI session to see credit consumption as it happens.
Beyond the tracker, six concrete moves:
Set your overage budget to $0 on day one. You can raise it later, but starting at zero means Copilot stops rather than charges when credits run out. Find it under GitHub Settings → Billing → Copilot → Budget.
Pick your model deliberately. The “Auto” selector often routes to frontier models when a smaller one would work fine. For boilerplate, explanations, and simple refactors, GPT-5.4 nano at $0.20/$1.25 per million tokens is 25x cheaper than GPT-5.5 at $5.00/$30.00.
Keep context windows tight. Close files you’re not editing. Agent mode inhales open-file context, and every extra file is thousands of input tokens you’re paying for. (Also relevant: AI coding tools can leak secrets from those open files.)
Batch related questions. One longer conversation with cached context is cheaper than ten fresh prompts, because cached tokens run 80-90% below the fresh input rate.
Reserve frontier models for hard problems. Architecture decisions, complex multi-file refactors, subtle debugging: those justify Opus or GPT-5.5 pricing. “Add a unit test for this function” doesn’t.
Check your usage dashboard weekly. GitHub → Settings → Billing → Usage. Catch runaway spending before it compounds through the month.
FAQ
What are GitHub Copilot AI credits?
AI credits are Copilot’s new billing unit, replacing the old premium request count. 1 credit = $0.01 USD. Every AI interaction (chat, agents, CLI, code reviews) consumes credits based on the tokens processed and the model used. Code completions and Next Edit suggestions remain free and unlimited on all paid plans.
How much do Copilot AI credits cost per token?
It depends on the model. GPT-5.4 nano runs $0.20 per million input tokens and $1.25 per million output tokens. Claude Opus 4.7 runs $5.00 and $25.00. A quick chat costs a fraction of a credit; a heavy agent session can cost 20-110 credits depending on model and context size. The full pricing table is on GitHub Docs.
What happens when Copilot credits run out?
If your overage budget is $0, Copilot stops responding until your credits reset on the next billing date. If you’ve configured an overage budget, usage continues at $0.01 per credit until that budget is also exhausted. The old automatic fallback to cheaper models no longer exists.
Will GitHub Copilot cost more with usage-based billing?
For chat-focused users, probably not. The included credit pool is generous for moderate use. For developers running frontier-model agent sessions daily, almost certainly. The old system’s 300 premium requests (Pro) worked identically regardless of model cost. The new system prices GPT-5.5 output at 24x what GPT-5.4 nano costs, so model choice directly affects your monthly spend.
What counts as free vs credit-consuming in Copilot?
Free and unlimited: code completions, Next Edit suggestions. Credit-consuming: Copilot Chat, Copilot CLI, cloud agent sessions, Copilot Spaces, Spark, third-party coding agents, and code reviews (which also burn GitHub Actions minutes separately).
Sources
- GitHub Copilot is moving to usage-based billing — official announcement
- Models and pricing for GitHub Copilot — per-model token rates
- Usage-based billing for individuals — individual plan mechanics
- Community discussion #192948 — developer reactions and cost projections
- copilot-cli-cost extension — open-source real-time cost tracker
- TechTimes: Agentic users face steepest increases — independent cost analysis
Bottom Line
GitHub’s billing shift makes financial sense for them. They were subsidizing heavy agentic users under the flat system, and that wasn’t sustainable. (For more on the AI coding productivity paradox, see our earlier analysis.) But the optimization burden now sits squarely on developers. Free code completions keep the base subscription worthwhile, and light chat users won’t feel the change.
But if you run agent sessions daily with frontier models, $10/month is a number on a marketing page. Your actual monthly cost is $39-100, and it’ll creep higher if you don’t watch token usage. The recommended path: start on Pro, set overage to $0, install the cost tracker, and see where your credits actually go for two weeks. If you’re consistently hitting the wall by mid-month, upgrade. If you’re not, the panic in the community threads doesn’t apply to you.