What Does This Amount of Tokens Translate Into Cash in the New GitHub Pricing Model Tokens ↑ 3.9m 3.5m Cached • ↓ 37.5k 4.1k Reasoning: $2.70–$19.90 Per Session Depending on Model Tier

In the new GitHub Copilot usage-based billing model, that token count — 3.9 million input tokens, 3.5 million of them cached, 37,500 output tokens of which 4,100 are reasoning tokens — translates into roughly $2.70 to $19.90 in GitHub AI Credits for a single interaction, because 1 AI credit equals $0.01 USD. The exact figure depends entirely on which model handled the request, since GitHub charges per million tokens at each model's published API rate. Cached input costs a fraction of fresh input on most frontier models, and reasoning tokens bill at the output rate.

The token breakdown in that figure follows GitHub's own four-part definition. Input tokens are everything sent to the model — your prompt, file context, conversation history. Cached tokens are input tokens the model reused from an earlier request because they had already been processed. Output tokens are what the model generates. Reasoning tokens are a subset of output: the internal thinking a reasoning model produces before it writes the visible answer, billed at the output rate.

A rough mid-range example: on a model priced at $1.25 per million input tokens, $0.125 per million cached tokens, and $10 per million output tokens — a rate card in the range GitHub publishes for frontier tiers — the math runs $0.49 for fresh input (400,000 tokens at $1.25/M), $0.44 for cached input (3.5M at $0.125/M), and $0.375 for output (37,500 at $10/M). That lands near $1.30, before the reasoning tokens are separated out. Bump the output rate to $60 per million, the pattern for the most expensive reasoning models, and the same session crosses $5.

That range is wide on purpose. The token count alone doesn't set the price; the model does. Token prices for GitHub Copilot models are published on GitHub's "Models and pricing for GitHub Copilot" documentation page and change whenever GitHub adds or reprices a model. The June 1, 2026 transition from premium request units to AI Credits is the event that made this math necessary in the first place — before that date, premium request counts obscured per-token cost entirely.

Read the table right and one thing jumps out: nearly 90% of the input is cached. That single fact drives the entire cost outcome, and it's why a session that looks enormous at 3.9M tokens can still bill like a small one.

Why 3.9 Million Input Tokens Aren't the Expensive Part

Cached tokens are the discount mechanism in the new pricing model, and they are the reason this session doesn't cost $20 by default. GitHub's documentation states that repeated input tokens "can often be reused through the use of cached tokens" because they have already been processed as part of an earlier request. On most frontier models the cached rate sits at roughly a tenth of the fresh input rate. Anthropic's published API pricing, for instance, charges $0.30 per million cached input tokens against $3 per million fresh input for Claude Sonnet — a 10:1 ratio that GitHub's Copilot rate card broadly mirrors.

Run the numbers on the cache share alone. If all 3.9M input tokens billed at fresh-input rates of $3 per million, the input line would cost $11.70 before a single output token was generated. With 3.5M of those tokens cached at $0.30 per million, the input line falls to $1.17 for cached plus $1.20 for the 400,000 fresh tokens — $2.37 total. The cache saving is $9.33 on that one interaction. Scale it to twenty such sessions in a workday and the difference between cached and uncached billing is the difference between a $36 monthly allowance lasting two days and lasting two weeks.

What creates caching in practice? Long agent sessions. When Copilot's cloud agent reads a repository, loads files, and iterates across multiple turns, the earlier context gets cached so the model doesn't reprocess it from scratch on every follow-up. A three-file editing session that runs twenty turns will rack up millions of cached input tokens almost by accident. The 3.5M cached figure in this token count is the signature of exactly that pattern — an agent that has been holding a large codebase in context across many steps.

One version-specific detail matters here. GitHub's pricing page notes that GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna, GPT-6 Astra, GPT-6 Luna, GPT-6 Sol, GPT-6.1 Sol, and GPT-6.1 Terra include a cache write cost in addition to cached input — earlier OpenAI models do not. If your session ran on one of those models, add a separate line for the initial cache write, priced per the model's table. That line is frequently omitted from third-party cost calculators, and it can add a few percent to any cached-heavy session.

Converting Each Token Bucket Into Credits and Dollars

The conversion rule is fixed: GitHub totals the token cost at each model's published rate, then converts the dollar total into AI Credits at 1 credit = $0.01 USD. There's no markup on the conversion itself. The markup, if any, lives in the per-token rates, which GitHub sets per model and revises as model economics evolve.

Here's the arithmetic laid out plainly for a mid-tier model at $2.50 per million fresh input, $0.25 per million cached input, and $15 per million output. Fresh input: 400,000 tokens ÷ 1,000,000 × $2.50 = $1.00. Cached input: 3,500,000 ÷ 1,000,000 × $0.25 = $0.875. Output: 37,500 ÷ 1,000,000 × $15 = $0.5625. Total: $2.44, or 244 AI Credits. The reasoning tokens, being a subset of the 37,500 output tokens, add nothing extra — they're already inside that line.

Now the same session on a premium reasoning model at $5 per million input, $0.50 per million cached, and $40 per million output. Fresh input: $2.00. Cached input: $1.75. Output: $1.50. Total: $5.25, or 525 credits. That's more than double the mid-tier figure for identical token counts. The lesson isn't that the tokens changed; it's that the model choice multiplies everything.

Swap in budget-tier rates — say $0.15 per million input, $0.015 per million cached, and $0.60 per million output — and the same session costs $0.084, under nine cents. A single session spans a 60-fold cost range depending on which model handled it. GitHub's own documentation uses the same illustration: "a quick question in Copilot Chat using a lightweight model might cost a fraction of an AI credit," while "a long Copilot cloud agent session using a frontier model across multiple files will cost more AI credits."

Rates shown are illustrative tiers in the pattern of GitHub's published structure; confirm exact per-model numbers on GitHub's "Models and pricing for GitHub Copilot" page before budgeting. The ratio between tiers holds regardless of the exact card.

Separating the 4,100 Reasoning Tokens From Ordinary Output

Reasoning tokens don't get a separate price line. GitHub's billing model measures output tokens as what the model generates, and reasoning is generation — the model's internal deliberation before it commits to an answer. So all 37,500 output tokens, including the 4,100 reasoning ones, bill at the output rate. The practical effect: a reasoning model's thinking time is invisible in your prompt but fully visible on the invoice.

This surprises people. When a reasoning session shows ↑ 3.9m ↓ 37.5k, the downward arrow covers the full 37,500, and 4,100 of those were "thinking" before any visible text appeared. If the model is a reasoning variant priced at $40 per million output, that 4,100-token thinking block alone costs $0.164 — more than the entire cached-input line on a budget model. The reasoning share here is about 11% of output, which is modest; some reasoning sessions run thinking-to-answer ratios of 3:1 or higher, and that ratio is the main cost control a user has.

How do you control it? Set your reasoning effort lower on models that expose the setting. Fewer thinking tokens mean a cheaper output line with no change to your prompt. Watch the downward arrow in the usage display for a few sessions and you'll see the pattern: the output figure balloons on reasoning models even when answers stay the same length. That's the thinking, and it's billable.

If you're auditing an invoice and can't square the total, the first step is checking whether the model that ran the session includes a cache write cost. The second is confirming the reasoning level the session used. Both change the output and cache lines without changing the token counts you see. GitHub's own usage display in the plan settings breaks down credits per session; if it doesn't match your arithmetic, the per-model rate on the pricing page is the authority to check, not a third-party calculator.

Running This Exact Session Against a Monthly Allowance

Copilot Pro at $10 per month includes a base credit allowance that matches its subscription price, plus a flex allotment GitHub describes as a variable monthly amount on top. Per GitHub's pricing announcement, base plan pricing didn't change on June 1, 2026 — Pro stays at $10, Pro+ at $39. The AI Credits allowance is where the flex allotment lives, and GitHub explicitly says it varies as model economics evolve.

Take a mid-range session at $2.44 and a Pro user with a base-plus-flex allowance in the low hundreds of credits per month. Three heavy agent sessions in a day would consume what a moderate user spends in a week. One cloud agent that iterates across a large repository for a full afternoon could plausibly burn several such sessions back-to-back. The allowance disappears faster than the token count suggests, because the cached discount only kicks in after the cache is warm — the first read of a repo at full input rates is the expensive one.

For organizations the pooling matters more. Copilot Business and Copilot Enterprise include per-user credits pooled at the billing entity level, meaning a heavy agent user in one team drains the shared pool while light users subsidize it with unused credits. GitHub's docs are explicit that overspend beyond the pool bills at per-token rates in AI Credits. A finance team budgeting per seat will underestimate if it assumes even usage.

Confirm current allowance figures on GitHub's usage-based billing pages, since the flex allotment changes monthly and GitHub doesn't guarantee it. The structure, though, is stable: base credits never change, flex varies, and anything past both bills per token.

How to Cap This Session's Cost Before It Runs

You can stop this exact token pattern from turning into a surprise invoice. The control is the budget setting, and GitHub documents a blunt option: create or edit a Bundled AI credits budget, set it to $0 USD, and enable "Stop usage when budget limit is reached." Do that and usage halts the moment your included allowance is exhausted. The session either finishes inside the allowance or stops partway.

For less drastic control, set a dollar budget above zero and let the stop switch do its job. This matters most for agent sessions, where the token count grows without user input — the agent decides how many files to read and how many turns to take. A 3.9M-token agent session isn't user-driven; you typed a prompt and the agent ran. Without a budget cap, an agent looping through a large repo can produce token counts far above this one.

Third, choose the model deliberately. Every Copilot surface that lets you switch models lets you choose the cost tier. A 37,500-token output on a budget model costs cents; the same output on a top-tier reasoning model costs dollars. For routine edits, the budget model is almost always sufficient. Save the premium model for the reasoning that needs it.

Fourth, watch the cache pattern. Sessions that reuse context across many turns benefit from caching; one-shot prompts that load a fresh repo each time don't get the discount. If you're paying for uncached input on repeated context, consolidate the work into one session rather than many.

Reading the Arrows and Cached Tags in the Copilot Usage Display

GitHub's usage display uses arrows: ↑ for input tokens, ↓ for output tokens, plus a cached tag alongside the input figure. The reading order matters. ↑ 3.9m 3.5m cached means 3.9M input of which 3.5M cached, so fresh input is 400k. ↓ 37.5k 4.1k reasoning means 37.5k output of which 4.1k reasoning, so visible answer tokens are 33.4k. Subtract before you price; pricing the headline numbers overstates cost.

The display exists because raw token counts can't tell you your bill. A session with 3.9M total tokens might cost nine cents or five dollars, and the arrows alone don't distinguish. The model label attached to the session does. If the display shows a session without a model name, the credits line in your billing settings is the fallback authority.

Different Copilot surfaces produce different arrow patterns. Chat sessions show modest input counts and larger output relative to input. Agent sessions flip it: massive cached input, smaller output. A 3.9M-input session is almost certainly an agent run, not a chat. Knowing that tells you where to focus cost control — on agent run frequency and model selection, not on prompt length.

One edge case: if the display shows cached input but your session ran on a model with cache write costs, the write line may appear separately from the cached-input line. Earlier models fold the write into the cached figure or omit it. A mismatch between your arithmetic and the displayed credits usually traces to this line.

What Happens When the Cache Goes Cold Mid-Session

The riskiest scenario for this token count is a mid-session cache miss. Cached tokens only save money if the model can reuse them; if the session restarts, branches, or exceeds the cache's lifetime window, previously cached tokens get reprocessed at full fresh-input rates. A 3.9M session that loses its cache halfway can double its input cost in one stroke.

Cache lifetime varies by provider. Anthropic's documented prompt caching, for example, offers cache lifetimes measured in minutes by default and extended durations as an option; GitHub's Copilot layer inherits whatever lifetime the underlying model applies. Start a long agent session, let it sit idle past the cache window, and the next turn reprocesses the whole context. The session's displayed token count may look similar, but the cached tag drops and the bill rises.

The failure case looks like this: a Pro user opens a large repository agent session, watches it run to 3M cached input, steps away for lunch, returns, and continues. The first post-lunch turn sends the full context uncached. Input cost jumps from the cached rate to the fresh rate for the entire history. On a $3/M-frontier model that's $9 for one turn that would have cost $0.90 cached.

GitHub does not publish a per-session cache lifetime figure for Copilot; the model provider's documentation governs cache expiry. The safe habit for expensive agent work is to finish a session in one sitting rather than leaving it open across hours. If you must break, start a fresh session with a clear context rather than resuming a cold one, and expect the first turn to cost more.

Setting a Per-Session Cost Target From Your Token Split

You can budget from this token pattern forward. Suppose your target is $1 per agent session. On a mid-tier rate card ($2.50/M input, $0.25/M cached, $15/M output), you can afford roughly 400,000 fresh input tokens, 3.5M cached, and 37,500 output for about $2.44 — so the $1 target means halving the output or cutting the fresh input. On a budget tier, the same split costs $0.13, and you can run seven or eight sessions before hitting $1. On a premium tier, $1 buys a quarter of one session.

The math gives you a decision rule. If your work needs reasoning, run it on a premium model but use the budget model for everything else in the same workflow. If your work needs volume, keep the model tier low and let caching do the heavy lifting. Very few workflows need the premium tier for every turn.

GitHub's flex allotment design reflects this: the company knows model economics swing, and it reserves the right to adjust the variable portion of allowances accordingly. Budgeting from your own session data is the only reliable path. The token counts shown in GitHub's display are the starting point; the model label converts them into dollars.

FAQ

Does 3.9 million tokens really cost only a few dollars?

In this session, yes — because 89.7% of the input was cached. Cached input bills at roughly one-tenth of fresh input on most frontier models, so the headline 3.9M figure is mostly a discount line. The same 3.9M tokens with no cache, all sent fresh at $3 per million, would cost $11.70 just for input. The cache tag is the reason the bill stays low.

Why are reasoning tokens billed if I never see them?

GitHub measures output as what the model generates, and a reasoning model generates its thinking before its answer. The 4,100 reasoning tokens are generation, so they bill at the output rate alongside the 33,400 visible answer tokens. Lower the reasoning effort setting where the model exposes one, and the output line shrinks without shortening your answer.

What's the difference between cached input and cache write cost?

Cached input is the discounted rate for reused context. A cache write cost is a separate charge for the first time context enters the cache, and only some models levy it. GitHub's pricing page lists GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna, GPT-6 Astra, GPT-6 Luna, GPT-6 Sol, GPT-6.1 Sol, and GPT-6.1 Terra as carrying a cache write cost; earlier OpenAI models don't. Check the model's row on the pricing page before pricing a cached-heavy session.

Can I stop a session from costing more than my allowance?

Set a Bundled AI credits budget to $0 USD and enable "Stop usage when budget limit is reached" in your Copilot billing settings. GitHub documents this as the hard stop. The session halts when the allowance runs out rather than rolling into paid usage. For a softer limit, set a dollar budget above zero instead.

Does the model choice change the cost of identical tokens?

Yes — by more than an order of magnitude. The same 3.9M/37.5k split costs about $0.13 on a budget-tier rate card, $2.44 on a mid-tier card, and $5.25 on a premium card in the illustrative tiers shown above. The token count sets the volume; the model sets the rate; the two multiply.

What happens if the cache expires in the middle of an agent session?

Previously cached tokens get reprocessed at full fresh-input rates on the next turn. A session that loses its cache halfway can roughly double its input cost, and the displayed token count may barely change while the bill jumps. Finish long agent sessions in one sitting, or start fresh rather than resuming a cold session.

Do I need to track tokens manually under the new billing?

Not for billing — GitHub's usage display shows credits per session in your plan settings. Manual tracking helps for budgeting, though. Multiplied token counts by model rate let you forecast a month's usage, and the reasoning-to-answer ratio tells you whether a reasoning model is earning its premium. GitHub's "Models and pricing for GitHub Copilot" page is the authority for rates.

Is 1 AI credit always one cent?

Yes — GitHub defines 1 AI credit as $0.01 USD across individual, business, and enterprise billing. The credit is a display unit for a dollar total calculated at each model's token rates; the conversion carries no markup. What varies is the token rate per model, not the credit value.

This article is general educational information about GitHub Copilot billing mechanics, not financial, legal, or procurement advice. Token rates, allowances, and model lineups change — confirm current figures on GitHub's official pricing and usage-based billing documentation, and consult whoever manages your organization's software budget before committing to a spending plan.