GitHub Copilot Usage Billing: What API Teams Should Expect

GitHub Copilot’s billing model changed twice in the last year and it changed again this month. As of this month, Copilot code review on pull requests starts consuming GitHub Actions minutes from the billing account that owns the repo. Combined with the premium-request quota that landed last quarter, API teams now juggle three meters at once: Copilot seats, premium requests, and Actions minutes. This guide explains what each meter measures, how the new code-review billing affects API repos in particular, and how to model the costs before they show up on an invoice.

We pair it at the end with a workflow inside Apidog so the API specification, contract tests, and AI review steps live in one place rather than scattered across three billing dashboards.

If you are also costing model APIs that your team consumes directly, the deeper guides on GPT-5.5 pricing and DeepSeek V4 pricing cover the per-token side of the same conversation.

TL;DR

• Copilot has three meters: per-seat license, premium requests (model-dependent), and now Actions minutes for Copilot code review.
• Code review on PRs runs as a GitHub Action under the hood. Each review burns Actions minutes against the org’s normal Actions allowance.
• API repos are heavier consumers than average because PRs are larger (spec + generated clients + handler + tests) and reviews fire across multiple agents.
• Premium requests cap “agentic” work (Workspace, agent mode, Copilot Spaces). Standard chat and code completions are still unmetered for paid tiers.
• Set spending limits before the next billing cycle. Budget around 400 to 800 Actions minutes per month per active API repo and revisit after 30 days.

The three meters and what they actually measure

Copilot used to be one bill. It is now three.

Meter 1: per-seat license

The flat fee. $10 per user per month for Copilot Business, $19 per user per month for Copilot Enterprise. This pays for chat, inline completions, multi-line suggestions, the IDE integrations, and access to the standard model pool. Seats are the easiest line item to forecast and the most likely to be over-provisioned. Audit it once a quarter and reclaim seats from inactive users.

Meter 2: premium requests

Premium requests are GitHub’s currency for the more expensive features. Anything that runs in agent mode, Workspace, Copilot Spaces, or model selection beyond the default counts as one or more premium requests depending on the model.

The current rates (subject to revision):

Each Copilot Business seat ships with 300 included premium requests per month. Copilot Enterprise ships with 1,000. Overages bill at $0.04 per request, capped by the spending limit you set on the org.

For an API team, the requests that move the meter are agent-mode tasks like “regenerate the OpenAPI client” or “write a contract test for this new endpoint”. Those tend to multi-step internally, so a single user prompt can resolve to four or five premium requests.

Meter 3: Actions minutes (new for code review)

This is the change that surprised teams this month. When Copilot performs an automated code review on a pull request, the review runs as a GitHub Action under the same Actions infrastructure your CI uses. The minutes the review consumes are debited from the org’s normal Actions allowance.

Two things to know:

• The minutes ARE included in your existing GitHub Plans Actions quota (3,000 min/month on Team, 50,000 on Enterprise for Linux runners). They are NOT a separate quota.
• Reviews on private repos cost more than public repos because Actions on private repos is metered against your minute budget, while public-repo Actions are free.

A typical Copilot code review on an API pull request consumes 2 to 6 Actions minutes. A heavy review (large diff, multiple files, full repo context) can hit 15. Multiply by the number of PRs your team merges and you have a meaningful line item.

Why API repos hit these meters harder

Three properties of API repos amplify the cost:

1. Pull requests are larger. A typical API change touches the spec (openapi.yaml), the generated clients in two or three languages, the server handler, and the contract tests. Copilot review reads all of them, runs longer, and burns more minutes than a one-file frontend tweak.
2. Generated code skews token counts. Even when generated clients are gitignored, many teams commit them. The review reads them all and pays for the privilege.
3. Multiple review agents fire per PR. Teams that run Copilot review alongside CodeQL, Snyk, and a custom security scanner pay for each of them separately. Copilot is the new arrival; the others were already metered.

The practical impact: an API team merging 50 PRs a month at 4 minutes per review burns 200 Actions minutes a month on Copilot review alone. That is 7 percent of a Team-tier monthly quota for a single repo. Three repos and you are at 21 percent before any CI run.

How to estimate your monthly bill

The number that catches people off guard is total cost, not any single meter. Build the estimate in three steps.

Step 1: seats

Count active Copilot users and multiply by the seat price.

seats = active_users × $10  (Business)
      = active_users × $19  (Enterprise)

Step 2: premium requests

Estimate per developer per month. A heavy Workspace user lands around 600 to 800 requests; a chat-only user lands closer to 150. With the included quota at 300 (Business), expect overage to start at the heavy-user side.

premium_overage = max(0, requests_used - 300_per_seat) × $0.04

Set a spending limit at the org level so a runaway agent loop does not blow past your budget. The default is unlimited, which is the wrong default for any team that is not actively monitoring.

Step 3: Actions minutes for code review

Multiply PRs merged per month by minutes per review. The 4-minute average is reasonable for medium-sized API PRs.

review_minutes = prs_per_month × 4
review_overage = max(0, review_minutes - actions_quota_remaining)
                 × $0.008  (Linux private repos)

Stack the three. For a 10-developer team merging 200 PRs a month, the rough numbers come out around:

• Seats: $190 (Enterprise)
• Premium overage: $40 (modest agent usage)
• Review minutes: 800/month, well within Enterprise quota, $0
• Total: ~$230 above the seat baseline

Smaller teams on Business tier hit overage faster because the quotas are tighter. A 5-developer Business team merging the same 200 PRs would burn through Actions quota and start paying $6 per 1,000 review minutes.

What changes in your CI pipeline

Three concrete pipeline changes pay back the cost overnight.

1. Skip Copilot review on bots and dependabot PRs. Most teams do not need AI review on a Renovate bump. Add a path or actor filter to the workflow trigger.

on:
  pull_request:
    types: [opened, synchronize]
jobs:
  copilot-review:
    if: github.actor != 'dependabot[bot]' && github.actor != 'renovate[bot]'
    runs-on: ubuntu-latest
    steps:
      - uses: github/copilot-review@v1

2. Cache generated client diffs. If your repo regenerates clients on every PR, the review reads the diff every time. Stash the generated output behind a computed hash and skip the review job when the hash matches the base branch.

3. Run Copilot review on a smaller path filter for API repos. Restrict the review to handler, spec, and test files. Skip the generated clients entirely. The review quality stays high; the minutes drop by half.

on:
  pull_request:
    paths:
      - 'apis/**/*.yaml'
      - 'cmd/**'
      - 'internal/**'
      - 'tests/**'

Governance: the four controls every API team should set

These take 20 minutes and prevent most surprise invoices.

1. Spending limit. Set it at the org level, not the repo level. Default is unlimited; pick a number you would not flinch at and round down by 20 percent.
2. Premium request alerts. GitHub sends emails at 50, 75, and 90 percent of the included quota. Wire those into Slack or your incident tool so they are not lost in inboxes.
3. Repository policy on review triggers. Decide whether Copilot review fires on every PR or only on PRs labeled review-please. The label-driven model cuts costs by roughly 60 percent without losing the reviews that catch real issues.
4. Per-team rollout. Enable Copilot Enterprise features per team rather than org-wide. New features ship as opt-in; you do not have to absorb the cost of every release the moment it lands.

Where Apidog fits

Apidog is not a Copilot replacement; it is the layer that keeps your contract testing inside one tool instead of three. The pattern that keeps both costs and quality predictable:

• Spec and saved request examples live in the Apidog collection committed alongside the repo.
• Contract tests run against the Apidog mock server, not the live API. Mock runs are free and fast.
• Copilot review focuses on handler logic and test coverage, not on whether the spec example is up to date.
• The CI workflow runs apidog-cli for contract validation in 30 seconds and only triggers Copilot review if validation passes.

That sequencing matters because Copilot review is the most expensive step in the pipeline. Failing fast on a contract issue saves the review minutes for code that actually deserves them. The API testing without Postman guide covers the underlying Apidog mock workflow; the DeepSeek V4 API guide shows the pattern applied to a model API.

What to expect in the next billing cycle

Three things to put on a calendar:

• Day 1 to 7: Premium request usage looks normal. Most teams stay under the 300/seat included quota in week one.
• Day 14 to 21: Heavy users cross the included quota. If you set a spending limit, requests start failing for those users. Without a limit, the bill grows.
• Day 28 to 30: Actions minute usage from Copilot review compounds. This is where teams notice the new line item. Compare against the previous month’s bill side by side.

Audit at the end of the month. Move heavy users to Enterprise tier (1,000 included requests), trim the seats of inactive users, and tighten the path filter on the review workflow.

Common mistakes

After auditing a dozen API teams in the past month, the same five issues come up:

1. No spending limit. A single agent loop can run for hours. Always cap.
2. Review enabled on every repo. Pick the repos where review actually pays back. Disable elsewhere.
3. Generated clients reviewed. Path-filter them out.
4. Bot PRs reviewed. Filter dependabot, renovate, and any in-house auto-bumpers.
5. No baseline metrics. Without a “before” snapshot, you cannot tell if a change to the workflow saved money. GitHub’s billing UI ships a CSV export; pull it monthly.

FAQ

Is the seat price still $10 per user?Copilot Business is $10 per user per month, Copilot Enterprise is $19 per user per month, and Copilot Pro for individuals is $10 per month. The seat tier sets the included premium-request quota.

Are inline completions metered now?No. The default model for chat and inline completions is unmetered for paid tiers. Premium requests cover the more expensive features and model selection.

What happens when my premium quota runs out?By default, requests start to fail with a quota error. You can set a spending limit to allow overage at $0.04 per request up to the limit.

Are the new Actions minutes for code review billed separately?No. They consume the same Actions minute pool as the rest of your CI. Track total Actions usage and adjust workflow triggers to keep the budget in line.

Can I disable Copilot code review entirely?Yes. The org admin can opt repos out at the policy level. The same setting controls per-team enrollment.

Will Copilot review work on private API specs?Yes. Private repos consume Actions minutes; public repos are free. The reviewer reads the spec and handler files like any other source.

Does Copilot review use premium requests too?Currently it consumes Actions minutes only. The model the reviewer uses is part of the Copilot platform and is not separately billed as a premium request. This is the part most likely to change in the next quarter; watch the GitHub changelog.

For teams running both Copilot review and direct model API calls in CI, the GPT-5.5 free Codex guide covers the per-token side and Apidog wraps the mock and contract layer so the AI review only runs on PRs that pass the cheap checks first.