GitHub Copilot Token Billing: Real Cost by Workflow (2026)

On June 1, 2026, GitHub flipped a switch that changed how Copilot billing works for millions of developers. The flat-rate subscription model (pay $10 or $39 a month and use it as much as you want) is gone. In its place: AI Credits that get consumed by every chat message, every agentic task, and every code review request you run.

Developer reaction has been swift. GitHub's own announcement has nearly 900 downvotes. Reddit threads document individual developers projecting monthly bills jumping from $29 to several hundred dollars. The backlash is real. But the picture is messier than the headlines suggest, and a lot depends on exactly how you use the tool.

This guide breaks down the actual numbers, walks through real workflow scenarios, and gives you concrete steps to control your bill. Whether you stay on Copilot or switch to an alternative, you need this information first.

The most important thing first: code completions are still free. Tab completions, Next Edit Suggestions, inline autocomplete: none of that touches your AI Credits balance. If you use Copilot primarily as an autocomplete engine while you're typing, your bill probably hasn't changed.

What does consume credits: Copilot Chat, agent mode, edit mode, code review, and Copilot Workspace interactions. Every one of those features now bills per token (input tokens, output tokens, and cached tokens, converted to credits at a rate of 1 credit = $0.01).

The shift affects every plan tier. Individual developers, teams, and enterprise customers all receive a fixed monthly credit allowance. Once you exceed that allowance, GitHub bills overages automatically at $0.01 per credit unless you set a spending cap.

Understanding the mechanics behind credit consumption is essential for controlling your costs. GitHub converts raw token usage into credits using a formula that factors in three token types: input tokens, output tokens, and cached tokens.

Input tokens represent everything you send to the model. This includes your prompt, the conversation history, and (critically) the codebase context that Copilot automatically attaches. A single chat message might look short, but Copilot often injects thousands of tokens of surrounding code to give the model enough context to answer accurately.

Output tokens are what the model generates in response. Longer, more detailed answers cost more. A one-line function signature costs far fewer output tokens than a full implementation with error handling and comments.

Cached tokens are input tokens that match a previous request in the same session. GitHub charges these at a reduced rate (roughly 25% of the standard input token cost). This is why batching questions in a single session saves money: the context from your first question gets cached and reused for subsequent questions.

Each model has its own token-to-credit conversion rate. Frontier models like GPT-5.5 and Claude Opus 4.7 cost significantly more per token than lightweight models like GPT-5 mini. The conversion rate is not published as a simple multiplier, but the practical effect is visible in the cost tables below.

Not all models cost the same. This is where most developers underestimate their exposure. A quick question on GPT-5 mini might cost 1 to 2 credits. The same question on Claude Opus 4.7 or GPT-5.5 can cost 15 to 40 credits, depending on context size.

If you've been using Copilot's automatic model routing without thinking about which model handles each request, you may have been burning premium credits without realizing it. GitHub's default model selection optimizes for answer quality, not cost. That means your simple "what does this function do?" question might get routed to a frontier model when a lightweight model would have answered just as well.

Your actual bill depends heavily on which of these four profiles matches how you work. Most developers fall into one of them.

The completions-only developer uses Copilot for tab completions and the occasional quick syntax question. Sends maybe 5 to 10 chat messages per day on a lightweight model. Monthly credit spend: 150 to 400 credits. Well within Pro. Bill unchanged.

The daily chat user on lightweight models opens Copilot Chat 10 to 15 times a day, sticks to GPT-5 mini or the default lightweight setting. Monthly credit spend: 600 to 1,200 credits. Likely within Pro. Minimal change.

The daily chat user on frontier models uses Claude Sonnet 4.6 or GPT-5.5 for everything, sends 10 to 15 chat messages per day. Monthly credit spend: 2,000 to 5,000 credits. Over Pro, into Pro+ territory. If you're on Pro and haven't changed your model settings, this is the profile most likely to see surprise overages.

The agentic power user runs agent mode for multi-file refactors, uses Copilot Workspace for larger tasks, runs code reviews on PRs. A single agentic session on a large codebase can cost 200 to 800 credits. At 2 to 3 sessions per day, you could exhaust a Pro+ allowance in 10 to 14 days. This is the group seeing the $200 to $600 monthly bills reported in developer forums.

The credit costs in the tables above tell part of the story. Several less obvious factors can inflate your bill significantly if you're not aware of them.

Every message in a Copilot Chat session includes the full conversation history as input tokens. Your first message might cost 3 credits, but your tenth message in the same session carries all nine previous exchanges as context. By message 15 or 20, you're paying for thousands of input tokens just in conversation history, even if your actual question is short.

The fix: start a new chat session when you switch topics. Keep conversations focused on a single problem. The cached-token discount helps within a session, but it only reduces the cost by about 75%, not eliminate it entirely.

When you use @workspace in Copilot Chat, it indexes relevant files from your project and includes them as context. On a large monorepo, this can pull in 50,000 to 100,000 tokens of context before you even type your question. That single query might cost 10 to 20 credits on a lightweight model, or 50 to 100 credits on a frontier model.

If you're working in a specific module, use @file references to target exactly the files the model needs. Replacing @workspace how do I add a new route? with @file:src/routes/index.ts how do I add a new route here? can cut context by 90%.

Copilot Code Review now charges per review. A small PR (under 100 lines changed) typically costs 5 to 15 credits. A large PR (500+ lines, multiple files) can cost 50 to 200 credits depending on the model used.

For teams running Copilot Code Review on every PR via GitHub Actions, this adds up quickly. A team of 10 developers merging 5 PRs per day at an average of 30 credits per review spends 1,500 credits daily on reviews alone. That's 33,000 credits per month, well beyond any standard plan allowance.

You don't have to accept the default billing behavior. These seven changes can dramatically reduce your credit spend without giving up the features you rely on.

The billing change hits teams differently than individual developers. Organizations need to think about credit allocation, policy enforcement, and cost visibility across their entire engineering team.

On Copilot Business ($19/user), each developer gets 1,900 credits per month. For a 50-person engineering team, that's 95,000 credits monthly, or $950 in included value. If 10 of those developers are agentic power users averaging 8,000 credits each, those 10 developers alone consume 80,000 credits, leaving just 15,000 for the remaining 40 developers.

The math gets uncomfortable fast. Organizations that previously paid a predictable $950/month for 50 seats now face potential bills of $2,000 to $5,000 depending on usage patterns. Engineering managers need per-developer usage visibility to identify outliers and set appropriate guardrails.

This is the question most developers are asking. Here is an honest answer based on actual numbers.

One factor that doesn't show up in cost comparisons: switching cost. If your team has built workflows around Copilot's VS Code integration, @workspace references, and GitHub-native code review, migrating to Cursor or Claude Code means retraining habits and rebuilding prompt libraries. For individual developers, that migration takes a weekend. For a 50-person team, it's a multi-week effort.

The pragmatic approach: audit your current usage during the promotional period (through August 31), project your September bill, and make the call based on real numbers rather than worst-case estimates from Reddit.