Home › Rules › GitHub Copilot AI credits explained

GitHub Copilot AI credits explained: what they cost, what you get, and how to make them last

From GitHub's own Copilot pricing page and docs, checked Nov 1, 2026. Sources below.

• Pricing
• GitHub Copilot
• AI credits
• Beginners

Short answer: Copilot measures chat and agent use in GitHub AI Credits, and 1 credit = 1 cent. Copilot Pro ($10 a month) includes 1,500 credits a month, Pro+ ($39) includes 7,000, and Max ($100) includes 20,000. How many credits a message uses depends on the model you pick and how much text goes in and out. Code completions (the gray text as you type) don't use credits on paid plans. Credits reset at midnight UTC on the 1st of every month and don't carry over. If you run out, you can wait, upgrade, or set a dollar budget for extra use, and you can set that budget to $0 so you're never charged more than your plan.

What an AI credit is

Every time you use Copilot Chat or an agent, the AI model reads text and writes text. GitHub counts that text in tokens (small chunks of words), in three kinds:

• Input tokens: what gets sent to the model: your question, the files it looks at, the chat so far.
• Output tokens: what the model writes back.
• Cached tokens: context the model already saw and can reuse. GitHub's docs say these are typically billed at 10% of the normal input price.

Each model has its own price per token. GitHub adds it up and turns it into AI credits, at 1 credit = $0.01. So, in GitHub's own words, a quick question to a light model "might cost a fraction of an AI credit," while a long Copilot cloud agent session on a top model across many files costs more, because it's doing more work.

This replaced "premium requests" on June 1, 2026. More on that below.

What each plan includes

GitHub's pricing page shows the same amounts in dollars: Pro is $10 of base credits plus $5 of flex ($15 in all), Pro+ is $39 plus $31 ($70), and Max is $100 plus $100 ($200). Copilot Student is free for verified students and also comes with an allowance. Copilot Business and Enterprise work differently: credits are shared across the company and admins set the limits.

Base credits vs flex allotment

• Base credits match what you pay (Pro's $10 buys 1,000 base credits). GitHub's docs say they "never change".
• The flex allotment is extra on top. GitHub calls it "variable" and says it "may change over time," as model prices and efficiency change. So the base number is the one you can count on.
• Order used: base credits go first. When they're gone, the flex allotment kicks in automatically, at the same rates, in your editor, on GitHub.com and in the Copilot CLI. There's nothing to turn on.

What uses credits, and what doesn't

Code review is billed two ways: AI credits for the model, plus GitHub Actions minutes for the machine that runs it. GitHub picks the review model for you and doesn't say which, so it gives estimates per review instead:

GitHub says these are estimates only, they don't include Actions minutes, and bigger pull requests and longer custom instructions usually cost more.

When your credits reset

• Your included credits reset to the full amount at 00:00:00 UTC on the 1st of every month. In the US Eastern time zone that's 7 PM on the last day of the month (8 PM while daylight saving time is on).
• The reset date is the same for everyone. It doesn't move with the day you signed up or the day you're billed.
• Unused credits don't carry over. Whatever's left at the reset is gone.

What happens when you run out

On Pro, Pro+ or Max, GitHub gives you three choices:

1. Wait for the reset on the 1st.
2. Upgrade. Copilot asks you to upgrade as you get close to your limit. You pay only the difference between the two plans, not the full new price, and the bigger allowance is there right away. What you already used this month counts toward the new plan's allowance.
3. Pay for extra use. Set a dollar budget for "additional usage". Extra credits cost the same 1 cent each, so a $10 budget covers 1,000 credits. GitHub notes extra usage "may be capped" until you pay off what you've already used.

You can also switch to a cheaper model to stretch what's left (see the model prices). GitHub's pricing page lists buying extra credits for Pro, Pro+ and Max.

How to set a spending limit (or make sure you never pay extra)

Budgets live in your GitHub billing settings. Here are the steps from GitHub's docs for a personal account:

1. Open github.com/settings/billing.
2. Click Budgets and alerts, then New budget.
3. Under "Budget Type", pick Bundled AI credits budget. That covers all your AI-credit spending in one budget.
4. Set the budget amount in dollars.
5. Tick Stop usage when budget limit is reached. This is the important one. GitHub's docs warn that if you don't tick it, you only get an email when you go over, and your usage won't be stopped.
6. Optional: tick Receive budget threshold alerts to get an email and a banner at 75%, 90% and 100% of the budget.
7. Click Create budget.

Want to make sure you're never charged beyond your plan? GitHub's own advice: create (or edit) a Bundled AI credits budget, set it to $0, and turn on Stop usage when budget limit is reached. Copilot then stops at your included credits instead of billing you.

On the same Budgets and alerts page, under "Included usage alerts", you can also choose to get an email when you've used 90% and 100% of your plan's included credits.

Paid for Copilot through the iPhone or Android app? You can't buy extra credits in the app, but if your GitHub account has a payment method on file, extra usage is billed to it based on your budget settings. A $0 budget with "Stop usage" covers that too.

How to see how many credits you've used

• On GitHub.com: go to github.com/settings/billing and click AI usage in the sidebar. It shows the included credits you've used, any additional usage, a chart of the models you used, and the credits and cost per model. You can also see it under Copilot settings (click your profile picture), in the "Usage" section.
• In VS Code: click the Copilot icon in the status bar. It shows your progress toward your limits and the date your allowance resets.
• In JetBrains IDEs: click the Copilot icon in the status bar, then View quota usage. Visual Studio, Xcode and Eclipse have it under their Copilot icon too.

GitHub's docs say the usage page shows credits by model, but you generally can't trace them back to one prompt or session. Also, GitHub recommends updating your editor and Copilot extension (for example VS Code 1.120 or later, Copilot CLI 1.0.48 or later), because older versions may show wrong prices or usage.

What each model costs

GitHub lists a price for every model, per 1 million tokens. Here are a few from each price range, with the same price turned into credits (multiply the dollar price by 100):

Prices from GitHub's "Models and pricing" table, checked Nov 1, 2026. Several models cost more past a context size (the "up to" notes), and some charge a cache write cost too. The full table lists every model, including Gemini 3.8 Flash at a promotional price through Dec 31, 2026.

The gap is big. The same amount of output costs 50 credits per million tokens on GPT-6 Luna and 5,000 on GPT-6 Astra. Two more things lower the bill on paid plans: auto model selection (letting Copilot pick the model) gets a 10% discount in Copilot Chat and Copilot cloud agent, and through Nov 30, 2026, GitHub is giving 30% off model costs when you use Copilot Fusion.

How to make your credits last

These come from GitHub's own guide to using fewer AI credits, in plain words:

1. Match the model to the job. Use a light model for formatting, docs and small, clear changes. Save the expensive reasoning models for hard bugs and big design decisions. If you're not sure, use auto model selection.
2. Plan with a strong model, build with a cheaper one. In the Copilot CLI, type /plan. In VS Code, pick "Plan" from the agent dropdown. Then start a new session to build from the plan. Our plan mode guide has ready-to-use plan prompts.
3. Say what "done" looks like. Tell Copilot what the problem is, where it is, and when to stop. Vague prompts make the agent explore, guess and redo work, and every extra step costs credits.
4. Start a new chat when you switch problems. A long chat sends its whole history with every message. In the CLI, /new (or /clear) starts fresh, /compact shrinks a long session you want to keep, and /context shows how much context you're using.
5. Give Copilot a map of your project. GitHub's guide says a good AGENTS.md or .github/copilot-instructions.md file gives agents an overview "so they don't have to read large numbers of files just to orient themselves." Fewer files read means fewer input tokens. A short example is below.
6. Don't switch models or settings mid-session. Changing the model, the reasoning level or the tools you have turned on throws away the cache, so the whole conversation gets billed again as fresh input. Caches also expire after a break (24 hours for OpenAI models, 1 hour for most others), so after a long break, start a new session.
7. Turn on only the tools you need. A big MCP server adds its whole tool list to every request.
8. Cap a session in the CLI. /limits set max-ai-credits 200 stops the agent once a session has used about 200 credits (the minimum is 30, and a reply that's already running finishes first). For one-off runs, add --max-ai-credits. GitHub calls this a public preview.
9. Let tests and linters catch mistakes early. A failing test stops a wrong turn before the agent builds three more steps on top of it.
10. Ask Copilot where the credits went. In the CLI, /chronicle cost-tips looks at your recent sessions and suggests ways to cut cost. When it spots a repeat problem, add a line about it to your instructions file.

A short "map" instructions file

Keep it short and about your real project. GitHub's guide says to include frameworks, build, test and lint commands, and mistakes the agent keeps making, and to skip long generic text, because it's included in the agent's context on every run. Put this in .github/copilot-instructions.md (GitHub's guide says an AGENTS.md works as a map too):

# Copilot instructions

## What this project is
- A small web app for [who it's for] that [the main thing it does].
- Built with [your stack, for example Next.js + Supabase].

## Where things are
- Pages: app/
- Shared pieces: components/
- Database code: lib/db/
- Tests: tests/

## Commands
- Run locally: npm run dev
- Tests: npm test
- Lint: npm run lint

## How to work
- Only read the files you need for the task.
- Make one small change at a time, then stop and tell me how to test it.
- Done means: tests pass and you've told me what changed.

More starters: copilot-instructions.md examples and AGENTS.md examples. Or build one for your exact project in the free rules generator.

What happened to "premium requests"?

Until June 1, 2026, Copilot counted premium requests: each message used one, times a multiplier for pricier models. On June 1, GitHub switched to AI credits, where the cost depends on the model and the tokens. Multipliers now only apply to people who were on a yearly Copilot Pro or Pro+ plan and chose to stay on the old system. GitHub says those plans move to Copilot Free when they end. If that's you, your options are to stay until it ends, cancel for a prorated refund, or upgrade to a monthly plan and get credit for what's left of the year.

How this compares to Cursor and Claude Code

Copilot is the only one of the big three that puts a number on your monthly allowance. Cursor uses a pool that refreshes weekly, and Claude Code uses your Claude plan's usage limits. See GitHub Copilot vs Cursor vs Claude Code for prices side by side.

Related

• GitHub Copilot vs Cursor vs Claude Code (prices side by side)
• copilot-instructions.md examples
• AGENTS.md examples
• Plan mode guide (6 tools + 6 plan prompts)
• AGENTS.md vs CLAUDE.md (which file each tool reads)
• Cursor vs Claude Code vs Codex (real prices)
• Lovable credits explained (and Bolt tokens)
• Vibe coding prompts

Sources

• GitHub: Copilot plans and pricing
• GitHub docs: Usage-based billing for individuals (AI credits)
• GitHub docs: Plans for GitHub Copilot
• GitHub docs: Models and pricing for GitHub Copilot
• GitHub docs: Optimizing your AI usage to maximize efficiency and reduce cost
• GitHub docs: Monitoring your GitHub AI Credits usage
• GitHub docs: Setting up budgets to control spending
• GitHub docs: Setting an AI credit session limit in Copilot CLI
• GitHub docs: What changed with Copilot billing (legacy)

All prices, credit amounts and settings checked Nov 1, 2026 on GitHub's own pricing page and docs. Prices are in US dollars, before tax, and GitHub says flex allotments and model prices can change. If something here no longer matches, tell us at [email protected].