An AI credit is a prepaid unit of usage-based billing: a fixed-value token of account that a vendor draws down as you consume compute. In GitHub Copilot, the clearest published example, one AI Credit is worth exactly $0.01 — so 100 credits is $1 and 1,000 credits is $10. Unlike a subscription quota, a credit balance is not a count of how many times you may ask; it is a dollar balance that drains at the real cost of the tokens you consume.
That distinction is the whole point, and it is why the same balance can last a month or an afternoon. This guide converts credits to dollars, shows what a balance actually buys on each model, and explains why vendors abandoned flat-rate plans. For the specific policy change and plan-by-plan allotments, see our breakdown of GitHub Copilot moving from premium requests to AI Credits.
AI credits to dollars
Where a vendor publishes a fixed credit value, the conversion is flat arithmetic — no bulk discount, no tiering. At the Copilot rate of $0.01 per credit:
| Credits | Dollar value |
|---|---|
| 10 credits | $0.10 |
| 100 credits | $1 |
| 500 credits | $5 |
| 1,000 credits | $10 |
| 1,900 credits | $19 |
| 3,000 credits | $30 |
| 3,900 credits | $39 |
| 7,000 credits | $70 |
| 10,000 credits | $100 |
The two numbers people search for most: 3,000 credits is $30 and 1,000 credits is $10. The first was the enhanced allotment Copilot Business received during the June to August 2026 transition; the second is Copilot Pro's base allotment — its full monthly allotment is 1,500 credits once GitHub's 500-credit "flex" allotment is added (GitHub Docs, verified September 8, 2026).
Credits are not tokens
This is the most common confusion. A token is a unit of text — roughly 0.75 of a word. A credit is a unit of money. Credits are spent to buy tokens, and the exchange rate between them is set by whichever model you invoke, at that model's published API rate across input, output and cached tokens.
So the question "how many tokens does $10 of credits give me?" has no single answer. It depends entirely on model choice — which is what the next section quantifies.
What a credit balance actually buys
Take one realistic agentic turn: 15,000 input tokens (the open files, conversation history and tool results the agent has to read) producing 2,000 output tokens (a patch and an explanation). Priced at each model's published rate and converted at $0.01 per credit:
| Model | $/M in / out | Credits per turn | Turns on $10 | Turns on $39 |
|---|---|---|---|---|
| GPT-5.5 mini | $0.3 / $1.2 | 0.7 | 1,449 | 5,652 |
| Gemini 3.1 Flash | $0.3 / $2.5 | 0.9 | 1,052 | 4,105 |
| o4-mini | $1.1 / $4.4 | 2.5 | 395 | 1,541 |
| Gemini 3.1 Pro | $1.25 / $10 | 3.9 | 258 | 1,006 |
| Claude Sonnet 4.6 | $3 / $15 | 7.5 | 133 | 520 |
| Claude Opus 4.7 | $5 / $25 | 12.5 | 80 | 312 |
| GPT-5.5 | $5 / $30 | 13.5 | 74 | 288 |
| o3 | $10 / $40 | 23.0 | 43 | 169 |
The spread is 33x for identical work. The same $10 balance is 1,449 agent turns on GPT-5.5 mini or 43 on o3. That is the single most important fact about credit billing, and it is invisible on a pricing page: which model you reach for is now a line item, not a preference.
Under the old flat-quota model, reaching for the most capable model available cost you one request either way, so there was no reason not to. Under credits, that habit can cost thirty times more. Our AI pricing calculator runs the same arithmetic against your own token volumes.
Why vendors moved to usage-based billing
Flat-rate AI subscriptions were priced for a world where a request meant one question and one answer. Agents broke that assumption: a single instruction can now trigger minutes of compute, dozens of model calls and hundreds of thousands of tokens. One user running agents can cost more than a hundred users running autocomplete.
GitHub said so directly when it made the switch — product leader Mario Rodriguez noted that agentic usage is becoming the default and brings significantly higher compute and inference demands, with the company stating that the premium request model was "no longer sustainable."
Expect the pattern to spread. Metered credits let a vendor sell one product to both the autocomplete user and the agent power user without underwriting the second at the price of the first.
How to make a credit balance last
- Match the model to the task. The cheapest model in the table above does 1,449 turns on $10. Reserve frontier models for work that genuinely needs them — nuanced refactors, tricky debugging — and let a fast model handle boilerplate, renames and test scaffolding.
- Know what is free. On Copilot, inline completions and Next Edit suggestions consume no credits at all, on every tier including Free. If you mostly live in autocomplete, your bill is your subscription fee and nothing more.
- Cut the input, not just the output. At 15,000 input against 2,000 output, most of the cost in the table is what the model reads. Narrowing context — fewer open files, shorter history, targeted file references — is usually the cheapest saving available.
- Use caching where the vendor prices it. Cached input is often an order of magnitude cheaper than fresh input, which rewards stable system prompts and repeated context.
- Watch the ceiling. Paid plans generally let you buy more usage once the allotment is spent, so hitting your limit bills you rather than stopping you. That is a convenience and a hazard.
Frequently Asked Questions
What is an AI credit?
An AI credit is a prepaid, fixed-value unit of usage-based billing that a vendor draws down as you consume compute. In GitHub Copilot one credit equals $0.01. Unlike a subscription quota, which counts interactions, a credit balance is a dollar balance that drains at the actual token cost of the work you run.
How much does 1 AI credit cost?
In GitHub Copilot, one AI Credit is fixed at $0.01, so 100 credits cost $1. The rate is flat, with no bulk discount. Credit values are set per vendor, so check the specific product's published rate before converting.
How much is 3,000 AI credits?
3,000 AI Credits is $30, because one credit is fixed at $0.01. That was the enhanced monthly allotment given to Copilot Business users during the June to August 2026 transition; the standard Business allotment is $19, or 1,900 credits.
Are AI credits the same as tokens?
No. A token is a unit of text, roughly 0.75 of a word. A credit is a unit of money used to buy tokens. The exchange rate between them depends on which model you invoke, so the same credit balance buys very different token volumes across models.
How many tokens do you get for $10 of AI credits?
There is no fixed number, because credits are charged at each model's published API rate. For one turn of 15,000 input and 2,000 output tokens, $10 of credits covers about 1,449 turns on GPT-5.5 mini but only about 43 on o3 — a 33x difference for identical work.
How many credits does GitHub Copilot include?
Each paid plan includes a base allotment plus a "flex" allotment. Per GitHub Docs (verified September 8, 2026): Pro at $10 includes 1,500 credits (1,000 base + 500 flex, $15 of usage), Pro+ at $39 includes 7,000 (3,900 + 3,100, $70), Max at $100 includes 20,000 (10,000 + 10,000, $200), Business includes 1,900 per seat ($19) and Enterprise 3,900 per seat ($39). Copilot Free gets a small allowance for limited chat and agent use. Our complete GitHub Copilot guide covers the plans in context.
Can you buy more AI credits?
On Copilot, yes — paid plans can purchase additional usage once the included monthly allotment runs out. This is the main behavioural change from quota-based billing, where hitting the limit stopped you rather than billing you.
Why did AI vendors switch to usage-based billing?
Because agents made flat-rate pricing unsustainable. A single agent instruction can trigger minutes of compute and hundreds of thousands of tokens, so one power user can cost more than a hundred light users. Metering by actual consumption lets a vendor serve both without pricing for the average.
The bottom line
A credit is a cent, and the arithmetic is trivial. What is not trivial is the burn rate: the same balance stretches 33x further on a fast model than on a reasoning model doing identical work. If you are budgeting for agentic coding, the number that matters is not what a credit costs — it is how many credits your model choice spends per turn. Deciding which tool to standardise on? Our weighted comparison of Copilot, Cursor, Claude Code and Codex scores all four on price alongside quality and speed.
Credit values and plan allotments as published by GitHub; per-model rates from our maintained pricing set (base verified May 2026, September 2026 launches at published launch pricing). Rates change — check the vendor's current pricing before committing a budget.
Want AI news before everyone else?
The morning's most important AI stories, straight to your inbox. No fluff.