GitHub Copilot Pricing & Billing 2026: Plans, AI Credits & Overages

GitHub Copilot pricing at a glance (June 2026)

Plan	Monthly price	Included AI credits	Best for
Copilot Free	$0	2,000 completions/mo (no AI credits)	Trying Copilot
Copilot Pro	$10 / user	$15 / month	Individual developers
Copilot Pro+	$39 / user	$70 / month	Heavy individual usage
Copilot Max	$100 / user	$200 / month	Power users / heavy agent loops
Copilot Business	$19 / seat*	Org-pooled credits	Teams
Copilot Enterprise	$39 / seat*	Org-pooled credits	Enterprises

Free/Pro/Pro+/Max prices and credit allotments verified against GitHub's official plans page on June 16, 2026 (1 AI credit = $0.01). New Pro/Pro+/Max sign-ups are temporarily paused. Business and Enterprise use GitHub's standard published seat prices (*); GitHub now directs organizations to sales for current per-seat credit allotments. Confirm live figures on GitHub's plans page before budgeting.

The June 1 cutover is the kind of pricing change that looks neutral on the surface and turns into a real budgeting story underneath. I've been tracking the developer reaction since the announcement and the pattern is consistent. Most teams are not going to pay more in absolute terms. A subset of teams that lean on agent mode and Pro+ models are going to pay noticeably more, and they are also the teams that don't know that yet.

Here is what's changing, what's not, and how to figure out which group your team is in before the next billing cycle catches you out.

The mechanism, in one paragraph

Until June 1, every paid Copilot plan came with a fixed monthly bucket of "premium requests" plus unlimited completions. Premium requests covered Copilot Chat, Agent Mode, Edits, and anything that wasn't tab-completion. Run out of premium requests, you got rate-limited until the next billing cycle. As of June 1, that bucket is gone. Instead, plans include a monthly allotment of GitHub AI Credits, denominated at 1 credit = $0.01. Each request consumes credits at the model's token rate (input + output + cached tokens, summed). When the included credits are exhausted, paid plans can buy more by the same per-token math. Code completions and Next Edit suggestions stay free and do not touch credits.

That last sentence matters more than it looks. If your team's Copilot usage is 90% tab-completion and 10% chat, the new model is essentially identical to the old one for you. If your team is running agent loops, large refactors with Claude or GPT-5, or repository-wide edits, the new model is going to surface costs the premium-request system was averaging away.

What each tier includes, exactly

Plan	Price	Included AI Credits	Credits vs price	What rolls over
Copilot Free	$0	None (2,000 completions/mo; no AI credits)	-	N/A
Copilot Pro	$10/month	$15 in credits	1.5x price	Nothing, credits reset monthly
Copilot Pro+	$39/month	$70 in credits	~1.8x price	Nothing
Copilot Max	$100/month	$200 in credits	2x price	Nothing
Copilot Business	$19/seat/month	Org-pooled credits (contact sales)	n/a	Nothing
Copilot Enterprise	$39/seat/month	Org-pooled credits (contact sales)	n/a	Nothing

Note the part GitHub is now leaning on: the included credits exceed the sticker price - Pro is $10/month for $15 of credits, Pro+ is $39 for $70, Max is $100 for $200. That reads as generous, and at cheap-model rates it is. The thing they aren't loud about: $70 of credits at GPT-5.5 or Claude Opus prices is not the same amount of work as $70 at Gemini 2.5 Flash prices. The model you pick decides the burn rate. We'll get into that.

What stays free

Two things, and they're the things most developers use most:

• Code completions. Every paid plan still gets unlimited code completions. The ghost-text "press tab to accept" experience is unchanged. This is also the feature with the cheapest model behind it, so GitHub keeping it free isn't generous, it's pragmatic.
• Next Edit suggestions. The newer "predict the next change you're about to make" feature also remains free across plans.

What's left to consume credits: Chat, Agent Mode, Edits across multiple files, code review assistance, and any feature that uses a frontier model. In other words, the work that was costing GitHub money on premium requests is the work that now costs you money on credits.

The model-rate math

Here's where the new billing gets opinionated. Each model has a published per-token price, and your credits debit at that rate. The expensive frontier models (GPT-5.5, Claude Opus 4.7) burn credits roughly 5-10x faster than the cheap ones (Gemini Flash, GPT-4o-mini). A single complex agent task on Opus can easily consume $0.50-$2.00 of credits depending on context length and tool calls.

Worked example. A Copilot Pro+ user ($39/month, $70 credits) running a typical day of mixed workflow:

• 200 tab completions: free, no credit cost
• 15 Chat messages on the default model: roughly $0.30 in credits
• 5 Agent Mode tasks on Claude Opus 4.7, each ~30K tokens: roughly $5-8 in credits
• 2 large refactors on GPT-5.5 across 5 files each: roughly $4-6 in credits

That's $10-14 of credits in one day for one developer. The $70/month Pro+ allowance covers roughly 5-7 days of that pattern. After that, the user either dials back, switches to cheaper models, or pays overage.

Compare that to a Copilot Pro user ($10/month, $15 credits) doing mostly tab-completion plus occasional Chat: maybe $1-3 of credits per day. The $15 Pro allowance stretches a light-usage month comfortably, but a moderate-usage month will still tip into overage. The math works differently per persona.

What happens to your team on day one

Three migration scenarios, depending on what plan you're on:

Monthly Pro or Pro+: Auto-migrated to the credits model on June 1. No action required. Your old "premium requests" balance is gone; you get the equivalent dollar allocation in credits instead.

Annual Pro or Pro+: You ride out your current term on the old premium-request model. When your annual renewal comes up, you'll be moved to credits. So if you bought an annual plan in October 2025, you're on premium requests until October 2026.

Business / Enterprise: Same shape, depends on contract term. Most Business contracts are month-to-month and auto-migrate; Enterprise contracts negotiated at the seat level might have specific terms.

The trap people are walking into: monthly Pro+ users who were comfortably finishing their premium-request budget every month assume the credits model will work identically. It might. It also might burn through credits 50% faster if they happen to lean on a more-expensive frontier model than the one GitHub was using to cost the premium-request budget against.

Where to see your AI Credit usage (and the VS Code visibility gap)

The single most common question since June 1 is "how do I even see how many credits I've used?" There are three places, and which one shows you anything depends on your plan.

• In VS Code, the Status Bar. Click the Copilot icon in the VS Code Status Bar to open the Copilot status dashboard. It shows the percentage of your monthly AI credit allowance you have used in the current cycle. This is the fastest personal read, and it updates as you work. Remember it only moves on credit-consuming actions (Chat, Agent Mode, Edits); tab completions and Next Edit suggestions are free and never show up here.
• On GitHub.com, Settings then Billing & licensing. The web billing page is where the dollar and credit detail lives: included credits, credits consumed this cycle, and any overage you have authorized. This is the number that becomes your invoice.
• For teams, the organization billing dashboard. Org and enterprise admins get a per-seat Copilot usage report with a downloadable CSV. That CSV is the only view that breaks spend down by member, so it is what you use to find your three highest-burning developers.

The Business / Enterprise visibility gap. A lot of the "I'm on a Business plan and I can't see my credits in VS Code" complaints trace to one design choice: Business and Enterprise seats draw from an organization-level credit pool, not a personal allowance. The Status Bar dashboard is built around a personal allowance, so on a pooled seat it may show little or nothing useful, and the real consumption and overage live in the org billing dashboard that only an admin can open. If your org also turned off member usage visibility, an individual developer sees no number at all until an admin shares the usage report. If that's you, the fix is organizational, not personal: ask whoever owns the GitHub org to export the usage CSV and circulate per-seat numbers. You cannot self-serve your way to a seat-level figure the org has chosen not to expose.

How to actually budget for this

Two pieces of math worth doing now that the credits model is live:

1. Estimate your team's credit burn at current usage

GitHub's billing dashboard has a "premium requests" history. Pull the last 30 days. For each request, you can infer the model used (or assume the default). Multiply each request's token count by the model's per-token credit cost. Sum across the month. That's your projected credit burn at current usage.

Most teams that do this exercise find one of three things:

• Credit burn ≤ 80% of included credits. You're fine. The migration is functionally invisible to your bill.
• Credit burn 80-120% of included credits. You're on the edge. A normal usage spike will tip you into overage. Plan for a 10-20% bill increase or institute model-selection discipline.
• Credit burn >120% of included credits. Your current usage is going to produce overage every month. Either upgrade to the next tier, route to cheaper models, or commit to the agentic patterns that minimize token waste (which we'll get to below).

2. Identify your three highest-burning users

In any team of more than five developers, Copilot usage follows a roughly Pareto distribution. Three or four people produce 60-80% of the spend, usually because they've adopted Agent Mode aggressively for repository-wide tasks. Those are the people you need to talk to before the migration.

The conversation isn't "stop using Copilot." It's "do you know that the way you used Agent Mode yesterday cost $4.50 of credits? Here's the cheaper way to do the same task." Most people don't realize. Sharing the data changes the behavior without changing the tool.

The patterns that minimize credit burn

Without telling people to use Copilot less, here are the workflow patterns that keep credit burn proportional to value:

Use the cheapest model that solves your actual task. Most chat questions don't need GPT-5.5 or Claude Opus 4.7. The default mid-tier models (GPT-5-mini, Claude Sonnet, Gemini 2.5 Flash) handle 80% of Copilot Chat use cases at a fraction of the credit cost. Only escalate to a frontier model when the task genuinely needs it (long-context reasoning, multi-file refactors with subtle invariants, code generation longer than ~500 lines).

Be deliberate about Agent Mode context. Agent Mode burns credits in proportion to the context it loads. If you point it at your whole repo when only three files matter, you pay for the whole repo. Use the @-file references to scope it down.

Cache reuse is free. If the same prompt is sent multiple times in a session (system prompt, repeated tool definitions, conversation history), the LLM provider's cache discount kicks in and your effective cost per request drops by 80-90%. This happens automatically inside Copilot; you don't have to opt in. But your habits affect whether the cache fires. Short focused sessions with the same agent reuse cache better than long disjointed ones.

Don't use Agent Mode for tasks Chat can solve. Agent Mode is a multi-step tool-using loop. Each step costs credits. If your task is "rewrite this function," Chat does it in one call. Agent Mode might do it in four. The Chat version is 4x cheaper.

If you build product on top of Copilot's pattern

This part is for the teams whose product is itself a developer-tool. The credits model is GitHub deliberately exporting the metering problem to its customers. Every customer now has to think about per-developer credit burn, per-team budgets, and overage policies. The teams who'd already built that thinking for their own LLM products (because they were billing usage to their own customers) are going to have an easier time absorbing it. The teams who weren't are going to discover what AI metering plumbing actually involves.

The shape of that plumbing is roughly: track tokens per request per user, attribute those tokens to a customer or cost center, apply a markup or surface the raw cost, alert when a budget is at risk. We built UsageBox for exactly that pipeline. If you're not building a metering layer for Copilot specifically, you're building one for whatever AI feature ships next, which is happening in every codebase that touches LLMs in 2026.

What about the legacy "premium requests" data?

GitHub is keeping premium-request usage history available in the billing dashboard for an audit window after the migration. Pull it before it ages out. The historical pattern is your best baseline for forecasting credit consumption in the new model, and it's not data you can reconstruct after it's gone.

The honest take

The credits model is more honest than the premium-request model. Premium requests were a fixed bucket that quietly subsidized heavy users at the expense of light users. Credits make the per-task cost visible. That's a better incentive structure, and over time it'll push the developer-tool ecosystem toward more efficient agent design.

The short-term cost is that heavy users (the people getting the most value out of Copilot, frankly) are about to see a bill they didn't have before. Not necessarily higher in total. But higher than the implicit zero they were paying for premium-request overuse. Some of those users will absorb it as a cost of doing business. Some will dial back. Some will leave for Cursor, Continue, or whatever else offers a more generous fixed-cost model.

What's certain: every team running Copilot is now also running a metering problem they may not have noticed before. The teams that handle it well will be the ones that put visibility in front of every developer, not just the billing admin. The teams that don't will get the worst version of usage-based billing, which is the version where the bill arrives before the awareness does.

Related reading

• Stripe AI Token Billing Without the Waitlist, the patterns for billing tokens to your own customers
• GPT-5.5 vs Gemini 3.1 Pro vs Claude Opus 4.7 Pricing, the per-model cost math underneath GitHub's credit conversion
• Gemini Pro Free Tier Killed (April 2026), Google's parallel move on the consumer LLM tier
• Gemini API Free Tier (2026), why the free tier disappears once billing is on, and how to keep a free project
• Claude Sonnet vs Kimi vs DeepSeek Billing, the cheaper-model alternatives to Copilot's underlying Claude calls
• Claude API Billing in 2026, the per-model limits behind Copilot's premium-request meter