As of October 28, 2026, GitHub Copilot costs $10 a month for Pro, $39 for Pro+ and $100 for Max. Each plan includes AI credits worth $0.01 apiece: 1,500 ($15), 7,000 ($70) and 20,000 ($200). Credits pay for the tokens chat and agent work use; code completions don’t touch them. Business is $19 and Enterprise $39 per seat, with 1,900 and 3,900 credits per user.
What actually changed: premium requests to GitHub Copilot AI Credits
Before June 1, 2026, when GitHub replaced premium requests with GitHub AI Credits for monthly Pro and Pro+ (the sticker prices didn’t change), Copilot billed on premium requests. Every chat message, agent turn, CLI call, or code review counted as one “request,” and each model carried a multiplier: a request answered by a 50x-multiplier model like GPT-4.5 cost the same as 50 standard requests, regardless of how long or short the exchange actually was. Plans included a flat monthly request quota, and going over cost a flat fee per request. Annual Pro and Pro+ subscribers stay on premium requests until their plan expires, then move to Copilot Free unless they upgrade.
That flat-count model is gone. Under GitHub AI Credits, cost is calculated from actual input, output, and cached tokens consumed, priced at each model’s published API rate, and denominated in credits where 1 credit = $0.01. A short chat question and a long, context-heavy agent task on the exact same model can now cost wildly different amounts, which the old per-request system never captured. GitHub’s own transition announcement is blunt about the other half of the change: “fallback experiences will no longer be available.” Previously, running out of premium requests meant Copilot quietly downgraded you to a cheaper model. Now, once your credit balance is gone, you’re either paying overage at metered rates or you’re stopped.
One thing didn’t change: code completions and next edit suggestions don’t use credits. Paid plans get unlimited completions; Free gets 2,000 a month. The credit meter only applies to Chat, Agent Mode, code review, the CLI, and Copilot Spaces.
GitHub Copilot pricing and credit allotments in 2026
| Plan | Monthly Price | Included AI Credits | Notes |
|---|---|---|---|
| Free | $0 | 2,000 code completions/month + limited chat | No paid credit allotment |
| Pro | $10/user | 1,500 credits ($15) | 1,000 base + 500 flex credits |
| Pro+ | $39/user | 7,000 credits ($70) | 3,900 base + 3,100 flex; intended for heavier individual agent use |
| Max | $100/user | 20,000 credits ($200) | 10,000 base + 10,000 flex; priority access to premium models |
| Business | $19/user | 1,900 credits/user ($19) | Centralized policy control, broad model catalog |
| Enterprise | $39/user | 3,900 credits/user ($39) | Adds codebase indexing, priority model access |
Prices and credits from GitHub’s Copilot plans docs, checked October 28, 2026. 1 credit = $0.01.
Three details in that table move over time:
- Base credits equal the plan price and are fixed; flex credits are the extra on top, and GitHub’s plans page says “Flex allotments may change over time.” Base credits are used first, then flex.
- The June to August 2026 promotion that gave existing Business and Enterprise customers $30 and $70 per user has ended.
- Auto model selection gets a 10% discount on model cost on paid plans. Max had a 30% auto-selection discount that ran through October 28, 2026.
How credits actually get burned per model and task
The old multiplier system was crude but predictable: a 50x model cost 50x, every time, no matter what you asked it. The new system scales continuously with tokens, so the same question can cost very different amounts depending on how much context gets sent and how long the response runs.
UsageBox’s 2026 Copilot billing guide (a third-party aggregator, not re-checked October 28, 2026) reports that expensive frontier models (GPT-5.5, Claude Opus 4.7) burn credits roughly 5-10x faster than budget models like Gemini Flash or GPT-4o-mini, and that a single complex agent task on a frontier model can run $0.50-$2.00 in credits. The Register (June 2, 2026) reported a Pro+ subscriber burning 1,180 credits (about 17% of their entire monthly Pro+ allowance) on one agent coding task that produced mediocre results. GitHub publishes per-model rates in a separate doc, “Models and pricing for GitHub Copilot”; the 5-10x and per-task figures above are UsageBox’s estimates, not GitHub’s, so treat them as directionally accurate rather than confirmed rates.
Real-world solo dev cost scenarios
A representative mixed-workflow day for a Pro+ subscriber ($39/month, 7,000 credits or $70), estimated in September 2026 from third-party per-task figures such as UsageBox’s (not GitHub data), looks like this:
| Activity | Estimated Cost |
|---|---|
| 200 tab/code completions | Free (unmetered) |
| 15 chat messages on a budget model | ~$0.30 |
| 5 Agent Mode tasks on a Claude Opus-tier model (~30K tokens each) | ~$5-8 |
| 2 large multi-file refactors on a frontier model (e.g., GPT-5.5) across 5 files | ~$4-6 |
| Estimated daily burn | $10-14/day |
At that pace, a full $70 monthly Pro+ allotment is gone in roughly 5-7 days if the pattern repeats daily. That means a solo dev who codes every day and leans on agent mode with frontier models could exhaust a month’s credits before the second week starts, then face either overage billing at the same metered rate or a hard stop, since the old fallback-to-cheaper-model behavior no longer exists.
The self-reported numbers circulating since launch are more dramatic, and worth stating carefully as anecdotes rather than universal outcomes:
- One developer reported a jump from roughly $29/month to a projected ~$750/month.
- Another reported roughly $50/month jumping to a projected ~$3,000/month.
- A Pro+ user reported burning about 8% of their monthly allotment within two hours of normal work.
- Another reported a single feature request costing over $6.
These figures come from social-media and forum posts surfaced by TechCrunch and The Register, not audited billing statements. Some commenters in the same threads pushed back, attributing the worst bills to inefficient “vibe coding” prompting habits rather than the pricing model itself, and noting that Microsoft’s old flat-rate system had actively encouraged the kind of unrestrained agent usage that now produces sticker shock. That’s a real counterpoint worth holding alongside the anecdotes. Still, the same workflow that cost a flat $10 or $39 in May now costs whatever your additional-usage budget allows.
Overage: what happens when you run out
When your credits run out you can upgrade, set an additional-usage budget, or wait for the reset, per GitHub’s billing docs (checked October 28, 2026). Under the old system, going over your premium-request quota cost a flat fee per request, scaled by whatever multiplier the model carried. Under GitHub AI Credits, there’s no separate flat overage fee. Once your included allotment is gone, paid plans (Pro, Pro+, Max, Business, Enterprise) can keep going, billed at the exact same per-token API rate used to meter the included credits, up to a budget you set in dollars ($10 buys 1,000 credits). GitHub says extra usage “may be capped”, and to continue past the cap you must pay what you’ve used. Budget alerts fire at 75%, 90% and 100%. An upgrade charges only the price difference and counts this cycle’s usage. Credits reset at 00:00 UTC on the 1st of each month and don’t carry over. It’s continuous metering, not a penalty tier. The Free plan has no overage option at all; usage simply stops at the included allotment.
What developers are actually saying
Coverage of this change has been overwhelmingly negative, and no offsetting positive developer testimonials turned up in the reporting reviewed for this piece. Visual Studio Magazine’s April 2026 pre-launch coverage summed up the sentiment before the change even shipped: “you will get less, but pay the same price.”
Once the change went live, TechCrunch (Lucas Ropek, May 30, 2026) quoted a developer calling the new system “just stupidly expensive” and reported the self-described cost jumps mentioned above. The Register (O’Ryan Johnson, June 2, 2026) reported a developer describing the shift as going from “a predictable subscription” to “a stressful meter-based” service, and noted some developers stating intentions to migrate workloads to Anthropic’s or OpenAI’s direct APIs, or to routing layers like OpenRouter, RooCode, or LM Studio. gHacks Tech News corroborated “rapid credit depletion” as the dominant launch-week complaint. Microsoft did not respond to TechCrunch’s request for comment as of that article’s publication.
The one meaningful counterpoint in the same coverage: some commenters argue the backlash conflates two separate things: a genuinely fairer, more granular cost allocation for light users, and a jarring transition for heavy agent users who built workflows around a flat-rate system Microsoft itself had encouraged. Neither changes what a heavy Agent Mode user should expect their bill to look like starting this summer.
GitHub Copilot AI Credits vs Cursor vs Claude Code: pricing predictability compared
Copilot is arguably catching up to where Cursor and Claude Code already were.
Cursor (as of October 28, 2026): Free, Plus ($8/month, Grok models only), Premium ($30), Super ($100) and Ultra ($200), plus Teams seats from $30/user. Each tier has a weekly pool of Cursor-model usage. Claude, GPT and Gemini aren’t in that pool: from Premium up they bill at API list price from the first request, paid from prepaid credit and capped by a monthly additional usage limit. Older plans such as Pro and Pro+ continue for existing customers with two monthly usage pools plus on-demand usage. Structurally, Cursor’s third-party billing is close to what Copilot just adopted. Cursor’s own plan structure has shifted multiple times in 2026 already, and we’ve covered why Cursor bills spike for developers who hit the same kind of shock Copilot users are experiencing now.
Claude Code (Anthropic): Access splits between subscription plans (Pro at $20/month with usage caps, Max at $100 or $200/month for 5x or 20x higher limits, and Team/Enterprise seats), which meter usage against rate-limited windows rather than charging per token directly, and pure pay-per-token API access (Claude Sonnet 5 at $2/$10 per million input/output tokens, Claude Opus 5 at $5/$25 per million, Claude Haiku 4.5 at $1/$5 per million). Prompt caching cuts effective input cost by roughly 90% on repeated context, which matters a lot for Claude Code’s typical pattern of re-sending a large, stable codebase context every turn. If you’ve run into throttling on a Claude subscription tier, our breakdown of Claude Code rate limits explains how those windows work differently from Copilot’s credit-balance model.
The practical takeaway for a solo developer isn’t “flat-rate vs. metered” anymore, since that era is basically over across the category. What actually differs between these three tools now is (1) how large the included allotment is relative to your real usage pattern, (2) whether the tool still degrades gracefully to a cheaper model when you’re running low (Copilot just removed this, and it’s the single most-cited cause of the price-shock complaints), and (3) whether the vendor prices its subscription as a markup over its own API rates or passes usage through closer to cost. If you’re trying to model your own burn rate before committing to a tier, our Cursor Auto Mode cost breakdown walks through a similar per-task cost exercise that applies just as well to Copilot’s Agent Mode.
Completion-heavy users can keep Copilot Pro
If your workflow is mostly code completions with the occasional chat question, GitHub Copilot’s AI Credits billing barely touches you: that usage stays free or nearly free, and Pro at $10/month still looks like a reasonable deal. The math only turns ugly if you’re running Agent Mode tasks against frontier models like GPT-5.5 or Claude Opus 4.7 multiple times a day; that’s the exact usage pattern behind the $29-to-$750 and $50-to-$3,000 anecdotes TechCrunch and The Register reported in late May and early June 2026.
For that heavier group, switching tools won’t necessarily help, since Cursor and Claude Code have the same fundamental economics now. The fix is tracking your actual burn rate before you’re surprised by it. Watch which model each task defaults to, push routine work toward budget models, and reserve frontier models for the tasks that actually need them. If you’re already comparing alternatives on cost grounds rather than features, our AI coding assistant comparison is the better starting point than any single vendor’s pricing page, because right now every vendor’s pricing page is telling a more optimistic story than its own users are.
