GitHub Copilot token billing calculator: project your June bill

What is actually changing on June 1

GitHub's current billing counts "Premium Requests" — a flat unit that varies by model but doesn't expose the underlying token math to the user. After June 1, that system disappears. In its place: AI Credits, where 1 credit costs $0.01 USD, and each model consumes a different number of credits per million tokens.

The plan prices do not change. Copilot Pro stays at $10/month. Business at $19. Enterprise at $39. What changes is how overages accumulate: instead of hitting a request cap and getting blocked, your token usage now runs a tab. If the tab exceeds your plan's included credits, you're charged for the overage at $0.01 per credit.

Each plan includes a matching credit allotment: Pro gets 1,000 credits ($10 of token value), Business gets 1,900, Enterprise gets 3,900. That math is intentional — the included credits equal the plan's dollar value, so a pure-token user breaks even. The question is whether your usage patterns push you past that threshold.

Code completions and Next-Edit Suggestions are not affected. They remain free on all paid plans. The metering applies only to chat interactions, inline edits that invoke a premium model, and agentic sessions. This is the distinction GitHub has been careful to preserve — the tab-completion feature that most people associate with Copilot doesn't change in cost.

The rates are published at docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing. They are per-million tokens, denominated in USD, and split between input (what you send) and output (what the model returns). Anthropic models also carry a cached-read rate and a cache-write rate — more on those below.

One thing the announcement doesn't emphasize: the per-million rates GitHub publishes equal the underlying providers' listed API rates as of April 28, 2026. You are not paying a markup on the tokens. You are paying for the IDE integration, the tab-completion, and the included credit allotment — and then raw API rates on top of that if you go over.

Per-model token pricing — full rate table

All rates are per million tokens, in USD, sourced from docs.github.com/.../models-and-pricing, effective June 1, 2026. The Cache Write column applies to Anthropic models only — for OpenAI, Google, and xAI, cache writes are billed at the standard input rate.

The output-to-input ratio varies by provider. Anthropic's Sonnet line is 5:1 (output costs 5x input). GPT-5 mini is 8:1. Grok Code Fast 1 is 7.5:1. For agentic work, which tends to generate long outputs, the output rate is the number that matters most.

The formula — how credits are calculated

GitHub's credit math is straightforward. Every workflow event (a chat turn, an agentic step, a code review) consumes some number of input tokens and output tokens. Anthropic models may also read from cache or write to it. Add up the costs, divide by the credit value, and you have your credit burn for that event.

credits = (
    input_tokens  × input_$/M
  + output_tokens × output_$/M
  + cached_tokens × cached_$/M
  + cache_write_tokens × cache_write_$/M   ← Anthropic only
) ÷ 1,000,000 ÷ $0.01

The division by 1,000,000 converts raw tokens to millions. The division by $0.01 converts the USD cost to credits. Everything else is multiplication by the model's published rate.

Worked example: Claude Sonnet 4 agentic session

A moderately complex agentic session on Claude Sonnet 4 — opening a codebase, writing a feature, running a review pass:

• 50,000 input tokens (files read, instructions, prior conversation)
• 20,000 output tokens (code written, explanations returned)
• 30,000 cached tokens (context re-used from cache)
• 10,000 cache-write tokens (new context written to cache)

That single agentic session costs 49.65 credits — roughly 5% of the 1,000 credits included in a Copilot Pro plan. Run that session 20 times in a month and you've consumed 993 credits, nearly the full allotment. The 21st session starts triggering overages.

Notice that output tokens dominate: $0.30 of the $0.4965 total, or 60%, comes from the 20k output tokens — even though input was 2.5x more tokens. This is the math that makes agentic work expensive relative to chat.

What workflows cost the most

Not all Copilot usage is equal under token billing. The difference between a $10 month and a $35 month is mostly workflow selection, not volume.

• Agentic sessions are the expensive class. A single Claude Sonnet 4 agentic session at moderate scale — 50k input, 20k output, 30k cached — costs 49.65 credits, as shown above. Run 22 of those in a month and you're at ~1,093 credits on that workflow alone. The killer isn't any single session; it's that developers running daily agentic work will easily hit 20–30 sessions per month.
• Code review on Sonnet is the silent accumulator. A single code review: 8,000 input (diff + context), 2,500 output (review comments), 4,000 cached (file history). That's roughly 14.6 credits per review. Eight reviews per month adds ~117 credits — not catastrophic, but it compounds with agentic usage.
• Chat on cheap models is nearly free. 150 chat sessions per month on GPT-5 mini — 800 input, 400 output each — runs approximately 15 credits total for the month. Less than 2% of the Pro allotment. If you're only using Copilot for conversation and tab completion, the June change is a non-event.
• Brainstorm sessions on Opus are short but expensive. A single Opus 4.7 brainstorm — 8k input, 4k output — costs 22 credits. Six of those in a month adds 132 credits. The per-session cost isn't ruinous, but it accelerates toward the limit faster than users expect because Opus is usually chosen for complex, long-output tasks.
• The multiplier effect. The patterns above are additive. A developer doing daily agentic sessions on Sonnet, weekly code reviews, and occasional Opus brainstorms will hit the Pro allotment before the end of month 1.

The practical takeaway: if your Copilot usage is predominantly tab completion and occasional chat, you're unlikely to see any bill change. If you've been running agentic sessions — especially multi-step, tool-using sessions with Sonnet or Opus — run the math before June 1.

Three usage profiles — projected June bills

These projections come from the Septim Meter CLI, built against the rates published at docs.github.com/.../models-and-pricing as of April 28, 2026. All profiles use the Copilot Pro plan ($10/mo, 1,000 credits included).

The angle nobody is talking about: Copilot vs. direct API

GitHub's per-million rates equal the underlying providers' listed API rates as of April 28, 2026. There is no markup on the tokens. This means the math for "should I just call Anthropic directly?" is unusually clean.

Take the heavy user profile: $21.78 in projected token costs inside Copilot. The token value consumed — 2,177.58 credits — represents $21.78 of API calls at published rates. Calling Anthropic and OpenAI directly would cost the same $21.78 in token charges, but there would be no $10 base plan on top.

Except there is no base plan on direct API. You pay exactly what you use. No credits included, no plan fee.

For the heavy user, the numbers are identical — because the $10 base plan is exactly offset by the 1,000 included credits. The formula is: if your token value exceeds $10, Copilot and direct API cost the same. If it's under $10, you're paying the $10 base for something you're not using fully, and direct API is cheaper.

But the comparison requires a caveat: Copilot Pro is not just token access. It includes:

• Tab completion and Next-Edit Suggestions — free, unlimited. For most developers, this is the feature that justifies the plan. The token-based chat and agentic work is additive.
• IDE integration. GitHub Copilot is embedded in VS Code, JetBrains, Neovim, and others. Replicating that against direct API requires additional tooling.
• GitHub Copilot Chat context. The IDE integration passes relevant file and repo context automatically. Direct API requires you to manage that context yourself.

For the light user — $0.15 in token value for the month — Copilot Pro costs $9.85 more than direct API calls alone. Whether that's worth it depends almost entirely on how much tab completion they use. If they're opening the IDE every day and accepting suggestions, the $10 fee is reasonable. If they're using Copilot only for occasional chat from the command line, direct API is significantly cheaper.

For the moderate user, the analysis is similar: $1.92 in token value, $10 base plan, $8.08 of the bill is paying for tab completion and IDE features. Still a reasonable trade for active developers.

The break-even point, where Copilot Pro and direct API cost exactly the same in token charges, is $10 of token value per month. Above that, both options cost the same — and Copilot gives you free completions on top. Below that, direct API is cheaper but loses the tab-completion feature.

See also: Anthropic API pricing 2026 — cost calculator and per-model breakdown and The Tokenocalypse — what a runaway agentic session actually costs.

What to do before June 1

• Check your current usage in the GitHub dashboard. Go to github.com/settings/copilot — it shows a breakdown of your Copilot interactions by type and model. Look for the session count and rough volume of agentic work. Organizations can review usage under Settings → Billing → GitHub Copilot.
• Estimate your June bill using the formula above. Multiply your typical session counts by the worked example numbers: 49.65 credits for a medium Sonnet agentic session, 14–22 credits for a code review, 1–2 credits for a cheap-model chat. Add them up and compare to your plan's included credits. Or wait for Septim Meter on May 12.
• If your projection exceeds comfort, choose a lever. The clearest one: switch your agentic model from Sonnet ($3.00/M input) to GPT-5 mini ($0.25/M input). For agentic work that is input-heavy — loading large files, passing long context — the input rate is the main driver. GPT-5 mini cuts agentic input cost by 12x. Quality trade-offs depend on the task; test it before committing.
• Reduce agentic session frequency if cost matters more than automation. The moderate profile (4 agentic sessions per month) stays well within the Pro allotment. The heavy profile (22 sessions) exceeds it. The line is somewhere around 20 Sonnet sessions per month on a Pro plan — depending on session size.
• Consider upgrading to Pro+ for heavy agentic users. Copilot Pro+ at $39/month includes 3,900 credits. The heavy profile at 2,177.58 credits would cost exactly $39 instead of $21.78 — worse than the Pro overage bill. For this specific profile, Pro is still better. But for heavier users — daily multi-hour agentic sessions — Pro+ may be cheaper than accumulating Pro overages.
• Set a spending limit in GitHub billing. Under Settings → Billing and plans → Spending limits, you can cap monthly Copilot spending. A $0 limit blocks access after included credits are exhausted. A $20 limit gives you a ceiling. This is the guard against surprises.
• If your bill has already spiked unexpectedly, contact GitHub support before June 1. The PRU system and AI Credit system have different billing mechanics; if you're seeing anomalous charges under the current system, resolve them before the June 1 transition resets the baseline.

Septim Meter — the calculator

We're shipping Septim Meter on May 12: $29, one-time, runs offline. You enter your session counts and token estimates; it projects your Copilot bill and runs the direct API comparison side-by-side, across all plans. The formula is the same one in this post — no account required, no data leaves your machine.

The CLI is already functional at the command line. The May 12 release adds the HTML report output and the interactive model-switching comparison. If you want early access or want to be notified when it ships:

FAQ