GitHub Copilot AI Credits, decoded: what Pro, Pro+, and Max actually cover after June 1

What changed on June 1

On June 1, 2026, GitHub flipped every Copilot plan to usage-based billing. The new unit is “GitHub AI Credits,” with a conversion rate spelled out in the docs: 1 AI credit equals $0.01 USD. Pro gets 1,500 included credits ($15 worth). Pro+ gets 7,000 ($70). The new Max tier gets 20,000 ($200). Each plan's pool covers chat and agent usage at per-token model rates.

What did not change: code completions and Next Edit suggestions remain unlimited on every paid plan. The docs are explicit about this. If your Copilot usage is mostly inline completions, the billing change does not touch your workflow.

Two other things happened in the same six-week window worth knowing about. As of June 1, Copilot code review now consumes GitHub Actions minutes in addition to AI Credits. And on April 24, GitHub flipped interaction-data collection to on by default for Free, Pro, and Pro+ users, with opt-out buried in settings. Three changes in six weeks. Pricing, training data, and reviewer compute. We covered the data policy on our full Copilot comparison; this post is the deep dive on the credit math.

GitHub also paused new sign-ups at the cutover. The June 1 changelog reads verbatim: “New user sign-ups remain paused for Copilot Student, Pro, Pro+, and Max plans. We'll reopen sign-ups in the coming weeks.” The Student tier is in that list, which closes the trial pipeline that historically fed Pro upgrades. Existing subscribers were grandfathered into the transition. New ones, for the moment, cannot subscribe at all.

The plan-tier math, decoded

Three plans, three credit pools, two flex allotments doubled and one tripled. The structure:

The flex allotment is the part most readers ask about. It is an additional credit pool baked into your plan, not a toggle. There is no published off-switch for any individual plan. Once you exhaust included credits, you can either purchase additional usage or set an additional-usage budget at $0 to cap overage spending. Organizations and enterprises have more granular admin-level budget controls.

A note on what the dollar value actually buys: it depends entirely on which model you pick. Some models cost nothing on a paid plan. Others can burn through 800 credits in a single request. The credit pool is not the constraint. The model selection is.

The model rates that actually drive the bill

Twenty-two models live in the Copilot catalog as of June 2026. Two of them are billed as included on paid plans, meaning they consume zero credits. The other twenty are metered per token at the model's published rate. Here is the working subset, sorted by output cost from highest to lowest, with the included models at the bottom so they read as “the safe place to live”:

The full table at docs.github.com has all twenty-two, including the Codex variants (GPT-5.2-Codex and GPT-5.3-Codex at $1.75 / $14.00) and Raptor mini, Gemini 2.5 Pro, Gemini 3 Flash, Gemini 3.5 Flash. Above is the working set most developers will actually touch.

A few things to read off the rates:

Output is the load-bearing number. Output tokens cost 4x to 6x more than input tokens on most models. An agentic task that produces a 30K-token diff costs much more than reading a 30K-token codebase. If you tune for credits, you tune for output length.

Two free models is real coverage. GPT-4.1 handles most “explain this code” and “write me this function” interactions. GPT-5 mini covers shorter completions and refactors. A developer who lives in the included models burns no credits at all. The credit budget exists for the moments when you reach for something stronger.

The premium-output spread is wide. Claude Sonnet 4.6 at $15 per million output tokens. GPT-5.5 at $30. Claude Opus 4.5-4.8 at $25 in the middle (all four versions priced identically). The same prompt, the same answer length, costs 2x more on GPT-5.5 than on Sonnet. Model choice is now the most consequential decision you make per session.

A worked session, billed against the rates

What does an architecture-and-refactor session actually cost? Here is a realistic walk-through with the live rates from the table above.

You open a chat with Claude Sonnet 4.6. You paste in a 10K-token codebase context and ask for a structural review. The model returns 5K tokens of output.

• Input: 10K * $3.00 / 1M = $0.030 = 3 credits
• Output: 5K * $15.00 / 1M = $0.075 = 7.5 credits
• Subtotal: 10.5 credits

You follow up four times. Each follow-up averages 8K tokens in, 6K tokens out, because you keep the codebase context in scope.

• Input: 8K * 4 * $3.00 / 1M = $0.096 = 9.6 credits
• Output: 6K * 4 * $15.00 / 1M = $0.360 = 36 credits
• Subtotal: 45.6 credits

You switch to Claude Opus 4.7 for the harder refactor plan. 15K in, 8K out.

• Input: 15K * $5.00 / 1M = $0.075 = 7.5 credits
• Output: 8K * $25.00 / 1M = $0.200 = 20 credits
• Subtotal: 27.5 credits

Then you hand the plan to an agent task running on Sonnet 4.6. The agent reads 5K of context and writes a 40K-token diff.

• Input: 5K * $3.00 / 1M = $0.015 = 1.5 credits
• Output: 40K * $15.00 / 1M = $0.600 = 60 credits
• Subtotal: 61.5 credits

Total session: roughly 145 credits, or $1.45. For a Pro plan ($15 included), that is about ten such sessions per month before overage. Pro+ at $70 buys about forty-eight. Max at $200 buys about one hundred thirty-seven.

That math assumes you stay on Sonnet and reach for Opus only once. Run the same session entirely on GPT-5.5 and the cost roughly doubles. Run it on the included GPT-4.1 and the credit cost is zero, though the quality ceiling is lower for the harder refactor step.

The reaction in the community thread

The original announcement discussion on github.com/orgs/community (thread #192948) currently sits at 958 downvote reactions to 24 upvotes. Two developer reports anchor the agentic-use complaint that drove most of the volume.

“822 credits gone in a single request” on a small project described as “just a few screens.” That one call burned 54% of a Pro+ monthly allocation in one shot.

Run that against the rate table: 822 credits is $8.22. That maps to roughly a 65K-token Claude Opus interaction (15K in + 25K out at Opus rates) or a 45K-token GPT-5.5 interaction (10K in + 18K out at GPT-5.5 rates). Both are realistic for a single agentic refactor on a real codebase. It is not a bug. It is what happens when you pair a Powerful-tier model with a high-output workload.

“8% of monthly credits in two hours of regular development work,” projecting full depletion in under two days at that pace.

The structural shift is not that bills went up. It is that the meter became visible. Under the old premium-request system, every call counted as one unit regardless of model. The credit system removes that fiction. A 30K-output Opus call now costs what it costs. The same prompt on GPT-5 mini costs zero. The user has to know which one to reach for.

For developers who built habits around model-agnostic pricing, that is the friction. They got trained on agentic workflows when the meter did not exist, and they are now paying real per-token rates on those same workflows. The Register's June 2 coverage captures the same pattern across multiple developer interviews. The complaint is rarely about the credit pool size. It is about the workflow dependency built under one pricing regime and now repriced under another.

What this means for your workflow

The math runs differently for different users.

Light user. Mostly inline completions and short chats, lightweight models. Pro at $15 is more than enough. GPT-4.1 and GPT-5 mini cover most ground without touching the credit pool. The new system is invisible to you.

Moderate user. Daily chat with Sonnet-class models, occasional agent task. Pro+ at $70 is workable with discipline. Watch the model column before you pick. A full month of Sonnet at moderate pace runs roughly $20 to $30 in credits. You have room.

Heavy agentic user. Multi-step agent tasks with Opus or GPT-5.5 daily. The math does not work at any included tier. $70 in credits depletes in three or four days of sustained heavy-model agentic use. Max at $200 stretches the runway to about ten days. After that, you are paying overage or rationing model choice.

For the third profile, two off-ramps actually remove the meter instead of moving it:

1. A BYOK extension. Cline and Continue.dev run as VS Code extensions in bring-your-own-key mode. You bring your own API key, pay your model provider directly, and the meter lives at the provider not the platform. No credit pool, no flex allotment, no transition window. Both are free under Apache 2.0.

2. A one-time-purchase IDE. Bodega One Code is $79 Personal or $149 Pro. Standalone desktop app, Monaco editor, autonomous coding agent, 10+ provider presets via BYOLLM, air-gap mode for regulated environments. No credit system, no monthly renewal, no per-token meter. You can run local models via Ollama or LM Studio at zero inference cost, or BYOK to Anthropic, OpenAI, Groq, and others.

The credit math is not the only reason to consider switching. It is the most visible. The deeper question, once the meter becomes legible, is whether you want any meter at all.

For the full side-by-side breakdown of features, training-data policy, and architecture, read our GitHub Copilot alternatives page. For the math on what Anthropic API direct costs versus routing through a credit broker, read Kilo Pass vs Anthropic API direct.

Sources

• GitHub Copilot models and pricing (the authoritative model + rate table, 1 AI credit = $0.01 USD): docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing
• Updates to GitHub Copilot billing and plans (June 1 changelog, sign-up-pause verbatim, Actions-minutes for Copilot code review): github.blog/changelog/2026-06-01-updates-to-github-copilot-billing-and-plans
• GitHub Copilot is moving to usage-based billing (April 27 announcement): github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing
• Introducing flex allotments in Pro and Pro+, and a new Max plan (plan amounts): github.blog/news-insights/company-news/github-copilot-individual-plans-introducing-flex-allotments-in-pro-and-pro-and-a-new-max-plan
• GitHub Copilot community discussion #192948 (958 downvotes, developer cost reports including the 822-credit single request and 8%-in-two-hours): github.com/orgs/community/discussions/192948
• The Register: Angry devs vow to flee GitHub Copilot as metered billing takes hold: theregister.com