GitHub Copilot Business Billing Change: What's New

You add a new developer to a client project. You go to assign their GitHub Copilot Business seat — same as always. This time, GitHub wants payment before the seat activates, not after.

That's not a glitch. It's the GitHub Copilot business billing change GitHub confirmed in its own changelog on August 28, 2026. It lands for existing organizations on October 1. If you run an agency, freelance with a team, or manage seats for client work, here's what's different, what it costs, and what to check first.

There's a third default GitHub flipped the same week, and it has nothing to do with money at all. More on that below.

What actually changes on October 1

Three things, all confirmed in GitHub's own changelog:

• Upfront seat billing. New Copilot Business and Enterprise signups moved to prepay-per-seat on September 1, 2026. Existing organizations follow on October 1. Every assigned seat is charged at the start of the billing cycle, not after. Mid-cycle additions are still prorated. Revoking a seat early gets you no refund — you paid for the month, so you keep the seat for the month.

• Unified Copilot experience, no earlier than September 28. Copilot Chat on github.com, GitHub Mobile, and the cloud coding agent merge into one product with one policy. Chat data retention jumps from 28 days to the lifetime of the account. It's on by default, and opting out means losing Copilot access on the web and mobile entirely — not a partial rollback.

• Code review effort defaults to "Balanced," not "Lite." Also September 28. Balanced reviews read more of your diff and burn more tokens per pull request than Lite did. If your org runs Copilot code review on every PR, this alone can move your monthly number.

Pricing itself isn't changing. A Copilot Business seat is still $19/user/month, Enterprise still $39/user/month. What changed is when you pay and how predictable the rest of the bill is.

Inside the GitHub Copilot Business Billing Change: the credits underneath it

None of this happens in a vacuum. GitHub replaced its old premium-request-unit system with token-based AI Credits back on June 1, 2026. That's the part that actually swings your bill.

The mechanic is simple once you see it: one AI Credit equals one cent, flat. Your plan's price sets your monthly credit allowance. A $19 Business seat includes $19 in credits. A $39 Enterprise seat includes $39. Code completions and Next Edit suggestions stay unlimited — they never touch your credit balance. Everything else draws from that pool instead: chat, agent tasks, code review, all billed at the published rate for whichever model answered.

Here's where it gets uneven. GitHub's own pricing page lists these per-million-token rates (input / output):

A request routed to GPT-6 Astra's long-context tier costs roughly 40 times more per output token than one routed to GPT-5 mini. Same seat, same developer, wildly different bill — depending only on which model answered. One number in that table will cost your team money without anyone doing anything differently, and it's not the number at the top.

The math nobody checks before it's too late

Say your team's default model quietly sits on Claude Opus 5 instead of Sonnet 4.6. Someone picked it in the settings six months ago. Nobody's checked since. One PR review at 40,000 input tokens and 8,000 output tokens costs about $0.40 on Opus 5. The same review costs roughly $0.24 on Sonnet 4.6.

Run that gap across 30 PRs a week. That's an extra $24 a month per reviewer — on a plan that only includes $19 in credits to start. This is illustrative math, not a GitHub-published benchmark. But the shape of it is real: there's one setting that decides most of your bill, and almost nobody on your team has ever opened it.

Multiply that by a five-person team split across three client projects, and the seat price stops being the number that matters.

What to actually check before October 1

• Look up your org's default model in Copilot policy settings. If it's set to a top-tier model for every request type, that's your biggest lever.

• Assign someone to own the Copilot policy settings. Not "the team," one person. Budget overruns happen when nobody's watching the three defaults GitHub just changed.

• Decide on code review effort deliberately. Balanced is more thorough, but it's also more expensive per PR. If Lite was working, opt back into it rather than letting the new default choose for you.

• Check your renewal date if you're on a legacy annual plan. GitHub confirms existing annual Copilot Pro and Pro+ subscribers keep request-based billing through their current term — but they auto-downgrade to Copilot Free once it expires, with no request-based option to renew into.

• Budget for the seat-plus-usage total, not just the seat price, when you're quoting a client project that leans on Copilot for review or agent tasks.

Is this actually a bigger bill, or just a more honest one?

Mitch Ashley, VP at The Futurum Group, called it a deliberate strategy in comments to DevOps.com, not an accident: "Charging upfront for seats and metering tokens is how a vendor prices a product whose per-seat value is under pressure while its consumption climbs." His advice matches the checklist above: "assign an owner to those defaults now, before the invoice makes the decision for them."

To be fair to GitHub, nothing here is hidden. The per-seat price is public. The per-token rates are public. The effective dates went out over a month ahead of time. But a flat $19-a-month seat used to be the whole story. Now the seat is just the floor — the model your team routes requests to decides how much higher the bill climbs.

Where this fits if you bill clients for the work

If you're an agency quoting Copilot-assisted work into a client project, the tool cost is now its own line item. It moves independently of the seat count. And it keeps accruing whether or not that client pays on time — you've already paid the seat upfront, so a slow-paying client doesn't slow down your GitHub bill.

That's the same structural problem protecting deliverables across multiple clients is built around. Your costs run on a schedule the client's payment doesn't have to match. That's exactly why delivery shouldn't happen before the invoice is settled. It's also why a tool decision like whether Cursor is still safe to route client work through deserves the same scrutiny as a billing change: both are costs and risks you carry before you've been paid.

Set up payment-conditional delivery once, and every seat, credit, and token you spend on a client build stops being money you're floating for free.

FAQs

When does GitHub's new Copilot Business billing change take effect? New Copilot Business and Enterprise signups moved to upfront seat billing on September 1, 2026. Existing organizations follow on October 1, 2026.

Does GitHub Copilot Business actually get more expensive under the new billing? The per-seat list price is unchanged — $19/user/month for Business, $39/user/month for Enterprise. What changes is the timing (seats are paid upfront, not in arrears) and the exposure to usage-based overage charges under the AI Credits system introduced June 1, 2026.

What is a GitHub Copilot AI Credit worth? One AI Credit equals $0.01 USD. Each plan's monthly price sets its included credit allowance — a $19 seat includes $19 in credits per month.

What happens if my organization exceeds its included Copilot AI Credits? Additional usage is billed at the published per-model, per-token rate once the monthly credit allowance runs out. Rates vary significantly by model, from $0.25 per million input tokens on GPT-5 mini up to $20 on GPT-6 Astra's long-context tier.

Will a legacy annual GitHub Copilot Pro plan be affected? Existing annual Copilot Pro and Pro+ subscribers keep request-based billing through the end of their current term. When that term expires, GitHub auto-downgrades the account to Copilot Free rather than renewing into request-based billing.

Key takeaways

• Starting October 1, 2026, GitHub Copilot Business and Enterprise seats must be paid for upfront, not billed in arrears — new signups moved to this model on September 1.

• The seat price didn't change. The risk is usage overage under the token-based AI Credits system GitHub rolled out June 1, 2026, where 1 credit equals $0.01.

• Per-model rates vary as much as 40x between the cheapest and most expensive options, so which model your org defaults to matters more than the seat price.

• GitHub's default code review effort jumps from "Lite" to "Balanced" on September 28, 2026, which consumes more tokens per pull request unless an org opts back down.

• Budgeting Copilot into a client quote now means pricing the seat and the usage pattern, not just the per-seat number.

Tool costs run whether or not the client pays. DevAegis holds the client's build behind a kill switch until the invoice clears, so a slow payer stops costing you Copilot credits, hosting, and hours the moment you flip it. See how it works.