GitHub Copilot AI Credits Explained: Allowances, Overage, and Budgets

GitHub Copilot AI Credits are the usage-based billing unit for Copilot model work: GitHub converts model token costs at 1 AI credit = $0.01 USD. They are not a second Copilot seat charge, they are not the legacy premium-request counter, and they do not replace meters such as GitHub Actions minutes. A subscription or organization seat pays for access and supplies an included allowance; AI-credit usage measures the model work drawn against that allowance. Copilot code review is the notable dual-meter case: its model work consumes AI credits while its agentic infrastructure also consumes GitHub Actions minutes. Use GitHub Copilot pricing for the current plan matrix; this guide focuses on the meter, billing owner, and spend decision.

How GitHub Copilot AI Credits work

A Copilot interaction can include input tokens, output tokens, cached input, and, for some models, cache-write tokens. GitHub publishes a price per one million tokens for each applicable token type. The dollar cost of those tokens is then converted to credits:

AI credits = model token cost in USD ÷ $0.01

That is a price conversion, not a request-to-credit conversion. One short chat interaction can cost a fraction of a credit, while an agent session can make multiple model calls, carry a large context, and consume many credits. There is no defensible universal statement that one prompt, one request, one code review, or one agent task equals a fixed number of credits.

GitHub's models-and-pricing table separates input, cached-input, cache-write, and output rates. For example, its default-tier GPT-5.6 Luna row lists $0.20, $0.02, $0.25, and $1.20 per one million tokens respectively. Other models and long-context tiers use different rates. Paid individual subscribers receive a 10% model-cost discount when they use auto model selection in supported Copilot surfaces. Some organization configurations also have modifiers; GitHub documents a 10% increase for data-resident and FedRAMP-compliant Copilot requests.

Do not carry legacy model multipliers into this math. Under AI-credit billing, the model's token prices and the tokens consumed determine the charge. For historical request counters and transition eligibility, use Copilot premium requests explained rather than converting requests into credits.

Allowance and overage boundary

Every Copilot plan supplies an included allowance, but exact base, flex, or pooled amounts belong in the current plan matrix. Use the Copilot plan guide to compare those allowances and plan ownership. For this worksheet, record the live allowance shown in GitHub billing and whether it belongs to one person or a shared billing entity.

Included credits do not roll over. Individual allowances and organization pools refresh at 00:00:00 UTC on the first day of each calendar month, independently of a subscription invoice date. For organizations, assigned licenses contribute to a shared pool; budget the pool as an organization resource rather than multiplying a personal allowance.

What belongs in the credit worksheet

Copilot chats, CLI work, and agentic tasks can make one or many model calls. The credit cost changes with the model, token mix, context length, retries, and number of calls, so measure credits per completed task instead of treating the opening prompt as the unit.

Copilot code review is a dual-meter workflow. Model work consumes AI credits, while context gathering and tool use also consume GitHub Actions minutes. GitHub selects the review model automatically, so use observed credits per review and keep Actions minutes in a separate worksheet column.

Seats, Actions minutes, Codespaces, storage, and other GitHub products keep their own billing units. AI-credit budgets can group eligible AI usage, but they do not absorb seat fees or non-AI product charges.

Overage and budget mechanics

When an individual exhausts included credits, the practical choices are to wait for the next calendar-month refresh, change model or workload behavior, compare another plan, or configure a dollar budget for additional usage. Current GitHub documentation describes additional usage across Copilot plans, subject to eligible billing and a configured budget. GitHub separately says additional-credit purchases are unavailable if the person subscribes, or has subscribed, through GitHub Mobile on iOS or Android; confirm eligibility in the live billing UI rather than inferring it from the plan label.

An individual additional-usage budget is denominated in US dollars while the usage screen reports AI credits. At the fixed conversion, a $10 budget corresponds to 1,000 additional credits. This does not predict how many tasks the budget buys; model and token consumption still decide that. Enable the stop-usage control when it is available if the number is meant to be a cap. Without that control, a budget can function as an alert while charges continue.

Organization and enterprise behavior has two phases. Usage first draws from the shared included pool. After the pool is exhausted, paid usage continues at $0.01 per credit if the AI-credit paid-usage policy permits it. GitHub enables additional usage by default for organizations and enterprises, so an administrator who wants a no-overage posture must explicitly disable the policy or configure enforcing controls.

The controls are not interchangeable. A user-level budget caps one user's total consumption across both the included-pool and metered phases and always enforces a hard stop. Cost-center, organization, and enterprise budgets govern metered charges after the pool is empty. Their “Stop usage when budget limit is reached” option is off by default; without it, the threshold produces alerts but does not cap spend. There is no automatic switch to a cheaper model when a budget blocks a user.

A company budget is also not the company's total Copilot bill. Seat fees remain separate, so the maximum exposure is the license cost plus any permitted metered budget. That distinction matters when comparing a larger included pool with overage: a nominal $5,000 enterprise budget does not absorb the seat invoice.

Put the charge under the right owner

If a person with an active Pro, Pro+, or Max subscription is assigned a Business or Enterprise seat, GitHub automatically cancels the personal plan and provides a prorated refund for the remaining personal billing period. Copilot then follows the organization's policies. That is an ownership change, not a transfer of the person's unused credits into the shared pool.

Build a workload worksheet

Use observed AI-credit data from GitHub's AI usage dashboard whenever possible. A token estimate is most useful for a new model or workflow; after a representative week or month, actual credits per task are the safer planning input.

For model-based estimation, calculate each token component separately:

Estimated model USD = input cost + cached-input cost + cache-write cost + output cost

Estimated credits = estimated model USD ÷ $0.01

Monthly workload credits = credits per interaction × interactions per task × tasks per month

For an organization, compare that workload with the shared pool and any user-level cap, not simply with one seat's contribution. For code review, use observed credits because the model is undisclosed, and keep Actions minutes outside the credit formula.

Assumption-only example

The following is an arithmetic example, not a forecast or a request-to-credit conversion. Assume one non-agent interaction uses the default-tier GPT-5.6 Luna rate row, with 100,000 input tokens, 20,000 cached-input tokens, 5,000 cache-write tokens, and 10,000 output tokens.

The example equals 3.365 AI credits before any applicable discount. One hundred identical interactions would be 336.5 credits. If all qualified for the paid-individual auto-selection discount, the estimate would be about 302.85 credits. An agent task can contain several interactions with different token totals, so multiplying the first prompt by a fixed factor would be misleading.

Use the worksheet result as a range. Add a buffer for longer contexts, retries, code-review variability, and model changes. Then compare the forecast overage in credits × $0.01 with the incremental subscription or seat cost shown on GitHub's plans page. A higher plan is not automatically cheaper; it may be justified by recurring usage, model access, ownership, or controls rather than credits alone.

Choose the response to your usage

Stay within the included allowance when representative usage fits with enough headroom for context spikes and agent retries. Monitor at least one normal workload period instead of upgrading because of one unusually large task.

Change model or workflow first when the overage is driven by frontier-model selection, long context, or unbounded agent sessions. A lower-cost model, eligible auto selection, tighter task scope, and feature-level session limits can extend the allowance without changing ownership or plan.

Use paid overage when excess demand is occasional, the billing owner accepts variability, and an enforcing budget is set at the correct scope. Convert the proposed dollar cap into credits, verify every stop toggle, and keep code-review Actions minutes outside that cap.

Test a plan change when excess usage is recurring and the incremental allowance or required model access is worth more to the buyer than repeated overage. Compare the incremental plan price with measured overage, not with an invented average cost per request. Remember that an upgrade does not erase usage already consumed that month.

Move work under Business or Enterprise ownership when the company needs pooled credits, centralized policy, cost centers, billing reports, or organization-controlled access. Do not use an employee's personal allowance as a substitute for an organization budget. Before paying, confirm the billing owner, current model rate row, remaining allowance, paid-usage policy, hard-stop behavior, and whether a plan change affects access immediately or at cycle end.