- GitHub Copilot abandons flat, request-based billing to move towards a pay-per-use model based on tokens and GitHub AI Credits.
- Individual Pro and Pro+ plans tighten usage limits, pause new sign-ups and student plans, and remove some Anthropic Opus models from cheaper tiers.
- Rising compute costs and heavier autonomous agent workflows are driving Microsoft to restrict free trials and ratchet up rate limits.
- Existing annual subscribers keep unlimited requests until renewal, after which all users are migrated to the new token-based system.
GitHub Copilot is heading into a new era. After several months of quiet adjustments, Microsoft is preparing to drop the flat, request-based pricing model and adopt billing by usage for its AI coding assistant. For developers who have grown used to unlimited prompts for a fixed fee, this marks a major shift in how they will plan and pay for their day-to-day tools.
Behind the scenes, internal documents and official posts point in the same direction: Copilot has become too expensive to run under the current structure. Longer agentic workflows, heavier language models and a growing user base are pushing infrastructure costs up so fast that keeping “all-you-can-eat” access simply no longer adds up.
The end of flat subscriptions: Copilot moves to usage-based billing
Until now, GitHub Copilot’s individual plans have revolved around a monthly fee tied to a fixed number of requests. Copilot Pro has been priced at 10 dollars per month with 300 monthly requests, while Copilot Pro+ has cost 39 dollars with 1,500 requests included. Each interaction with Copilot’s advanced features counted against those quotas, regardless of how many tokens were processed internally.
According to leaked documentation and Microsoft’s own hints, this request-based logic is going away in favor of a pay-per-token system. Instead of counting every chat or operation as a single request, usage will be calculated based on the number of tokens consumed, including input, output and cached tokens, in line with how modern AI APIs are usually billed.
In concrete terms, GitHub plans to introduce GitHub AI Credits as the currency for Copilot usage. The nominal prices of the plans will remain the same on paper — from 10 dollars for Copilot Pro up to 39 dollars for Enterprise tiers — but that monthly payment will effectively transform into a credit balance. Once those credits are spent, Copilot’s advanced capabilities will stop working unless users or organizations top up their balance.
Microsoft’s goal is to align Copilot much more closely with the underlying compute costs of the models it offers. Instead of treating all requests equally, the number of tokens and the specific model in use will determine how quickly credits are burned, creating a more direct link between heavy usage and higher bills.
At the same time, GitHub has confirmed that simple autocomplete and inline code suggestions will remain included in all plans without consuming AI Credits. The real spend will be triggered by the more intensive features: multi-step chat sessions, repository-wide code reviews and autonomous agents that iterate through projects over long periods of time.
Rising compute costs and why Microsoft is tightening the screws
One of the central reasons for the switch is economic: internal estimates suggest the weekly cost of running GitHub Copilot has nearly doubled since January. As more users lean on agentic workflows, start multiple parallel sessions, and rely on more capable — and therefore more expensive — models, the original pricing structure has started to look unsustainable.
Microsoft is far from alone in this. Most major AI providers such as OpenAI and Anthropic already bill by tokens, not by loose notions of “requests” or flat usage. GitHub Copilot, by comparison, was one of the last big players trying to hold onto a quasi-flat structure using request multipliers, which often meant that heavy users were effectively paying far less than the actual cost of their compute consumption.
The internal documents cited in reports say that a significant share of Copilot customers is regularly hitting existing usage caps. Long-running, parallel tasks consume far more resources than the original plans anticipated. If Microsoft does nothing, the logic goes, overall service reliability would deteriorate and the financial losses would keep piling up, especially in segments such as education where plans are subsidized or free.
For Microsoft, moving Copilot to a token-based system is less a matter of bold strategy and more a necessity to keep the product viable at scale. The combination of growing demand and increasingly powerful models appears to have pushed the service to a tipping point where flat pricing simply no longer covers the underlying infrastructure bill.
Stricter limits, paused sign-ups and changes in available models
Alongside the move to pay-per-use, Microsoft is rolling out a series of immediate restrictions affecting individual, business and enterprise plans. One of the most visible steps is a temporary pause in new paid sign-ups for GitHub Copilot Pro and Pro+, as well as for the Copilot Student plan included in the GitHub Education bundle.
Officially, GitHub frames this pause as a way to focus resources on existing customers and ensure service quality. In practice, it also limits the number of new users coming into plans that, under current economics, appear to be loss-making, particularly in the education sector. Until the new billing model is in place, Microsoft seems reluctant to onboard more users under pricing terms it regards as unsustainable.
At the same time, usage limits for individual plans are becoming much stricter. GitHub has already tightened rate limits once in early April and is preparing further adjustments in the coming weeks. These changes affect not only individual users but also some Business and Enterprise tiers, reducing the maximum number of intensive operations that can be performed over a given period.
In recent communications, GitHub has underlined the idea that Pro+ accounts will receive around five times more tokens than Pro accounts. The implicit message is simple: if the new limits are too restrictive on the cheaper tier, users are encouraged to upgrade. In the user interface, new usage indicators will appear in Visual Studio Code and Copilot CLI, surfacing how close people are to their weekly or session-based caps.
Beyond raw limits, the catalog of models available in each plan is being reshuffled as well. The Anthropic Claude Opus family will be removed from the 10-dollar Copilot Pro tier and restricted to more expensive options. Opus 4.6 Fast has already been withdrawn from Pro+ users, and Opus 4.6 and Opus 4.5 are scheduled for removal as part of a broader transition toward Opus 4.7.
Multipliers, model pricing and how credits are really consumed
Under the existing request-based system, GitHub has been relying on multipliers to reflect the cost differences between models. Each interaction is not just “one request” but “one request multiplied by a factor,” depending on how expensive the underlying model is. For example, GPT‑5.4 Mini has been listed with a 0.33x multiplier, while various versions of Claude Opus have ranged from 3x up to 30x in the case of Opus 4.6 Fast.
Opus 4.7, the latest in the lineup, has been operating under a promotional multiplier of 7.5x until the end of April. Even with that discount, internal calculations suggest that Opus 4.7 is around 250 % more expensive to use than its predecessor, making it significantly pricier in terms of compute. Once the promotion ends, its effective cost is expected to rise even more.
From Microsoft’s standpoint, this system of multipliers has reached its limits. When a single high-end model can count as dozens of requests in one go, it becomes very difficult to communicate pricing clearly to customers, and even harder to balance flat subscription income against wildly variable usage patterns.
The introduction of GitHub AI Credits and token-based billing is meant to simplify that picture. Instead of juggling abstract request multipliers, users will see their credits drain based on the exact token volume processed by the model they choose, at rates that mirror the provider’s own API pricing. Developers who stick to lighter, more efficient models will see their credits last longer, while those who rely heavily on premium models for big repositories will burn through their balance much faster.
Crucially, Microsoft appears to be considering an end to any plan that still behaves like an unlimited token buffet for a flat fee. Internal notes suggest that offerings which allow large token consumption without proportional revenue have “stopped being profitable” some time ago, which helps explain the sudden wave of stricter limits and model removals.
Free trials, refunds and how GitHub is responding to user backlash
The change in direction is already stirring frustration among developers, and GitHub seems to be anticipating some pushback. The company has suspended free trial plans for GitHub Copilot Pro, citing widespread abuse as the reason. While a free Copilot plan remains available, it no longer carries the same weight for heavy experimentation with premium features.
At the same time, Microsoft is offering a limited refund window for users who are unhappy with the new restrictions. Customers who disagree with the updated limits and removed capabilities can request a refund for what they paid for their subscriptions up until May 20, effectively giving them a short grace period to walk away if the changes break their workflows.
In their official messaging, GitHub attributes the toughening of limits to surging demand for compute resources, driven particularly by agentic workloads. As Copilot’s agents become more capable and handle bigger chunks of work autonomously, they naturally consume more tokens, which in turn increases the load on the underlying infrastructure.
GitHub executives point out that long, concurrent sessions are especially problematic. They often run for extended stretches of time, generate large volumes of tokens and can quickly eat through the budgets that were envisioned when the original plans were designed. If left unchecked, they argue, this would degrade the overall quality and reliability of the service for everyone.
To keep the system stable, GitHub is implementing session limits and weekly token caps. When a user hits their per-session maximum, they simply have to wait for a new usage window to reset before Copilot can be used again. Weekly limits, on the other hand, define the total number of tokens that can be consumed across all sessions in a given week.
According to GitHub, these weekly caps were introduced to rein in long-running, parallel jobs that rack up prohibitively high costs. By combining per-session and per-week ceilings, Microsoft hopes to smooth out usage spikes, prevent extreme outliers from overwhelming the system and make sure that all users get a predictable level of performance.
What changes for individuals, students and companies
For individual developers, the immediate impact is twofold. On the one hand, new sign-ups to Copilot Pro and Pro+ are temporarily off the table, and trials have been scaled back or suspended. On the other hand, those who already have an active subscription will keep their current terms — including unlimited requests — until their existing contract expires.
Once those subscriptions come up for renewal, though, all users will be migrated onto the new monthly, credit-based structure. That means paying the same sticker price but receiving a fixed allowance of GitHub AI Credits instead of a loosely defined volume of requests. When that allowance is spent, Copilot’s chat and agent features will pause until the next billing cycle or until extra credits are purchased.
For organizations, GitHub is introducing a shared “credit pool” concept. Instead of each employee’s credits living in complete isolation, unused tokens from some team members can be reallocated to colleagues who need more, a setup reminiscent of how some mobile carriers let subscribers share spare gigabytes of data across a family account.
The education segment is where the change looks particularly harsh. New subscriptions to GitHub Copilot Student are being put on hold, and GitHub Education’s free bundle is under pressure from the same cost realities as the rest of the product. Internal documents suggest that these plans are not profitable in their current form, pushing Microsoft to slow down intake while it revisits pricing and usage policies.
From a business perspective, the logic is blunt: either prices rise and are tied clearly to token consumption, or Microsoft cannot justify expanding access to segments that consistently run at a loss. For schools and students who have integrated Copilot heavily into their courses, this could mean fewer seats, stricter quotas or simply a steeper bill down the line.
Enterprise customers, meanwhile, face a mix of new constraints and advantages. They will see tighter rate limits on certain premium features, but also gain tools like detailed usage previews and billing estimates. GitHub plans to roll out a billing “preview” in May, giving companies a chance to simulate what their upcoming costs would look like under the token-based regime before it fully takes effect.
How developers might adapt to a pay-per-token Copilot
For many developers, the most practical question is straightforward: how much more will Copilot cost once every token counts? The answer will vary widely depending on coding habits, chosen models and how heavily they use chat, code reviews and agentic flows versus simple autocomplete.
Power users who have woven Copilot into nearly every part of their workflow — spinning up long-running agents, running repeated repository-wide analyses and keeping several parallel sessions open — are likely to see their usage translate directly into higher monthly bills. The flat-fee structure that once shielded them from the true cost of their compute will no longer be there.
Conversely, developers who stick to lighter models and shorter, more targeted interactions could end up staying relatively close to their current spending levels. Because the new system measures usage at token granularity, mindful workflows — such as keeping chats concise or avoiding unnecessary re-analysis of the same code — can meaningfully stretch a monthly credit allowance.
Over time, the shift may also change how teams think about which features they enable for whom. Organizations might reserve the most expensive models and capabilities for specialized roles, and rely on Visual Studio subscriptions — such as staff responsible for large-scale refactors or security reviews — while steering more casual users toward cheaper defaults that still offer solid productivity gains.
From a tooling perspective, GitHub’s promise to surface clear usage indicators directly in editors like VS Code could become essential. Seeing a live view of how many tokens are left in a weekly budget, or which types of operations are burning through credits the fastest, will help teams and individuals refine their habits before they run into hard limits.
All of this ultimately brings Copilot closer to the broader trend in cloud and AI services: pay for the compute you actually consume. For some, that means finally aligning costs with value. For others, it could feel like hitting a paywall around a tool that had quietly become indispensable to getting their job done.
With rising compute costs, stricter limits and a full pivot to token-based billing, GitHub Copilot is evolving from a flat-fee, largely unlimited assistant into a metered service where every intensive operation leaves a trace on the bill; how smoothly that transition goes will depend on whether developers and organizations can adapt their workflows quickly enough to keep Copilot useful without letting usage — and costs — spiral out of control.
