100% private · no tracking · works offline100% client-side/no data leaves your browser/no accounts/works offline
A practical breakdown of GitHub Copilot's new AI Credits billing — how tokens convert to dollars, what every plan includes, and how to keep one agent session from eating your month's allowance.
By Amaresh Adak13 min read
Free toolkit
85+ private dev tools
Everything runs in your browser. Zero tracking, no sign-up.
Browse toolsOn June 1, 2026, GitHub replaced Copilot's premium request units with GitHub Copilot AI Credits — a token-metered, usage-based billing system that works like an API bill wearing a subscription costume. Your plan price didn't change, but what you get for it now depends entirely on which models you use and how you use them. This guide breaks down how credits convert to tokens and dollars, what every plan actually includes, what each model costs in practice, and the specific habits that stretch a $10 allowance instead of burning it in one agent session.
In this guide, you'll learn:
GitHub announced the move to usage-based billing in April, and it took effect for all plans on June 1. The old system counted premium request units (PRUs): one request to a premium model consumed one unit times a model multiplier, regardless of whether that request was a one-line question or an hour-long agent run. That flat-per-request model is gone.
The core changes:
GitHub's stated reason is blunt: a quick chat question and a multi-hour autonomous coding session used to cost the user the same amount, and agentic usage is becoming the default. The flat-rate economics stopped working — the same story we traced across Cursor, Claude, and the rest of the industry in our breakdown of AI coding tool pricing in 2026. Copilot was the last big holdout, and now it has folded too.
)
One GitHub AI Credit equals $0.01 USD. When you use Copilot Chat, the CLI, or an agent, the interaction consumes input tokens, output tokens, and cached tokens, each priced per million at the model's published rate. That dollar total is converted to credits and drawn from your monthly allowance — so a $10 Copilot Pro subscription's base allowance is exactly 1,000 credits' worth of model usage.
The mechanics matter more than they sound. Because billing is token-based, the size of what you send is now as important as how often you send it. A chat message that drags a huge context window behind it costs real money in a way a PRU never captured. Cached tokens (context the model reuses across turns) are billed at roughly a tenth of fresh input rates, which is what keeps long conversations from being ruinously expensive — but they are not free.
Two details from the individual billing docs are easy to miss:
Here's what the paid individual plans include as of July 2026, per GitHub's documentation:
| Plan | Price/month | Base credits | Flex allotment | Total monthly credits |
|---|---|---|---|---|
| Copilot Pro | $10 | 1,000 | 500 | 1,500 |
| Copilot Pro+ | $39 | 3,900 | 3,100 | 7,000 |
| Copilot Max | $100 | 10,000 | 10,000 | 20,000 |
Copilot Max is new — a $100/month tier currently open to existing Student, Pro, and Pro+ users who want more included usage, with sign-ups for new users planned as GitHub re-enables registration across plans. Copilot Free and Copilot Student get a credit allowance with auto model selection only; Free includes 2,000 code completions per month, Student unlimited.
On the business side, Copilot Business includes $19 per user per month in credits and Enterprise $39, with a temporary promotion running June through August 2026 that bumps those to $30 and $70 respectively. Crucially for admins, included credits are pooled across the billing entity rather than stranded per seat — a heavy user can draw on allowance a light user never touches.
One upgrade mechanic worth knowing: if you exhaust a plan mid-month, upgrading costs only the price difference between tiers, and your existing usage counts inside the new plan's larger allowance. You are not paying for both plans in the same period.
Every model in Copilot is billed at its listed API rate. The full table lives in GitHub's models and pricing reference; here are the rates for the models most developers actually pick between (all prices per 1 million tokens):
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-5.4 nano | $0.20 | $0.02 | $1.25 |
| GPT-5 mini | $0.25 | $0.025 | $2.00 |
| Claude Haiku 4.5 | $1.00 | $0.10 | $5.00 |
| GPT-5.3-Codex | $1.75 | $0.175 | $14.00 |
| Claude Sonnet 5 (promo until Aug 31, 2026) | $2.00 | $0.20 | $10.00 |
| GPT-5.4 (≤272K context) | $2.50 | $0.25 | $15.00 |
| Claude Sonnet 4.6 | $3.00 | $0.30 | $15.00 |
| Claude Opus 4.8 | $5.00 | $0.50 | $25.00 |
| GPT-5.5 (≤272K context) | $5.00 | $0.50 | $30.00 |
| Claude Fable 5 | $10.00 | $1.00 | $50.00 |
A few things jump out of the full table. Long-context requests cost more: GPT-5.4 doubles its input rate past 272K tokens, and Gemini 3.1 Pro doubles past 200K. Claude models add a separate cache write line item ($2.50 per million tokens on Sonnet 5, up to $12.50 on Fable 5) for storing context that later turns reuse. And the spread between cheapest and most expensive is enormous — Claude Fable 5's output tokens cost 40x more than GPT-5.4 nano's.
The rates only become meaningful when you multiply them out. Take a hypothetical but realistic agentic session: the agent reads across a codebase and iterates for a while, consuming 2 million input tokens (1.5M of them cached rereads, 0.5M fresh) and producing 100K output tokens. Applying the published rates, and setting aside cache-write charges for simplicity:
| Model | Fresh input | Cached input | Output | Total | Credits |
|---|---|---|---|---|---|
| GPT-5 mini | $0.13 | $0.04 | $0.20 | ~$0.37 | ~37 |
| Claude Sonnet 5 | $1.00 | $0.30 | $1.00 | $2.30 | 230 |
| Claude Fable 5 | $5.00 | $1.50 | $5.00 | $11.50 | 1,150 |
Same session, same work — a 30x price difference depending on the model. On a Copilot Pro plan with 1,500 total monthly credits, that one Fable 5 session consumes over three-quarters of your month. Run it on Sonnet 5 and it's about 15%. Run it on GPT-5 mini and you'd barely notice.
By contrast, an ordinary chat exchange — say 6K input tokens and 1K output on Sonnet 5 — works out to roughly 2 credits. Chat is cheap. Agent sessions are where credits go to die, because agents loop: every tool call and iteration resends context. This is the same context-consumption dynamic we examined when comparing how Gemini CLI and Claude Code subagents manage context — architecture that controls context growth is now directly visible on your bill.
GitHub publishes its own usage optimization guide; the advice below combines what's documented with what follows directly from the pricing math.
The single biggest lever. Boilerplate, renames, test scaffolding, and quick explanations don't need a frontier model — GPT-5 mini or Haiku 4.5 handle them at a tiny fraction of the cost. Save Opus 4.8 or Fable 5 for the problems that actually defeat cheaper models. The table above is your menu; order accordingly.
Paid plans get a 10% discount on model costs when using auto model selection in Chat, the CLI, or the cloud agent. If you don't have a strong opinion about the model for a given task, auto selection is literally cheaper than picking manually.
Code completions and next edit suggestions are unlimited and cost zero credits. For small, local edits, accepting a completion instead of asking chat to write the same three lines keeps your allowance intact for work that needs it.
Because every iteration resends context, a sprawling session that wanders across a large repo multiplies input tokens. Start fresh sessions for new tasks rather than continuing a bloated one, scope the agent to the directories that matter, and set session limits to cap spend on agent tasks — GitHub's optimization guide covers the mechanics.
Cross 272K tokens of context on GPT-5.4 and your input rate doubles; same story past 200K on Gemini 3.1 Pro. If a task genuinely needs giant context, fine — but drifting past the threshold because a session accumulated cruft is paying double for garbage.
Claude Sonnet 5 is priced at $2/$10 per million input/output tokens through August 31, 2026 — cheaper than Sonnet 4.6 and most of the mid-tier. If Claude models fit your workflow, it's the best value in the Claude column right now. Expect the math to change September 1.
Your Billing Overview page on github.com shows available allowance and consumption. Look at it mid-month, not when the email arrives. If you're on a team, remember Copilot code review draws Actions minutes in addition to credits — two meters running on the same feature.
)
For organizations, the change is less about price and more about governance. Admins can now set budgets at the enterprise, cost center, and individual user levels, and decide what happens when the included pool runs dry: allow additional usage at published rates, or hard-cap spend. There is no silent fallback model anymore — a capped-out developer stops getting premium model access, full stop, which makes budget configuration an availability decision, not just a finance one.
Pooling changes the planning math too. Under PRUs, each seat's unused allowance evaporated individually. Pooled credits mean a 50-seat Business plan is really a single $950/month usage pool (or $1,500 during the June–August promotion), and your heavy agent users effectively spend your light users' surplus. Watch the distribution for a month before setting per-user budgets — capping your most productive engineer at the median is a false economy.
The other operational note: additional usage is billed in dollars against a budget you define, at the same 1 credit = $0.01 rate. Budgets don't carry over either. Treat them like any other cloud spend line — reviewed monthly, alarmed before exhaustion.
If you're on an annual Pro or Pro+ plan, you're in a transitional limbo: you keep request-based billing until your plan expires, but GitHub raised the model multipliers for annual subscribers on June 1, so your existing allowance drains faster than it did in May. At expiry you drop to Copilot Free with the option to re-subscribe monthly.
You have two options worth weighing. Convert to a monthly plan early — GitHub prorates the remaining value of your annual plan as credit — and get the new system's full allowance plus flex allotment now. Or ride out the annual term at the increased multipliers and decide later. If you barely touched premium requests before, riding it out is fine. If you use agent features regularly, the raised multipliers likely bite harder than the conversion would; check your consumption on the Billing Overview page and do the arithmetic for your own usage before deciding. The community FAQ discussion has GitHub staff answers on the conversion flow.
No. Included credits are forfeited at the end of each calendar month, and your allowance resets to the full monthly amount at 00:00 UTC on the first of the month. The reset date is fixed and does not follow your subscription billing date.
No. Code completions and next edit suggestions remain unlimited on all paid Copilot plans and consume no credits. Credits are consumed by model-driven features: Copilot Chat, Copilot CLI, the cloud agent, Copilot Spaces, Spark, and third-party coding agents.
No. Additional usage is capped, and the cap varies by plan tier, your usage patterns, billing history, and account verification state. Pro+ users generally get higher caps than Pro users. You'll see an in-product notification when you hit a limit, and GitHub's recommended path past it is upgrading to the next tier.
Copilot Max is a $100/month individual tier introduced with usage-based billing, including 10,000 base credits plus a 10,000-credit flex allotment (20,000 total per month). As of July 2026 it's available as an upgrade for existing Student, Pro, and Pro+ users, with new-user sign-ups planned.
Annual Pro and Pro+ subscribers keep request-based billing until their plan expires, but with higher model multipliers that took effect June 1, 2026. They can convert to a monthly plan early and receive prorated credit for the remaining annual value, or let the plan lapse to Copilot Free at expiry.
Copilot's flat-rate era ended the way flat rates always end when a product grows an expensive power-user mode: the meter came out. The plan prices didn't move, but the variance did — a careless month of frontier-model agent sessions can now cost multiples of what any month cost before, while a deliberate developer using cheap models, unbilled completions, and scoped agent runs will live comfortably inside 1,500 credits. The pricing table is public and the math is just multiplication. Do it before the bill does it for you.
Comments
Sign in to join the discussion.
No comments yet. Be the first to share your thoughts.