GitHub Copilot AI Credits Explained: Plans, Credit Costs and How Not to Run Out

The short answer

This page is built from GitHub’s own sources: the usage-based billing announcement, the individuals billing doc, the organizations and enterprises doc, the models and pricing reference, the monitoring guide, the budgets how-to, the optimization tutorial, the session-limit doc and the plans page. All of them were fetched on October 30, 2026. The converter tables are our arithmetic on GitHub’s published token prices, because the doc lists dollars per million tokens rather than credits. We did not run Copilot sessions to measure real consumption, so the worked examples use stated token shapes, not observed usage.

What changed on June 1

GitHub’s chief product officer announced the move on April 27, 2026 and set June 1, 2026 as the switch date. The post says premium request units were replaced by GitHub AI Credits and that credits are consumed by token usage, including input, output and cached tokens, using each model’s published API rate. GitHub’s stated reason is that Copilot had turned from an in-editor assistant into an agentic platform, and that under the old model a quick chat question and a multi-hour autonomous session could cost the user the same amount.

Four details from that announcement shape everything below. Base plan prices did not change: Pro stayed $10 a month, Pro+ $39, Business $19 per user and Enterprise $39 per user. Code completions and next edit suggestions stayed included and uncharged. The fallback behavior ended: before, users who exhausted premium requests could drop to a cheaper model and keep working, whereas now usage is governed by credits and budgets. And code review gained a second meter, because it consumes GitHub Actions minutes at the normal per-minute rates on top of AI credits.

Annual subscribers were treated differently. The announcement says users on annual Pro or Pro+ plans stay on premium request pricing until their plan expires, with higher model multipliers from June 1, and then move to Copilot Free unless they upgrade to a monthly plan or convert early for prorated credits. GitHub’s pricing doc points those subscribers to a separate legacy multiplier table, which we did not fetch, so nothing in this guide applies to annual plans still on request-based billing.

One thing in the current docs postdates the announcement. The announcement lists Free, Pro, Pro+ and Student for individuals, while the current individuals doc and the plans page also list a Copilot Max plan at $100 a month. We found no GitHub post in the sources above that explains when Max launched, so we only report what the doc says it includes.

Plans: base vs flex credits

GitHub’s individuals doc splits each paid plan’s monthly allowance into two parts. Base credits come with the subscription, match the subscription price and, in GitHub’s words, never change. The flex allotment is an additional monthly amount on top. GitHub describes it as a variable part of your included usage that is designed to adapt as the economics of AI evolve, including model pricing, new models and efficiency improvements. Base credits are spent first. If you go past them, the flex allotment is applied automatically at the same rates across the IDE, GitHub.com and Copilot CLI, with no extra setup.

The credit counts come from the individuals billing doc. The plans page agrees: it shows the total credit value as $15, $70 and $200 a month, the base credits as $10, $39 and $100, and flex allotments of $5 for Pro and $31 for Pro+ (the Max flex figure did not render in our fetch of that page, so the 10,000 comes from the doc alone). The last column is ours. Divide the price by the total credits and Max gives you the cheapest credit at half a cent, while overage costs a full cent. That gap is the whole economic case for upgrading before you pay for extra usage.

Copilot Free and Copilot Student also get a credit allowance, but the doc gives no number for either. It says both are limited to access through auto model selection only, that Copilot Free includes 2,000 code completions a month and that Copilot Student includes unlimited completions. The plans page describes Free as limited chat and agent usage. Treat any exact Free credit figure you see elsewhere as unverified.

Two rules matter for planning. Included credits do not roll over: unused credits are forfeited, and the allowance resets to the full monthly amount at 00:00:00 UTC on the first day of each calendar month. That reset date is fixed and ignores your billing date, so a plan you buy on the 25th gets a full allowance for a few days and then a fresh one almost immediately. And because flex is the variable part, the totals above are a snapshot. Check the doc before you build a team budget on the Pro+ figure of 7,000.

Credits-to-dollars converter

The conversion is one line. Copilot prices every token class per million tokens, you multiply each class by its price, sum them, and multiply the dollars by 100 to get credits. The pricing doc says the cost depends on two things only, the model and the number of tokens consumed. Dollars per million tokens times 100 gives credits per million tokens, so a model at $2.00 per million input tokens costs 200 credits per million input tokens, or 0.0002 credits per token.

// Prices are USD per 1M tokens, copied from GitHub's models-and-pricing doc.
// 1 AI credit = $0.01, so credits = dollars * 100.
function credits(tokens, price) {
  const usd =
    (tokens.freshInput * price.input +
      tokens.cachedInput * price.cached +
      (tokens.cacheWrite ?? 0) * (price.cacheWrite ?? 0) +
      tokens.output * price.output) / 1_000_000;
  return usd * 100;
}

// Claude Sonnet 5.5: input 2.00, cached 0.10, cache write 2.50, output 10.00
credits(
  { freshInput: 100_000, cachedInput: 400_000, output: 20_000 },
  { input: 2, cached: 0.1, cacheWrite: 2.5, output: 10 }
); // about 44 credits, i.e. about $0.44

The reference session in the last column of the tables below is one agent run with 100,000 fresh input tokens, 400,000 cached input tokens and 20,000 output tokens, and no cache writes. It is a stated shape, not a measurement, but it resembles a short multi-turn agent task where most of the context is re-read from cache. Add cache writes separately where the model has that price: 50,000 tokens written to cache on Sonnet 5.5 would add $0.125, or 12.5 credits.

Every cell below reads credits per 1M tokens, with the doc’s dollar price in brackets. All rates are GitHub’s list rates for the default tier, as published on October 30, 2026. Models marked n/a in the cache write column have no cache write price in the doc.

OpenAI models

The doc says GPT-5.6 Sol, Terra and Luna, GPT-6 Astra, Luna and Sol, and GPT-6.1 Sol and Terra carry a cache write cost in addition to cached input, while earlier OpenAI models have none. GPT-6 Astra is the most expensive OpenAI row at 1,000 credits per million input tokens and 5,000 per million output tokens, and GPT-6 Luna is the cheapest at 10 and 50. For how those models compare on capability and Codex limits, see GPT-6 Astra vs Sol vs Luna: price, release dates and Codex usage.

Anthropic models

The doc lists a cache write price for every Anthropic row. Claude Opus 5.5 and Sonnet 5.5 are cheaper than the models they follow on input and output (Opus 5.5 at 400 and 2,000 credits against Opus 5 at 500 and 2,500), and both cut the cached rate in half, which is why their reference sessions come out lower. If you are choosing between those two for coding, Claude Opus 5.5 vs Sonnet 5.5 for coding covers the capability side. Fable 5.1 keeps Fable 5’s $10 input and $50 output but drops the cached rate from $1.00 to $0.25, a change we cover in the Claude Fable 5.1 guide.

Google, Microsoft, xAI and Moonshot models

The doc footnotes the two Gemini rows as promotional pricing: Gemini 3.8 Flash at the listed rates through December 31, 2026 and Gemini 4 Argon until December 1, 2026. It does not say what happens after those dates, so do not assume the rates stay. More on the Google models in the Gemini 4 Argon guide. Grok 4.5, 4.6 and 4.7 share identical rates in the doc, so the table lists them as one row.

Long-context tiers

Several models switch to a higher rate once the input crosses a threshold. The doc labels the tier Long context and gives the threshold in input tokens. Past the threshold, input, cached input and output prices all rise, in most rows to roughly double the input price.

The doc’s note says models with a Long context tier offer extended capabilities and longer context windows. It does not say whether the higher rate applies to the whole request or only to the tokens past the threshold, so budget conservatively: a single long-context agent run on GPT-6 Astra at the rates above would cost far more than the default-tier figure in the earlier table.

Image generation

Image generation is billed separately from the model running your session. The doc lists one model, GPT Image 2.5 Flare, in public preview, at $5.00 per million text input tokens, $1.25 cached text input, $8.00 image input, $2.00 cached image input and $30.00 image output. In credits that is 500, 125, 800, 200 and 3,000 per million tokens. Text you send counts as text input, images you send count as image input and the generated image counts as image output.

Models on the plans page without a rate

The plans page lists several models that we could not find in the pricing tables: GPT-5 mini, GPT-5.2, GPT-5.2-Codex, GPT-5.4, GPT-5.4 mini, GPT-5.5 and Gemini 3.7 Flash. The pricing doc also has an empty Fine-tuned (GitHub) table. If you use one of those models, read the rate in your own usage dashboard rather than inferring it from a neighbor.

How far do the credits go?

With the reference session priced, you can see how many such sessions each plan covers. The numbers below are the monthly total credits (base plus flex) divided by the session cost and rounded down. They assume you use only that model and nothing else, which nobody does, so read them as a scale rather than a forecast.

The spread between the cheapest and dearest model in this table is 100 to 1, and that is the single biggest lever you have. Running a routine task on GPT-6 Luna instead of GPT-6 Astra turns six sessions per Pro month into 625.

The same arithmetic tells you when to upgrade. Overage costs $0.01 per credit, and the upgrade rule in the individuals doc is that you pay only the price difference, with your usage so far in the cycle counted against the larger allowance. Pro to Pro+ adds $29 for 5,500 more credits. If your month would otherwise exceed 4,400 credits on Pro, you would pay $10 plus $29 of overage by that point, which equals the $39 of Pro+, so heavier use is cheaper on Pro+. By the same logic Pro+ to Max adds $61 for 13,000 credits, and the break-even is 13,100 credits a month on Pro+. These thresholds assume the flex allotments in the table stay as they are, and they ignore Max’s plan-specific features, which are outside this guide.

What burns credits

Both billing docs list the same features as metered. The plans page adds the code review and Copilot app surfaces. A feature consumes credits whenever it calls a model, and what it costs is set by the model it called and the tokens exchanged.

GitHub names three drivers of how much a task costs. Conversation length and complexity matter because longer threads involve more back-and-forth and re-sent history. Agentic features matter because a single task can involve many model calls. And model choice matters because capable reasoning models cost more per token, which is why the doc says switching to a less expensive model is one way to extend your allowance.

Code review costs

Copilot code review is the one feature where you cannot read a model price and estimate the bill. The doc says the model is selected automatically and not disclosed, so per-token costs may vary between reviews. Each review is billed twice: tokens in AI credits, and the agentic infrastructure behind the review in GitHub Actions minutes. GitHub publishes dollar estimates per review effort level, which convert to credits at 100 per dollar.

GitHub calls these estimates only. Consumption generally rises with pull request size and with repository custom instructions, actual costs can fall outside the ranges, and the figures exclude Actions minutes. At the Max level, one average review is 1,000 credits, which is two thirds of a month of Copilot Pro. Actions minutes are attributed to the repository and from there to the enterprise or cost center where applicable.

Who pays depends on who triggered the review. For members with a paid Copilot license, credits are charged to the member or the organization depending on the policy for how licensed members are billed. If the requester has no Copilot seat, usage goes to the enterprise or cost center. For pull requests authored by the Copilot cloud agent, usage is attributed first to the human co-author, and to the organization if that person cannot be billed. Pull requests from other bots, or reviews requested by a bot, are billed directly to the organization. You can see the Actions side by filtering metrics on the copilot-pull-request-reviewer workflow or by filtering the billing usage report on the workflow_path value dynamic/agents/copilot-pull-request-reviewer.

Discounts: auto model selection and Fusion

Two discounts are documented for paid plans. Users on a paid plan get a 10 percent discount on model costs while using auto model selection in Copilot Chat or the Copilot cloud agent. And through November 30, 2026, paid-plan users get a 30 percent discount on model costs when they use Copilot Fusion. Both appear in the individuals doc, and the Fusion note is repeated in the optimization tutorial.

Fusion is described in the tutorial as a mode that evaluates each task and picks the most efficient execution pattern, either one best model or several models doing review passes, for the effort level you choose. The three levels are Fusion Standard (balances cost, quality and latency), Fusion High (balanced orchestration with moderate token savings) and Fusion Max (frontier capability while still considering token efficiency). GitHub says Fusion keeps the main conversation on the same model where it can, so the conversation keeps benefiting from cached tokens. Neither doc says how a discount shows up in the usage dashboard, and we did not test it. The Fusion discount has a fixed end date, so do not plan a quarter around it.

When you run out of credits

On an individual plan the individuals doc gives three options once the included credits are gone. You can upgrade, where the cost is only the difference between your current plan and the new one, and the credits are available immediately. You can stay put and pay for more by setting a budget for additional usage, noting that additional usage may be capped and that you must pay off any extra usage already consumed to keep going. Or you can wait for the monthly reset. The extra-usage budget is set in US dollars while usage is shown in credits, so a $10 budget covers 1,000 credits.

What you will not get is the old fallback. The announcement says that users who exhausted premium requests could previously fall back to a lower-cost model, and that this experience is no longer available. When the money is gone, the agent stops. If you bought Pro, Pro+ or Max through an in-app purchase on iOS or Android, the doc says you cannot buy extra credits through the app store, but extra paid usage can still be billed to a payment method on your GitHub account according to your budget settings. To keep all billing in one place, GitHub suggests cancelling the mobile subscription and re-subscribing on GitHub.com.

Business and Enterprise

Organization plans work differently from individual ones. The organizations doc says each assigned license adds a monthly allowance to a shared pool, so an enterprise with 100 Copilot Business users gets 190,000 credits as one pool rather than 100 separate buckets. Light users offset heavy ones. Adding licenses mid-cycle grows the pool at once, while removing licenses does not shrink it until the next cycle.

The announcement also granted existing Business and Enterprise customers promotional included usage for June, July and August, at $30 and $70 in monthly credits per user. That window has closed, and the current doc table shows 1,900 and 3,900. The organizations doc does not state a base and flex split for these plans, so we do not give one.

Defaults matter here. On Business and Enterprise, additional usage past the pool is enabled by default, so an administrator who wants a hard stop at the included credits must disable the AI credits paid usage policy in the AI Controls settings. Budgets can then limit users and spend. A user-level budget caps an individual’s total consumption per cycle, including usage drawn from the pool, and always enforces a hard stop. A $0 user-level budget immediately blocks credit-consuming features while leaving inline completions available. Cost center budgets limit metered charges for a group, enterprise spending limits cap total metered charges, and organization budgets cover users whose seats are billed to the organization. The budgets doc warns that a user-level budget is the first check in the evaluation sequence and can block someone even when the enterprise or cost center budget has capacity left.

An organization can also see GitHub App usage on its bill. A GitHub App installed on an organization can use an installation access token to call Copilot without a user signing in, and the owning organization pays under its own model policies. You cannot create a budget for an individual app or installation. When a member runs out, a banner on GitHub.com lets them ask an administrator for more budget.

How to monitor usage

GitHub gives you several views, and none of them is a per-request ledger. The monitoring doc is explicit that the AI usage page shows credits consumed and costs by model, but that you generally cannot trace consumed credits to specific prompts, sessions or exact features. Plan around that limit: measure by model and by day, not by prompt.

Individual accounts

1. Open github.com/settings/billing and click AI usage in the sidebar.
2. Read how many included credits you have used, how much additional usage you have consumed beyond the plan, a chart of the models you have used, and a table of credits and cost per model.
3. For a quicker number, click your profile picture, open Copilot settings, and read the Usage card for the current period.
4. To download a usage report, follow GitHub’s doc on viewing usage of metered products and licenses.

Inside the editor and the CLI

In VS Code, click the Copilot icon in the status bar to see which features your plan includes, your progress toward limits and the date your allowance resets. In Visual Studio, click the Copilot icon at the top right and then Copilot Consumptions. In JetBrains IDEs, click the status bar icon and choose View quota usage. Xcode shows it from the menu bar icon, and Eclipse from the status bar icon. GitHub recommends minimum versions for accurate pricing and alerts: VS Code 1.120, Visual Studio 2022 17.14.33, Visual Studio 2026 18.6.0, the JetBrains plugin 1.9.1, the Eclipse plugin 0.18.0, the Xcode extension 0.50.0 and Copilot CLI 1.0.48. Older versions still work but can show wrong prices or miss usage alerts. In the CLI, /context shows current context usage, and /chronicle cost-tips analyzes your session history for ways to cut token spend.

For Business and Enterprise members, the Copilot settings page shows Usage this cycle. If a user-level budget applies, the card shows credits used out of the budget total, for example 450 of 1,000. Without one it shows the running total.

How to cap spending

There are three layers of control, and they do different jobs. Budgets are the money limit for a month. Alerts tell you before the limit. Session limits cap a single task in the CLI.

Set a hard monthly cap on a personal account

1. Open github.com/settings/billing and click Budgets and alerts, then New budget.
2. Under Budget Type choose Bundled AI credits budget to cover every AI-credit SKU, or SKU-level budget to cover one, such as Copilot AI credits, Spark AI credits or Copilot cloud agent.
3. Set the budget amount in dollars. For no spending beyond your plan, GitHub’s pricing doc says to set it to $0 USD.
4. Tick Stop usage when budget limit is reached. GitHub flags this as important: if you do not select it, you are only emailed when you exceed the budget and usage is not stopped.
5. Tick Receive budget threshold alerts to get an email and a GitHub banner at 75, 90 and 100 percent of the budget, then click Create budget.

Separately, under Included usage alerts on the same page, you can opt in to emails when your plan’s included usage reaches 90 and 100 percent. That covers the included credits, not the paid overage, so most people want both. Avoid overlapping budgets, such as a product-level and a SKU-level budget on the same spend, because whichever hard budget is exhausted first blocks usage and the other one cannot prevent it.

Cap a single CLI task with a session limit

A session limit caps the credits Copilot may spend on one session. It is in public preview and must be set to at least 30 credits. In an interactive session, run /limits set max-ai-credits NUMBER and remove it with /limits unset. For scripted runs, pass --max-ai-credits NUMBER, as in copilot -p "YOUR PROMPT" --max-ai-credits NUMBER. When the limit is reached, the agent stops cleanly and tells you. In interactive mode you can raise the limit and continue, and in non-interactive mode the run ends.

These are soft limits. If a response is in progress when the limit is hit, it completes first, so actual use can slightly exceed the number. GitHub also says session limits do not replace user-level budgets or spending limits, which govern monthly consumption. The SDK also supports session limits, per the optimization tutorial, but the setting steps we verified are CLI-only.

Set budgets for a team

Organization and enterprise owners and billing managers use the same Budgets and alerts page under Billing and Licensing. The Bundled AI credits budget type can be scoped to the enterprise, an organization, a cost center or a single user. Leaving the user field empty creates a universal budget for every Copilot-licensed user, choosing a cost center sets one per-user amount for that group and overrides the universal one, and choosing a specific user overrides both, optionally with an expiry (end of the billing cycle, or a date you pick). Existing premium request budgets were converted automatically to AI credit budgets. Configure budgets before users start consuming credits.

How to spend fewer credits

GitHub’s optimization tutorial is more practical than most vendor docs, and it lines up with the pricing tables above. These are its main points, with the reasoning from the table where it applies.

• Match the model to the task. GitHub suggests reasoning models for architecture and complex debugging, mid-tier models for executing a clear plan, and lighter models for refactoring, formatting and documentation. With a 100 to 1 spread across rows, this is the largest saving.
• Raise reasoning effort only for hard tasks. Higher levels can improve hard answers but use more tokens and therefore more credits. Configurable reasoning is available in VS Code and the CLI for supported models.
• Preserve the cache. Cached tokens typically bill at 10 percent of the input price, which holds for most rows in the tables, though a few models charge 5 percent or 2.5 percent and Grok 4.5 charges 25 percent. Switching models mid-session, returning to an old session after the cache expires (24 hours for OpenAI models and one hour for most others), and changing reasoning effort, context size, tools or MCP servers during a session all force a full re-send at the fresh input rate.
• Keep context lean. Open tabs, attached files and the entire back-and-forth all count as input. Start a new conversation when you switch problems (/new or /clear in the CLI), run /compact on long sessions you want to continue, keep a short AGENTS.md or .github/copilot-instructions.md as a map of the repository, and enable only the MCP toolsets you need, since tool definitions are sent on every request.
• Plan with a strong model, implement with a cheaper one. Split research, plan and implementation into separate sessions with /plan, and run subagents on cheaper models, since they start with fresh context and do not disturb the main agent’s cache.
• Write prompts with a stopping condition. A clear task, relevant files up front and a definition of done reduce retries and scope drift.
• Use tests, linters and security scans as guardrails. GitHub notes that long chains of incorrect changes are one of the biggest drivers of token waste.

If you use more than one coding agent, the same habits carry over. Our notes on how other tools meter usage are in You’re out of Codex and Work usage and Antigravity plans, AI credits and overages, and the Caveman skill token-savings guide looks at which prompt-compression claims hold up.

Claim and evidence table

Limitations

• Every price and allowance is GitHub’s published figure as of October 30, 2026. GitHub says flex allotments may change, two Gemini rates are promotional with end dates, and the Fusion discount ends November 30, 2026. Check the docs before committing a budget.
• The credits-per-million figures are the doc’s dollar prices times 100, and the reference-session numbers are our arithmetic on a stated token shape. We did not measure real Copilot sessions, so actual consumption for your workflow will differ, mainly because of how much context is cached.
• We could not find rates for GPT-5 mini, GPT-5.2, GPT-5.2-Codex, GPT-5.4, GPT-5.4 mini, GPT-5.5 or Gemini 3.7 Flash in the pricing tables, although the plans page lists them.
• The doc does not say whether the Long context rate applies to a whole request or only to tokens past the threshold, and it does not explain how discounts appear in the dashboard.
• We did not fetch the legacy multiplier table for annual plans, the budgets-for-usage-based-billing concept page, or the cost center docs, and we did not test any of the settings. The steps above follow the docs.
• Copilot Free and Student credit amounts, the Max plan launch date, and any plan features beyond credits are not covered.
• Docs change often. The June 2026 announcement describes a plan lineup (and a promotional Business credit) that has already moved on.

Verdict

Usage-based billing makes Copilot behave like a prepaid meter with a monthly top-up. The rate is simple (one cent per credit), the allowances are published, and the model price table is detailed enough to estimate almost any workload. The part that is not simple is how much of your allowance is guaranteed. Base credits are fixed, but 500 of Pro’s 1,500, 3,100 of Pro+’s 7,000 and half of Max’s 20,000 are flex, which GitHub reserves the right to adjust.

For a solo developer who mostly chats and accepts completions, Pro’s 1,500 credits go a long way on mid-tier models and the completions are free. For heavy agent use on frontier models, the table says Pro disappears in a handful of sessions, and Pro+ or Max is cheaper than overage once you pass the break-even points we computed. The practical routine is short: set a $0 Bundled AI credits budget with Stop usage enabled, turn on the 75, 90 and 100 percent alerts, check the AI usage page weekly, and keep expensive models for planning and review. Raise the budget deliberately, not by accident.

FAQ

Sources

Sources checked October 30, 2026.

• GitHub Copilot is moving to usage-based billing: GitHub Blog, April 27, 2026 (announcement, June 1 date, plan prices, annual plan treatment)
• Usage-based billing for individuals: GitHub Docs (base and flex credits, allowance table, discounts, exceeding credits, minimum IDE versions)
• Usage-based billing for organizations and enterprises: GitHub Docs (pooled credits, Business and Enterprise allowances, budget levels)
• Models and pricing for GitHub Copilot: GitHub Docs (per-token prices, long-context tiers, image generation, code review estimates)
• Monitoring your GitHub AI Credits usage: GitHub Docs (AI usage page, IDE views, reporting limits)
• Setting up budgets to control spending on metered products: GitHub Docs (Bundled AI credits budget, stop usage option, alerts, scopes)
• Optimizing your AI usage to maximize efficiency and reduce cost: GitHub Docs (model choice, cache, context, Fusion, session limits)
• Setting an AI credit session limit in GitHub Copilot CLI: GitHub Docs (commands, minimum, soft limit, public preview)
• GitHub Copilot plans and pricing: github.com (credit totals in dollars, model lists, FAQ, alert thresholds)

Related reading: Claude Opus 5.5 vs Sonnet 5.5 for coding, GPT-6 Astra vs Sol vs Luna pricing and usage, Codex usage resets guide and Antigravity credits pricing explained.