GitHub Copilot AI Credits: What One Credit Buys in Tokens, Model by Model

TL;DR

One GitHub Copilot AI credit is worth $0.01, and how many tokens it buys depends entirely on the model: about 8,333 output tokens on GPT-5.6 Luna, 833 on GPT-5.6 Terra, 500 on GPT-5.6 Sol or Claude Opus 5.5, and 200 on Claude Fable 5.1. Copilot switched from premium requests to these credits on June 1, 2026. Pro ($10/month) includes 1,500 credits, Pro+ ($39) includes 7,000 and Max ($100) includes 20,000. Code completions stay free and unlimited on paid plans. The change worth planning for now is October 19, 2026, when GitHub retires GPT-5.4 and GPT-5.5 and points both at GPT-5.6 Sol: a typical agent session on the GPT-5.4 path goes from 22.5 credits to 32.

Plans, per-model rates and deprecation dates last verified: October 13, 2026.

What Changed on June 1, and What Changed Since

On June 1, 2026, GitHub flipped the billing model for every Copilot plan. The old system gave you a fixed count of “premium requests” (300/month on Pro, 1,500/month on Pro+) no matter which model you picked or how many tokens a conversation consumed. That system is gone.

Every AI interaction except code completions and Next Edit suggestions now draws from a monthly pool of AI credits, at 1 credit = $0.01 USD. The current pools, per GitHub’s docs and plans page:

GitHub’s individual billing docs describe base credits as fixed and the flex allotment as an amount that can change, so treat Pro’s 1,500 as “1,000 guaranteed plus 500 for now.” Unused credits don’t roll over: the pool resets at 00:00 UTC on the first of each month.

Four things have moved since launch day:

1. The promotional credits ended. Existing Business and Enterprise customers got extra usage ($30 and $70 per user per month) for June, July and August. That promo closed on August 31, so org plans now run on the base pools in the table.
2. The model lineup turned over. GitHub deprecated Claude Opus 4.7 and Gemini 3.5 Flash on October 2, and its mid-October deprecation notice retires GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-5 mini, Gemini 3.7 Flash and Grok 4.5 on October 19, 2026. GPT-5.5 and GPT-5.4 are replaced by GPT-5.6 Sol, and both minis by GPT-5.6 Luna.
3. Auto got cost tiers. Since a September 14 changelog, Auto model selection offers three tiers (efficiency, balance and intelligence), and paid subscribers keep a 10% discount on usage billed through Auto.
4. Org budgets got a release valve: members who hit their limit can now request a budget increase from an admin instead of simply being blocked.

How AI Credits Work

Four variables determine your burn rate.

The model you pick is the biggest one. GPT-5.4 nano costs about 24x less per output token than GPT-5.5 ($1.25 vs $30 per million), and the spread across the current lineup is wider still: Claude Haiku 5.5 output costs $0.50 per million, Claude Fable 5.1 output costs $50. Model selection is now a direct cost decision. (If you’re still deciding which AI coding tool to use at all, see our OpenCode vs Claude Code vs Cursor comparison.)

Input tokens are everything you send: your prompt, file context, conversation history. Copilot’s agent mode can stuff 50K-100K tokens of codebase context into a single request without you noticing.

Output tokens are what the model generates back: longer answers, detailed plans, multi-file edits. Output is priced 5-6x higher than input on most models, so verbose agents cost more than chatty prompts.

Cached tokens, where the model reuses context from earlier in the same conversation, are billed at a fraction of the fresh input rate: 10% on most models, 5% on Sonnet 5.5 and Opus 5.5, as low as 2.5% on Fable 5.1 and 25% on Grok. Continuing a thread is cheaper than starting a new one. Anthropic models and the GPT-5.6/GPT-6 families also list a separate cache-write rate, set at 1.25x the input price.

How Many Tokens Is One Copilot AI Credit?

This is the most common question about the system, and the answers floating around can be off by orders of magnitude. An AI-generated search summary returned while researching this update (October 13) put a single credit at “about 4 million input tokens” on GPT-5 mini; at $0.25 per million, the real figure is 40,000. The arithmetic itself is simple: a credit is $0.01, so tokens per credit = $0.01 ÷ (price per token). The short Python script below does it for the models most people are likely to pick, using the default-context rates from GitHub’s models and pricing page:

CREDIT_USD = 0.01

# model: (input, output) USD per 1M tokens, default context tier
RATES = {
    "Claude Haiku 5.5": (0.10, 0.50),
    "GPT-5.4 nano": (0.20, 1.25),
    "GPT-5.6 Luna": (0.20, 1.20),
    "Gemini 3.8 Flash": (0.75, 3.75),
    "GPT-5.6 Terra": (2.00, 12.00),
    "Claude Sonnet 5.5": (2.00, 10.00),
    "GPT-6 Sol": (2.00, 10.00),
    "GPT-5.4 (until 10/19)": (2.50, 15.00),
    "GPT-5.6 Sol": (4.00, 20.00),
    "Claude Opus 5.5": (4.00, 20.00),
    "Claude Opus 4.8": (5.00, 25.00),
    "GPT-5.5 (until 10/19)": (5.00, 30.00),
    "Claude Fable 5.1": (10.00, 50.00),
}


def per_credit(rate: float) -> int:
    return round(CREDIT_USD / rate * 1_000_000)


print(f"{'Model':<23}{'input tok/credit':>17}{'output tok/credit':>18}")
for name, (i, o) in RATES.items():
    print(f"{name:<23}{per_credit(i):>17,}{per_credit(o):>18,}")

Running it on October 13, 2026 prints:

Model                   input tok/credit output tok/credit
Claude Haiku 5.5                 100,000            20,000
GPT-5.4 nano                      50,000             8,000
GPT-5.6 Luna                      50,000             8,333
Gemini 3.8 Flash                  13,333             2,667
GPT-5.6 Terra                      5,000               833
Claude Sonnet 5.5                  5,000             1,000
GPT-6 Sol                          5,000             1,000
GPT-5.4 (until 10/19)              4,000               667
GPT-5.6 Sol                        2,500               500
Claude Opus 5.5                    2,500               500
Claude Opus 4.8                    2,000               400
GPT-5.5 (until 10/19)              2,000               333
Claude Fable 5.1                   1,000               200

“One credit” spans a 100x range: 20,000 output tokens on Haiku 5.5 versus 200 on Fable 5.1, so a single tokens-per-credit figure only ever fits one model. Newer models can also be the cheaper ones. GPT-6 Sol and Claude Sonnet 5.5 both price output at $10 per million, half of what GPT-5.6 Sol charges and a third less than GPT-5.4.

The same math answers the “how much is X credits in tokens” question. Pro’s 1,500 credits are $15 of usage, which buys 1.25M output tokens on GPT-5.6 Terra or 750K on GPT-5.6 Sol, before you count a single input token. In practice input dominates agent sessions, so treat those as ceilings.

The Full Pricing Table

GitHub bills credits “at the per-token rates shown in the pricing tables” on its docs page. These are the models worth knowing about as of mid-October (default context tier, USD per 1M tokens):

Most of the larger OpenAI models have a long-context tier: past 272K input tokens (200K for GPT-5.6 Luna), the input rate doubles and output goes up by roughly half. Agent mode on a big monorepo can cross that line without telling you. The full page also lists Sonnet 4/4.6, Opus 5, Fable 5, GPT-5.3-Codex, three Grok versions and MAI-Code-1.1-Flash, among others. Check it before you settle on a default, because the lineup has changed every few weeks since June.

Real Session Costs: The Token Math

The table below uses four representative interaction sizes and GitHub’s current rates. The token counts are illustrative and ignore caching. The numbers come from extending the script above with a session helper:

SESSIONS = {
    "quick chat": (1_000, 500),
    "coding chat": (2_000, 1_000),
    "agent session": (30_000, 10_000),
    "big agent run": (100_000, 20_000),
}


def credits(model: str, inp: int, out: int) -> float:
    i, o = RATES[model]
    return (inp * i + out * o) / 1e6 / CREDIT_USD


for name in ("GPT-5.4 nano", "GPT-5.6 Terra", "GPT-5.4 (until 10/19)",
             "GPT-5.6 Sol", "Claude Sonnet 5.5", "Claude Opus 5.5"):
    row = ", ".join(f"{s} {credits(name, *t):g}" for s, t in SESSIONS.items())
    print(f"{name}: {row}")

GPT-5.4 nano: quick chat 0.0825, coding chat 0.165, agent session 1.85, big agent run 4.5
GPT-5.6 Terra: quick chat 0.8, coding chat 1.6, agent session 18, big agent run 44
GPT-5.4 (until 10/19): quick chat 1, coding chat 2, agent session 22.5, big agent run 55
GPT-5.6 Sol: quick chat 1.4, coding chat 2.8, agent session 32, big agent run 80
Claude Sonnet 5.5: quick chat 0.7, coding chat 1.4, agent session 16, big agent run 40
Claude Opus 5.5: quick chat 1.4, coding chat 2.8, agent session 32, big agent run 80

For an older side-by-side of the June-era flash models, see the Gemini Flash vs Claude Haiku comparison.

A quick chat on GPT-5.4 nano (about 1,000 input tokens and 500 output) costs 0.08 credits, under a tenth of a cent. Pro covers roughly 18,000 of them. For simple questions, refactoring hints and boilerplate, the billing model is invisible.

A normal coding chat (2,000 in, 1,000 out) costs 2 credits on GPT-5.4, 1.6 on GPT-5.6 Terra and 1.4 on Claude Sonnet 5.5. That’s 750 to about 1,070 chats a month on Pro, which covers most people who use Copilot as a pair programmer rather than an agent.

Agent mode is where the totals move. A multi-file agentic session with plan-execute-verify loops, sized at 30,000 input and 10,000 output tokens, costs:

• 16 credits on Claude Sonnet 5.5 or GPT-6 Sol
• 18 credits on GPT-5.6 Terra (83 sessions on Pro)
• 22.5 credits on GPT-5.4 while it lasts
• 32 credits on GPT-5.6 Sol or Claude Opus 5.5 (47 sessions on Pro, about two per workday)
• 40 credits on Claude Opus 4.8

The practical catch is in the middle of that list. GitHub’s suggested replacement for GPT-5.4 is GPT-5.6 Sol, which charges $4/$20 per million against GPT-5.4’s $2.50/$15. Running the same session through it costs 42% more. If you pinned GPT-5.4 as your daily driver, the lower-friction move on October 19 is GPT-5.6 Terra or Sonnet 5.5, both cheaper than what you’re on today. GPT-5.5 users get the opposite news: a large agent run (100K in, 20K out) drops from 110 credits on GPT-5.5 to 80 on Sol.

Community reports get more extreme than these averages. In GitHub’s community discussion on the billing change, one developer reported 822 credits gone in a single request, which they put at 54% of their monthly quota. Others projected monthly costs into the hundreds. These are outliers (huge context, long agent sessions, frontier models), but they’re real scenarios that the old flat-rate system absorbed without the user ever seeing a number.

Who Gets Hit and Who Doesn’t

Developers who live on code completions won’t notice anything. Tab-complete and Next Edit remain unlimited and free on every paid plan. If that’s your primary Copilot use, the billing switch is a non-event. Free-plan users are capped at 2,000 completions and 50 chat requests a month and can’t use the cloud agent or code review at all.

Light-to-moderate chat users are fine too. Five to ten coding questions a day on a mid-tier model costs 10-20 credits, and Pro’s 1,500 covers a month without stress.

Agentic users on frontier models are the ones who feel it. Three or more cloud-agent runs a day on GPT-5.6 Sol or Opus 5.5 burns through Pro in about three working weeks. Pro+ at 7,000 credits gives real breathing room, and Max at 20,000 is the realistic floor for all-day agent use. Pro also excludes delegation to third-party coding agents such as Claude and Codex; that starts at Pro+.

Anyone who relied on the old fallback behavior also gets caught out. Under premium requests, running out switched you to a cheaper model. GitHub’s announcement says fallback experiences “will no longer be available,” and the org billing docs repeat that there’s no automatic fallback to lower-cost models. When credits hit zero, Copilot stops responding unless you’ve allowed additional paid usage.

What Developers Are Saying

The community discussion passed 500 comments and 800 replies. Three complaints kept repeating.

Rollover came up constantly. Credits expire monthly with no carryover, so a light week’s savings vanish on the reset date. Development is bursty (sprint weeks burn credits, planning weeks don’t), and the new system penalizes that rhythm.

The promotional gap drew pointed comments. Business and Enterprise customers got $30-70 per user per month in extra credits through August. Individual Pro and Pro+ subscribers got the base pool with no buffer. Now that the promo is over, org users are discovering what individuals saw in June.

The third was churn talk: several developers named alternatives they were evaluating, mostly Cursor and Devin Desktop (formerly Windsurf). The billing change removed one of Copilot’s strongest retention levers: the simplicity of “pay $10, get Copilot.”

Copilot vs Cursor vs Claude Code After the Change

Usage-based pricing is now the norm across the category, which makes cross-tool comparisons messier. Here’s how the $20-40/month tier compares (Cursor column updated October 16 for its move to the X Subscription):

Cursor went the opposite way. Since October 12, 2026 its pricing page sells the X Subscription bundle, where the weekly pool covers only Cursor’s own models (Grok and Composer 2.5) and third-party models are billed at API list price on top. Copilot’s plans include more Claude and GPT usage than their price, and Cursor’s include none, which is why Copilot comes out cheaper for Claude-heavy work at every level in the worked Cursor vs Copilot cost math. You still trade IDE flexibility for Cursor, since its editor is its own VS Code fork.

Claude Code is included with the $20/month Claude Pro subscription, with Max plans from $100/month for higher limits. Usage counts against subscription limits rather than a per-token meter, so for terminal-native, agent-heavy work the cost per session falls as usage rises, up to the plan’s limits. Anthropic had announced a separate credit pool for programmatic Claude Code usage (Agent SDK, claude -p) starting June 15, but paused that change on the day it was due. Agent SDK and claude -p usage still draws from subscription limits, and since October 7 Max plans also include $100 or $200 a month in Claude API credits. The Claude Code Pro vs Max breakdown covers what those credits do and don’t pay for.

Copilot’s remaining advantage is breadth: the widest IDE support, a free completions floor, and models from six vendors in one subscription. If your workflow is mostly tab-complete with occasional chat, $10/month is still very good value. Credit costs only become real once agent mode is part of your day.

How to Keep Your Bill Under Control

Install the copilot-cli-cost plugin first. It shows real-time estimated session cost inside Copilot CLI:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/DamianEdwards/copilot-cli-cost/main/install.sh)"

Once installed, use /cost inside any Copilot CLI session to see credit consumption as it happens. The README also lists a Windows installer and a copilot plugin install route.

Beyond the tracker, six concrete moves:

1. Set your additional-usage budget to $0 on day one. You can raise it later, but starting at zero means Copilot stops instead of charging when credits run out. The setting lives in your account’s billing settings under budgets for metered products.

2. Pick your model deliberately, and re-pick it before October 19 if you use GPT-5.4 or GPT-5.5. For boilerplate, explanations and simple refactors, GPT-5.6 Luna at $0.20/$1.20 per million is 20x cheaper on input than GPT-5.6 Sol and about 17x cheaper on output. If you’d rather not micro-manage, Auto’s efficiency tier plus the 10% Auto discount is a sane default. Our ranking of the best AI models for coding covers which tier is worth paying for on harder work.

3. Keep context windows tight. Close files you’re not editing. Agent mode inhales open-file context, and every extra file is thousands of input tokens on the meter. Research on context engineering points the same way from the quality side: pruned context made agents both cheaper and more accurate. (Also relevant: AI coding tools can leak secrets from those open files.)

4. Batch related questions. One longer conversation with cached context is cheaper than ten fresh prompts, because cached tokens bill at a fraction of the fresh input rate.

5. Reserve frontier models for hard problems. Architecture decisions, complex multi-file refactors and subtle debugging justify Opus 5.5 or Fable 5.1 pricing; adding a unit test for one function does not.

6. Check your Copilot usage in billing settings weekly. Catch runaway spending before it compounds through the month.

FAQ

What are GitHub Copilot AI credits?

AI credits are Copilot’s billing unit since June 1, 2026, replacing premium requests. 1 credit = $0.01 USD. Every AI interaction (chat, agents, CLI, Spaces, Spark, code reviews) consumes credits based on the tokens processed and the model used. Code completions and Next Edit suggestions stay free and unlimited on all paid plans.

How many tokens is one GitHub Copilot AI credit?

There’s no single number, because one credit is $0.01 and every model prices tokens differently. At current rates one credit buys 8,333 output tokens on GPT-5.6 Luna, 1,000 on Claude Sonnet 5.5, 833 on GPT-5.6 Terra, 500 on GPT-5.6 Sol and 200 on Claude Fable 5.1. Input tokens are 5-6x cheaper, so one credit covers 1,000-50,000 input tokens on the same models.

How much do Copilot AI credits cost per token?

It depends on the model. GPT-5.6 Luna runs $0.20 per million input tokens and $1.20 per million output tokens. Claude Opus 5.5 runs $4.00 and $20.00. A quick chat costs a fraction of a credit; an agent session on a mid-tier or frontier model costs 16-110 credits depending on model and context size. The full pricing table is on GitHub Docs.

What happens when Copilot credits run out?

If you haven’t allowed additional usage, Copilot stops responding until your credits reset at 00:00 UTC on the first of the month. If you’ve set a budget for additional usage, it continues at $0.01 per credit until that budget is spent. The old automatic fallback to cheaper models no longer exists. In organizations, members can now request a budget increase from an admin.

Will GitHub Copilot cost more with usage-based billing?

For chat-focused users, probably not: the included pool is generous for moderate use. For developers running frontier-model agent sessions daily, almost certainly. The old 300 premium requests on Pro worked the same regardless of model, while the new system prices Fable 5.1 output at 100x Haiku 5.5. The October 19 swap from GPT-5.4 to GPT-5.6 Sol adds another 42% per agent session for anyone who keeps the default replacement.

What counts as free vs credit-consuming in Copilot?

Free and unlimited on paid plans: code completions, Next Edit suggestions. Credit-consuming: Copilot Chat, Copilot CLI, cloud agent sessions, Copilot Spaces, Spark, third-party coding agents, and code reviews (which also burn GitHub Actions minutes separately).

Sources

• GitHub Copilot is moving to usage-based billing: official announcement, including the June-August promo and the end of fallback models
• Models and pricing for GitHub Copilot: per-model token rates and long-context tiers
• Usage-based billing for individuals: plan pools, base vs flex credits, monthly reset
• Copilot plans: Free plan limits and per-plan features
• Upcoming deprecation of selected models in mid-October: the October 19 retirements and replacements
• Selected models deprecated, October 2: Opus 4.7 and Gemini 3.5 Flash retirement
• Configure cost and quality in Auto model selection: Auto tiers and the 10% discount
• Budget increase requests are generally available: org budget changes
• Community discussion #192948: developer reactions and cost reports
• copilot-cli-cost extension: open-source real-time cost tracker
• The New Stack: Anthropic pauses Claude Agent SDK subscription change: status of the June 15 Claude Code billing split
• TechTimes: Agentic users face steepest increases: independent cost analysis at launch

Bottom Line

My read is that the billing shift makes financial sense for GitHub: a flat 300 requests a month priced a 110-credit GPT-5.5 agent run the same as a 0.08-credit nano chat, and heavy agent users were the ones collecting that gap. The optimization burden now sits with developers, and four months in, that burden includes tracking a model lineup that turns over every few weeks. Whether all that agent spend buys real output is a separate question, covered in our look at the AI coding productivity paradox.

If you only use completions and occasional chat, $10/month is still one of the best deals in AI tooling. If you run agent sessions daily, your real cost is $39-100 a month, and the cheapest thing you can do this week is check which model you’ve pinned. Anyone sitting on GPT-5.4 will be moved to a model that costs 42% more per session on October 19 unless they pick something else. GPT-5.6 Terra, Sonnet 5.5 and GPT-6 Sol all do the same session for less.