GitHub Copilot AI Credits: Usage-Based Billing Guide

GitHub Copilot's billing changed fundamentally on June 1, 2026. The old system of counting "premium requests" is gone. In its place: GitHub AI Credits, a token-based usage currency that applies to every paid Copilot plan — Pro, Pro+, the new Max tier, Business, and Enterprise alike.

The change has prompted a sharp reaction from developers. Some agentic power users reported bills jumping 10x–50x overnight. Others discovered their included monthly credits vanish in hours when using GPT-5 or Claude for multi-turn agent sessions. Understanding exactly how the credit system works — and how to constrain it — matters now more than ever.

This guide breaks down the mechanics, the plan differences, model-level cost math, and the new budget controls available for individuals and organization admins.

Why GitHub Made the Switch

The old request-based model counted discrete "premium requests" per model. As GitHub added more frontier models with wildly different inference costs — GPT-5 mini at one end, GPT-5 and Claude Sonnet at the other — a flat per-request charge became economically incoherent. One "request" to GPT-5 mini costs GitHub far less than one to GPT-5.

Moving to token-based AI Credits solves that alignment problem. Each model has its own input/output token rate, and your credit balance decreases in proportion to actual compute consumed. From GitHub's perspective, this is sustainable pricing. From the developer's perspective, it introduces variable costs that can spike unexpectedly, especially when using Copilot in agentic or chat-heavy workflows.

How GitHub AI Credits Work

Every GitHub AI Credit equals $0.01 USD. Your monthly plan includes a credit allowance equal to the plan's base price — a Pro subscriber at $10/month gets $10 worth of credits, a Pro+ subscriber at $39/month gets $39 worth, and so on.

Usage is metered in tokens: input tokens, output tokens, and cached tokens are each billed at the published API rate for the model in use. The token cost is then divided by $0.01 to convert to AI Credit consumption.

One important carve-out: code completions and Next Edit Suggestions are not billed in AI Credits. They remain unlimited on all paid plans. The credit meter runs only when you're using Copilot Chat, agents, inline chat, and similar prompt-driven interactions.

When your included credits run out, the behavior differs by plan and configuration:

• Individuals: By default, you stop at your included allowance. You can opt in to additional metered spending and set a personal cap in billing settings.
• Organizations/Enterprises: Admins decide whether additional usage is allowed after the pool is exhausted, and they can set per-user caps.

The previous fallback — where Copilot automatically dropped to a cheaper model when premium requests ran out — is gone. If you exhaust your credits and haven't enabled additional spending, Copilot Chat simply stops responding.

Plan Comparison

Migration note: Users on annual Pro or Pro+ plans stay on the legacy request-based pricing until their subscription renews. Monthly plan subscribers were automatically moved to AI Credits billing on June 1. New individual sign-ups for Pro, Pro+, and Max were paused starting April 20, 2026; Max is currently an upgrade-only tier for existing subscribers.

Business and Enterprise plans receive a temporary credit boost: existing subscribers received higher included AI Credits for the transition period from June 1 through September 1, 2026 — giving teams time to observe and calibrate usage before full metered billing kicks in.

Model Pricing Breakdown

This is where the real variation lies. GitHub Copilot exposes multiple models, and each has its own token rate. The following figures are approximate based on published API rates as of June 2026; check the GitHub Docs models and pricing page for the current canonical table.

To put that in practical terms: a Pro subscriber with $10/month in credits could run roughly 50 short GPT-5 mini conversations (assuming ~5K tokens each) or only 5–6 similar conversations using GPT-5. The model choice matters enormously.

For agentic sessions — where an agent iteratively reasons, calls tools, processes results, and generates multi-step plans — token counts climb fast. A single agentic coding session using GPT-5 can consume several hundred thousand tokens, which translates to several dollars in credits in one sitting.

Budget Controls: Individuals

Individual subscribers can set a personal spending cap directly in GitHub billing settings under Copilot → Spending Limits. The default behavior after your included credits are exhausted is to stop (no additional charges). You can opt into metered overage and cap additional spend at any dollar amount you choose.

Key things to configure:

1. Enable additional usage — toggle required to allow any spending beyond included credits.
2. Monthly spending cap — set in dollars; once hit, Copilot Chat stops until next billing cycle.
3. Model preference — in the Copilot settings within your IDE, you can pin a default model. Defaulting to GPT-5 mini for everyday tasks preserves credits for when you actually need GPT-5 or Claude.

Monitoring usage is available in GitHub's billing dashboard under Usage → GitHub Copilot. The dashboard shows credits consumed per day and per model, which makes it straightforward to spot sessions that burned through budget unexpectedly.

Budget Controls: Organization and Enterprise Admins

For organizations and enterprises, the new user-level budgets (ULB) are the most important addition. Admins can now:

• Set a universal per-user credit cap that applies across the entire organization.
• Override the cap for specific users or teams — for example, giving senior engineers higher limits.
• Receive email notifications as individual users approach their cap, before they're cut off.
• Adjust budgets at any time from the organization's billing settings.

Credits are now pooled across the org, not siloed per user. Under the old system, if one user had leftover credits and another ran out, there was no sharing. Now the included pool is shared, eliminating stranded capacity. When the shared pool runs out, admins control whether additional spending is permitted and up to how much per user.

This changes the admin workflow: instead of purchasing individual per-seat licenses and watching them hit walls independently, you manage a single credit pool with user-level guardrails on top.

To configure these:

1. Go to your organization's Settings → Billing and Licensing → GitHub Copilot.
2. Under Budget Controls, set the default per-user monthly spend limit.
3. Under User Overrides, add specific GitHub usernames with custom limits.
4. Enable email alerts for approaching thresholds.

Enterprise plans have an additional tier: cost-center-level budgets, letting you segment credit allocation by team, division, or project.

Real Cost Scenarios

Scenario 1 — Everyday individual developer (Pro, $10/month)
Uses Copilot Chat 5–10 times per day for short code questions with GPT-5 mini. Token usage: ~20K tokens/day → ~$0.05/day → ~$1.50/month. Well within included credits with room to spare. Model choice at this usage level doesn't cause sticker shock.

Scenario 2 — Power user on Pro+ ($39/month) doing agentic coding
Runs 2–3 Copilot agent sessions per day using GPT-5. Each session: ~200K input tokens + 50K output tokens. Daily cost: ~(200K × $3.75 + 50K × $15) / 1M ≈ ~$1.50/day. Monthly: ~$45 — which exceeds included credits. This user needs Pro+ with metered overage enabled, or Copilot Max.

Scenario 3 — Small engineering team (Business, 10 developers)
Included pool: 10 × $19 = $190/month. Mixed usage: 7 developers light (GPT-5 mini chat), 3 heavy (daily agentic GPT-5 sessions). Light users consume $3/month each ($21 total); heavy users consume $45/month each ($135 total). Total: ~$156 — within pool. But in months when a deadline pushes heavy users to 4–5 agent sessions per day, the pool could run over.

The takeaway: completions are free, and light chat with a budget model stays affordable. The cost exposure concentrates in agentic workflows using premium models.

Practical Steps for Managing Your Copilot Spend

1. Audit which model you're actually using.
Many developers accept whatever model Copilot defaults to without thinking about cost. Check your IDE settings — VS Code and JetBrains both surface the active model in the Copilot status bar. If you're on GPT-5 by default, switch to GPT-5 mini or GPT-5.5 for routine questions and reserve the top-tier model for complex reasoning tasks.

2. Set a hard cap before enabling metered overage.
If you want the safety net of continued access after exhausting included credits, enable metered overage — but also set a monthly cap. Without a cap, a runaway agentic session (or a stuck agent in a loop) can generate an unexpectedly large bill by end of month.

3. For orgs: start with a conservative per-user limit, then adjust.
Rather than setting a high user limit up front and hoping it's enough, set a conservative default ($30–$50 above included per-user) and let notifications guide you to which users legitimately need more.

4. Use the billing dashboard's per-model breakdown.
The usage dashboard in GitHub settings shows credit burn per model per day. After a week of normal usage, you'll have a clear picture of where your budget goes and whether your defaults are appropriate.

5. Code completions are free — use them.
Inline completions and Next Edit Suggestions don't touch your credits. If you can phrase a task as something completions handle (e.g., writing a function body by setting up the signature), that's zero cost compared to asking Copilot Chat to write it.

Frequently Asked Questions

Q: Does switching from Pro to Pro+ actually get me more included credits, or just more features?

Both. Pro+ costs $39/month and includes $39 in AI Credits, compared to Pro's $10/month and $10 in credits — nearly 4× the monthly budget. Pro+ also unlocks access to additional premium models. If you're regularly hitting the ceiling on Pro, upgrading to Pro+ is straightforward math. Copilot Max is more involved: it's currently upgrade-only and targets high-volume agentic use.

Q: I'm on an annual Pro plan. Am I already on AI Credits billing?

No. Annual plan subscribers stay on the legacy request-based pricing until their subscription renews. When it does renew, you'll automatically move to AI Credits billing. GitHub docs recommend reviewing your usage history before renewal to estimate whether your included credits will cover normal usage.

Q: Our organization uses Copilot Business. How does the credit pool work for our team?

All per-seat included credits are merged into a single shared pool for the organization. If your team of 10 pays $19/user/month, you have a shared pool of $190/month in AI Credits. When one user is below their natural share and another is above, the pool absorbs the variance. You control whether additional spend is permitted once the pool is exhausted, and you can set per-user caps to prevent any single user from draining the pool.

Q: What happens if I run out of credits mid-session?

For individuals who haven't enabled metered overage, Copilot Chat stops returning responses once your included credits are exhausted. The IDE will display a credit exhaustion notice. Completions and Next Edit Suggestions are unaffected and keep working. For organizations, the behavior depends on admin configuration — orgs can enable or disable continuation past the pool limit.

Q: Can I keep using Copilot with only the free tier to avoid all of this?

Yes, Copilot Free provides limited access to Copilot Chat and completions at no cost. The free tier rotates model access and applies daily usage caps, so it isn't a substitute for Pro or Pro+ in a professional workflow. But for lightweight experimentation or occasional use, it's a legitimate option.

Key Takeaways

GitHub Copilot's move to AI Credits billing reflects a structural reality: different models cost different amounts, and a flat request count can't bridge that gap forever. The tradeoff is that developers now face variable monthly costs instead of a predictable flat rate.

The practical impact splits by use case. If your Copilot usage is primarily inline completions and occasional short chat questions, the new system likely doesn't change your effective cost much. If you run agentic sessions, long multi-turn conversations, or use premium models heavily, the credit math deserves close attention.

The new user-level budgets for organizations are a genuine improvement over the old per-seat model — pooled credits eliminate the waste of stranded per-user balances, and per-user caps give admins actual control. For individuals, the combination of metered overage with a hard cap is the safest configuration if you want uninterrupted access without surprise bills.