Copilot Premium Requests: The Dec 2 Billing Reset

GitHub’s move to Copilot premium requests went from pilot to policy in 2025. And on December 2, 2025, a quiet but critical change landed: legacy $0 budgets for enterprise and team accounts created before August 22, 2025 were removed, shifting control to your “premium request paid usage” policy. If you haven’t reviewed your settings, your organization could already be paying per-request overages—or unintentionally blocking developers at the worst moments.

What changed on December 2—and why it matters

Until December 2, many enterprise and team tenants created before August 22, 2025 had a default $0 Copilot premium request budget. That hard stop protected you from overage charges but sometimes surprised developers when features simply stopped working after the monthly allowance. GitHub removed those legacy $0 budgets on December 2 and now relies on a policy switch: Enabled (allow paid usage) or Disabled (block at allowance). Practically, this turns spending from a static dollar cap into a governance setting that you must intentionally configure.

Two more details shape the new reality:

• Dedicated SKUs: Since November 2025, premium requests for Spark and the coding agent are tracked on their own SKUs, improving cost visibility by product. That’s a win for FP&A and chargebacks.
• Monthly reset: Premium request counters reset at 00:00:00 UTC on the first of each month. Unused amounts don’t roll over.

What are Copilot premium requests?

Think of a premium request as a metered unit for capabilities that use higher-cost models or features—Copilot Chat with certain models, agent mode, code review, the coding agent working a task, even the Copilot CLI. The exact usage per interaction can vary by feature and by the model’s multiplier. Included models on paid plans (such as GPT‑4.1 and GPT‑4o) don’t consume premium requests; premium models do.

Plan allowances today look like this for individuals:

• Free: 50 premium requests/month (limited features/models)
• Pro: 300 premium requests/month
• Pro+: 1,500 premium requests/month

Additional premium requests are currently priced at about $0.04 per request for individuals. Organizations and enterprises control overages via policy (allow or block) and budgets at the enterprise, org, or cost center levels.

How much do Copilot premium requests cost—and when?

There are two money moments: first, your included monthly allotment (by plan and seat); second, any overage beyond that allowance. If your policy is set to allow paid usage and you have an active payment method, overages bill automatically at the prevailing rate associated with the premium request SKU. If the policy is disabled, usage stops when the allowance is exhausted. There’s no carryover between months, and counters reset on the first of each month.

Also remember model multipliers. Some examples used in 2025 billing guidance:

• Claude Opus 4.1 can count as 10× a premium request in some contexts.
• Claude Sonnet 4/4.5, Gemini 2.5 Pro, GPT‑5, and GPT‑5‑Codex often count as 1× on paid plans.
• Grok Code Fast 1 shows as 0.25× on paid plans in some docs.
• Included models on paid plans—GPT‑4.1 and GPT‑4o, plus GPT‑5 mini—count as 0× (no premium request consumed).

What’s the takeaway? A single “ask” to an expensive model in chat or agent mode can burn through multiple requests. If your teams default to high‑end models, your allowance will vanish faster than expected.

Who’s most at risk of surprise spend?

Three patterns show up again and again in audits we run for clients:

• Teams using agent mode for long tasks. The coding agent spinning up workspaces and iterating on PRs can consume premium requests steadily. It’s productive—but not free.
• Mixed plans in the same org. Pro, Pro+, Business, and Enterprise seats behave differently in usage ceilings and model access. Without seat policy hygiene, power users silently drive overages on the wrong cost center.
• Model roulette. Developers switching among models “to see what’s better” without a policy-based default burn multipliers unintentionally.

30-minute “no-surprises” setup (do this today)

You don’t need a two-week project to get control. Use this quick checklist:

1. Open Copilot policy settings and decide at the enterprise level: allow or block paid premium request usage. If your org isn’t budget-ready, set it to Disabled now and revisit monthly.
2. Create a bundled premium request budget at the enterprise or org level. Start with a conservative cap (e.g., $500 or an amount equal to 5–10% of your monthly seat spend). Turn on “stop usage when budget is reached.”
3. Map budgets to cost centers for high-signal teams (platform, core product, data science). If your finance model needs it, create individual SKU budgets for coding agent and Spark so you can attribute costs accurately.
4. Set alerts at 75%, 90%, and 100% of budget. Route alerts to a shared Slack/Teams channel with the platform team and an engineering manager.
5. Enable an “included models first” default in developer guidance for chat: GPT‑4.1/4o or GPT‑5 mini on paid plans. Reserve multipliers for named cases (long refactors, security audits).
6. Download the usage report from billing settings and spot the top 10 users by premium request volume. Brief them on the model policy and why it matters.

If you want a deeper walkthrough with screenshots and scripts, we published a practical playbook here: 30‑Day plan to roll out premium request controls.

The R‑A‑T‑E framework for ongoing control

Here’s a lightweight operating model that’s worked across multiple clients:

• R — Restrict high‑multiplier models behind feature flags or org-level policies. Make the “expensive” choice explicit.
• A — Allocate premium request budgets to cost centers that truly benefit from agents (e.g., platform migrations, security hardening).
• T — Track top users, model mix, and SKU usage weekly. Pin a short dashboard in the engineering leaders’ channel.
• E — Educate with short Looms or brown bags: when to use agent mode vs. chat, which prompts trigger multipliers, and how to fall back to included models.

We’ve packaged a similar approach for cloud spending under multicloud network changes—if you’re dealing with AWS connectivity shifts, this primer helps: what architects should do now for interconnect.

People also ask: does chat count, and which models are “free”?

Do chat, code review, and the CLI count as premium requests?

Yes—depending on the model. Chat, code review, agent mode, the coding agent, and the Copilot CLI can use premium requests. If you’re on a paid plan and stick to included models (GPT‑4.1, GPT‑4o, GPT‑5 mini), your usage may not draw down the premium request meter. Switch to a premium model, and it will.

Are GPT‑4.1 and GPT‑4o really unlimited on paid plans?

On paid plans, they’re included for chat and agent interactions, subject to rate limits. That means you won’t consume premium requests using those models, but you can still hit throughput constraints during heavy usage.

What exactly is a model multiplier?

It’s a factor applied to a single interaction. If a model carries a 10× multiplier and you run it once, you’ll consume 10 premium requests. If you’ve got a 0.25× model (like Grok Code Fast 1 on some guidance), four interactions equal one premium request. This is why setting a default model matters.

Data you can act on: allowances, prices, and dates

Here are the practical numbers and timelines your budget owners need:

• Allowances: Free = 50; Pro = 300; Pro+ = 1,500 premium requests/month.
• Per-request price (individuals): about $0.04 beyond the included allowance.
• Enforcement start: Premium request allowances across paid plans began enforcing on June 18, 2025 (monthly resets on the 1st).
• Dedicated SKUs: Spark and coding agent tracked on separate SKUs starting November 2025.
• $0 budget removal: December 2, 2025 for enterprise and team accounts created before August 22, 2025.

If these dates look familiar, that’s because we’ve been covering this transition in real time. For a timeline with remediation steps and admin scripts, see our note on the Dec 2 changed billing and the companion admin fix.

For CFOs and procurement: a simple forecast formula

You can estimate monthly Copilot premium request costs with a back‑of‑the‑envelope model. It won’t be perfect—but it’s good enough for approval cycles.

Monthly Overage Cost ≈ Σ over teams [ max(0, (Avg Premium Requests per Dev × Devs) − (Included Requests per Seat × Seats)) × (Request Price × Avg Multiplier) ]

Worked example: Suppose 60 developers on Business-equivalent usage patterns average 150 premium‑eligible interactions/month, mostly 1× models, but 20% of their interactions are at 0.33× and 10% at 10×. Effective multiplier ≈ 1××70% + 0.33××20% + 10××10% = 1.0×0.7 + 0.066 + 1.0 = 1.766. If each seat includes 300 requests and you’re at 150 average interactions, you’re probably inside allowance. But shift to 250 average interactions and bump premium model share, and you’ll pierce the allowance quickly. That’s the whole point of setting a budget and alerts.

Risks and edge cases most teams miss

There are a few gotchas you should plan for:

• Multiple billing entities. If a user belongs to multiple orgs/enterprises, they must choose the “Usage billed to” entity. If they forget, usage might fall on the wrong ledger—or block unexpectedly.
• Mobile subscriptions. If an individual paid via the iOS/Android app, additional premium requests and some budget controls may not be available. Standardize purchases through your primary billing account.
• Rate limits ≠ cost limits. Hitting rate limits on included models doesn’t protect you from costs if devs hop to a premium model to “get it through.” Budgets and policies still matter.
• Agent autonomy. The coding agent can produce long sessions that feel like a single task but meter multiple premium requests under the hood. Treat it like a managed workload, not a novelty.
• SKU drift. With dedicated SKUs for Spark and the coding agent, make sure your cost centers and dashboards reflect the new lines. Otherwise you’ll lose visibility just when finance starts asking questions.

Let’s get practical: model policy that won’t annoy engineers

Here’s a policy template we’ve rolled out successfully:

• Default chat model: GPT‑4.1 (included on paid plans). Agents and reviews use the same default.
• Allow high‑multiplier models only for specific squads (platform, SRE, security). Implement via IDE policy or documented conventions.
• Require a short PR comment when switching to a premium model on agent tasks: “Why this model?” Keep it human—just enough to add friction for thought, not bureaucracy.
• Budget caps by cost center: start small and adjust with monthly usage reports.

If you want deeper governance patterns across AI tools, our piece on avoiding surprise bills lays out controls that work even in regulated environments: stop surprise bills with Copilot.

What to do next (1‑week plan)

Here’s a focused track you can run immediately:

• Day 1: Set your enterprise policy to Enabled or Disabled based on your risk tolerance. Create a bundled budget with stop‑at‑cap.
• Day 2: Publish your model policy (included models by default; premium only on request). Pin it in the engineering handbook.
• Day 3: Configure alerts to a shared channel. Add a weekly usage snapshot to the staff meeting agenda.
• Day 4: Map coding agent and Spark to cost centers. Validate that your dashboard shows both SKUs.
• Day 5: Brief top 10 users by usage. Offer them a “power user” lane with higher budgets in exchange for sharing best practices.

Need a structured rollout? Use our hands‑on 30‑day plan and the quick budget guide: control your spend now.

Why this model is here to stay

Zooming out, GitHub’s direction is clear: seat licenses grant base access; premium requests meter high‑cost features and models; SKUs separate products for visibility. That aligns with how cloud services, observability tools, and API platforms monetize workload intensity. Expect more AI products to land on their own SKUs, and expect the premium request catalog to evolve with model performance and cost curves.

Here’s the thing: none of this is bad for developers or finance if you set guardrails. In fact, organizations with sane defaults and clear budgets get the benefits of agents and advanced models without the bill shock. The cost only bites when governance is sloppy.

Bottom line

If you remember one thing from the December 2 update, make it this: policies, not default $0 budgets, now control your exposure. Decide whether you allow paid usage, cap it with budgets and alerts, and make included models the default. Do those three things and your engineers keep shipping—without your controller calling at 11 p.m.