GitHub Copilot switches to usage-based billing — AI Credits system launching in June

GitHub has just announced a decision that will impact the wallets of millions of developers: starting June 1, Copilot will shift from a fixed monthly subscription to a usage-based billing model, introducing an AI Credits quota system. This is the biggest pricing model change since Copilot launched in 2021.

Simply put, going forward, the more code you generate with Copilot, the more credits you consume. The monthly fee stays the same, but once you exceed the free quota, every token will cost extra.

New billing model: monthly fee becomes a “base quota”

Here are the specific rules:

• Copilot Business ($19 per month): each month provides $30 worth of shared AI Credits
• Copilot Enterprise ($39 per month): each month provides $70 worth of shared AI Credits
• Usage beyond the quota will be billed by token consumption, with different prices depending on the model

That “shared” part is crucial. For team subscriptions, all members share one credit pool. If your team has ten people on Business, that means 10 × $30 = $300 in monthly credits—once used up, you’ll have to pay extra.

This is fundamentally different from the previous fixed monthly fee. Before, you paid $19 and could use Copilot endlessly—GitHub bore the cost risk. Now that risk shifts to users: the more you use, the more you pay.

Why change? Cost pressure and industry trends

GitHub’s official explanation is “to provide more flexible pricing,” but the real reason is simple: the costs have become unsustainable.

Copilot is powered by OpenAI models (mainly GPT‑4 and GPT‑3.5). Each code completion or chat interaction costs money. With a fixed monthly fee, heavy users may cost GitHub far more than $19 each month. Microsoft’s backing has covered that for a while, but now GitHub wants a healthier pricing model.

More importantly, the entire AI tool industry is shifting toward usage-based billing. OpenAI’s own API is billed per token, as is Anthropic’s Claude API, and even Chinese platforms like Tongyi Qianwen and Wenxin Yiyan are promoting pay‑as‑you‑go. Fixed‑rate subscriptions are proving unsustainable in the AI era because usage varies wildly—one user may generate a few lines of code per day, another thousands; the cost difference can be dozens of times.

From a business perspective, usage‑based billing has three advantages:

1. Cost control: users pay for what they use, GitHub no longer loses money on heavy users
2. Price differentiation: light users find it inexpensive (often under quota), while heavy users willingly pay more (since they use more)
3. Transparency: users can track consumption and plan budgets more easily

But for developers, this means higher uncertainty in usage costs. Before, you knew the maximum was $19 per month; now it could be $19, $50, or $100—depending on your habits.

Comparing competitors: how do Cursor and local tools charge?

GitHub’s adjustment closely follows Cursor’s example. Cursor has been usage‑based from the start:

• Free plan: 2,000 completions and 50 slow GPT‑4 requests per month
• Pro plan ($20 per month): unlimited completions, 500 fast GPT‑4 requests, with throttling or per‑use billing for overages

Cursor’s approach is more aggressive—counting “requests” directly as billing units, giving users clear visibility of remaining quota. GitHub’s AI Credits system is milder, retaining a “monthly fee + free quota” buffer.

Chinese AI coding tools are catching up too. Tongyi Lingma, Wenxin QuickCode, and Doubao MarsCode all offer usage‑based options, generally with free credits to attract users. For example, Tongyi Lingma gives new users 500,000 free tokens, then charges ¥0.0001 per token thereafter.

Interestingly, domestic tools are generally cheaper than GitHub’s. For GPT‑4‑level models:

• GitHub Copilot (estimated): ≈ $0.03–$0.06 per 1,000 tokens (based on OpenAI API pricing)
• Tongyi Lingma: ≈ $0.012 per 1,000 tokens (¥0.0001 per token)
• Doubao MarsCode: some features free; paid pricing undisclosed but reportedly lower

The price gap mainly comes from two factors: local models have lower costs (using in‑house architecture), and fierce market competition drives prices down.

What should developers do? Three coping strategies

If you’re a heavy Copilot user, this change could double your costs. Three ways to adapt:

1. Monitor usage and optimize habits

GitHub will provide a usage dashboard showing AI Credits consumption. Check it weekly to understand your patterns:

• Which actions consume the most credits? (Chat usually costs more than code completion)
• What times see the most usage? (Consider reducing non‑critical usage during those periods)
• Who in the team uses it most? (Provide training to avoid waste)

Some developers may start thinking before asking Copilot—instead of generating code reflexively. That’s a big mindset shift from “fixed fee, use as much as you want.”

2. Evaluate downgrades or tool changes

If you’re a light user (rarely exceed $30 quota), this change won’t affect you—maybe even saves money since you’re not covering others’ heavy usage.

For heavy users, consider:

• Downgrading to personal plan: if your company uses Enterprise but you personally use little, request a Business plan
• Switching to domestic tools: Tongyi Lingma, Cursor, Codeium, etc. offer free or cheaper options
• Hybrid use: rely on free tools daily, and use Copilot for key moments

3. Manage credits at the team level

For enterprise users, the main challenge is how to allocate AI Credits across the team.

A 10‑person team on Business gets $300 credits monthly. If split evenly, $30 each—but in practice, 2–3 people might spend $200, others $100. To handle this:

• Set individual quotas: assign fixed credits per developer, require approval for overages
• Prioritize usage: allow more credits for critical projects and fewer for minor tasks
• Review regularly: analyze monthly consumption and adjust allocation

Some firms may adopt an “AI Credits budget” like cloud budgets: each project has its quota, and once used up—either request more or wait for next month.

Is usage‑based billing the endgame for AI tools?

GitHub’s move reveals a broader trend: AI tools are evolving from “Software‑as‑a‑Service” (SaaS) to “AI‑as‑a‑Service” (AIaaS).

In traditional SaaS, development costs are fixed and marginal costs near zero—so monthly pricing works. AI tools differ: each call incurs real compute costs, so marginal costs are non‑zero. This makes fixed monthly fees hard to sustain in the AI era.

Usage‑based billing fits AI’s cost structure but raises new issues:

• Worse user experience: developers constantly worry “how much will this request cost?” hurting workflow
• Budgeting difficulty: companies struggle to predict monthly AI expenses—finance teams won’t like that
• Matthew effect: large firms can afford high quotas; small teams may be priced out, widening the tech gap

A hybrid model may emerge—basic features at flat monthly rates, premium features billed by usage. Or, like cloud services, “reserved instances”: buy annual credits at a discount but non‑refundable if unused.

Another possibility is local deployment. If usage billing gets too expensive, some companies may self‑host open‑source models (e.g., DeepSeek Coder, CodeLlama)—a one‑time hardware investment for long‑term free use. That’s a threat to GitHub: if prices soar, users will vote with their feet.

Final thoughts

GitHub Copilot’s change essentially passes true AI costs on to users. Microsoft and GitHub used to subsidize developers for cheap AI‑assisted coding; now that market education is done, they’re moving toward commercial rationality.

For developers, this isn’t necessarily bad. Usage‑based billing makes pricing more transparent—you know how much you used and spent. Meanwhile, competition will drive prices down, with domestic and open‑source options eyeing the market.

But beware: don’t let cost anxiety hurt your productivity. AI coding tools exist to boost efficiency; if you avoid them just to save money, you lose out. The key is finding your own rhythm—use when valuable, hold back when not.

Once the new billing starts June 1, observe your usage for a month before deciding whether to stay, downgrade, or switch tools. After all, tools serve people—not the other way around.

---

References

• GitHub Official Blog: Copilot moves to usage‑based billing – Official announcement detailing the new billing model and AI Credits system
• Zhihu Discussion: OpenCode pitfalls – Developer experiences analyzing potential cost issues under usage‑based billing