GitHub Copilot Pricing (2026): The Seat Is the Floor, Credits Are the Bill

GitHub Copilot pricing starts at $0 for Free and $10 a month for Pro, but the seat price is only the floor. Pro currently includes $15 of GitHub AI Credits, its monthly allowance for model work; chat and agents draw down that balance, and additional usage can raise the bill. Choose a plan from your model spending and budget controls, rather than how often you accept a code suggestion.

Verified against GitHub's live pricing page, Plans for GitHub Copilot, and Models and pricing for GitHub Copilot on 6 October 2026. Prices below are in USD.

GitHub Copilot Pricing Plans: Current Monthly Costs

GitHub Copilot, an AI coding assistant for your editor, terminal and GitHub workflow, charges separately for access and model usage above your included allowance. Paid plans keep inline code suggestions unlimited without drawing credits; the budget question is chat, agents and other model work.

These are the current monthly prices and allowances, verified October 2026. GitHub's plan documentation is the source for the table, including the separate Student plan.

The individual totals include variable flex credits. Pro's $15 is $10 base plus $5 flex. Pro+'s $70 is $39 base plus $31 flex. Max's $200 is $100 base plus $100 flex. GitHub says base credits match the subscription price and do not change, while flex can change as model economics evolve. The current total is useful for this month's decision; it is not a permanent guarantee. Individual billing rules.

For an occasional developer, Free can be enough indefinitely: stay within its inline allowance, use its limited Auto-selected chat and agent access, and avoid buying capacity you do not need. GitHub's current allowance tables do not publish a fixed dollar balance for Free. A paid plan becomes useful when that allowance or model-selection restriction interrupts your work.

GitHub Copilot Pricing Model: Seats Plus Usage

One GitHub AI Credit is $0.01, a billing unit rather than a prompt or a completed task. Tokens are the pieces of text a model reads and produces. GitHub prices uncached input, cached context and output according to the selected model, then converts their cost into credits.

For a paid plan with additional usage allowed, the calculation is:

Monthly Copilot bill = subscription fee + max(0, model usage in dollars minus included credit value).

The included value is already part of your subscription. Do not add it to the seat fee again. A Pro subscriber who stays inside the allowance owes the subscription, not the subscription plus the dollar value of every token consumed.

Inline suggestions, the code offered while you type, and next edit suggestions consume no AI Credits. Chat, CLI and agent work do. An agent, which can inspect files and carry out a sequence of coding actions, can make multiple model calls inside a single task. Counting your submitted prompts therefore does not establish your bill. How individual usage is billed.

A founder asking for a function explanation and a developer asking an agent to repair a repository are buying different amounts of model work, even if each starts with a short sentence. The useful number is the usage meter attached to that work.

GitHub Copilot Token-Based Pricing: Three Worked Months

The same subscription can produce very different invoices because the model and token mix change. These are hypothetical monthly workloads, calculated from GitHub's published rates, not observed customer spending or estimates of what a typical developer consumes.

GitHub quotes rates per million tokens. The examples assume manually selected models, separate token billing categories and permission to buy overage. They exclude GitHub Actions and other product charges. Replace the assumed volumes with your usage export before making a purchase decision.

A light chat user: $10 on Pro

A developer who mainly accepts inline suggestions and occasionally asks chat for explanations has little reason to buy a large credit allowance.

Assume the month's chat uses one million uncached input tokens and one million output tokens in OpenAI GPT-5 mini, with no cached input. GitHub lists input at $0.25 per million, cached input at $0.025, and output at $2.00. There is no separate cache-write charge for this model. GitHub's model rates.

The month adds up as follows:

• Input: 1 × $0.25 = $0.25.
• Output: 1 × $2.00 = $2.00.
• Model usage: $0.25 + $2.00 = $2.25, or 225 credits.
• Pro overage: max(0, $2.25 minus $15) = $0.
• Final invoice: $10 subscription + $0 overage = $10.

At a smaller unit, the same rates make 1,000 uncached input tokens plus 1,000 output tokens cost $0.00025 + $0.002 = $0.00225 of the allowance. That is token cost, not an additional charge while included credits remain.

Pick Pro if you need unlimited inline suggestions or manual model selection. The assumed chat volume fits its credits comfortably. Free may still suit your actual work, but its Auto-only access and limited allowance mean this manually selected workload is not a promise about Free's capacity.

A daily agent user: $46 on Pro+

An agent-heavy month can make the higher subscription cheaper after overage, even before the lower plan's bill looks dramatic.

Assume a developer's daily agent work totals ten million uncached input tokens, ten million cached input tokens, two million cache-write tokens and five million output tokens during the month in Anthropic Claude Sonnet 5.5. These are separate billing buckets; cache-write tokens are not also counted as ordinary uncached input.

GitHub lists Sonnet 5.5 at $2.00 input, $0.20 cached input, $2.50 cache write and $10.00 output, all per million tokens. GitHub's model rates.

• Uncached input: 10 × $2.00 = $20.
• Cached input: 10 × $0.20 = $2.
• Cache writes: 2 × $2.50 = $5.
• Output: 5 × $10.00 = $50.
• Model usage: $20 + $2 + $5 + $50 = $77, or 7,700 credits.

Now apply the current plan allowances to that same workload:

Pro: $77 minus $15 = $62 overage. $10 + $62 = $72 billed.

Pro+: $77 minus $70 = $7 overage. $39 + $7 = $46 billed.

Max: $77 fits inside $200. $100 + $0 = $100 billed.

Pro+ saves $26 against Pro in this month. Max costs $54 more than Pro+ because you pay for capacity this workload does not use. Buying the biggest plan before looking at consumption is expensive insurance against an unmeasured problem.

A 10-seat Business team: $321.50 total

Pooling makes Business useful for uneven workloads, but it does not make the organization's bill flat.

Assume 10 Business seats, with six developers using the light chat month and four using the agent month above. There is no other credit consumption. GitHub pools included credits at the billing entity level, so heavy users can draw from unused capacity contributed by lighter users. Organization billing rules.

First, the fixed subscription and pool:

• Seat fees: 10 × $19 = $190.
• Included credits: 10 × 1,900 = 19,000 credits, worth $190.

Then the modeled usage:

• Light chat: 6 × $2.25 = $13.50.
• Agent work: 4 × $77 = $308.
• Total model usage: $13.50 + $308 = $321.50, or 32,150 credits.
• Overage: $321.50 minus $190 = $131.50, or 13,150 credits.
• Final invoice: $190 seats + $131.50 overage = $321.50.
• Effective cost per seat-month: $321.50 ÷ 10 = $32.15.

The agent users are not individually restricted to the credit contribution of their own seats unless you impose that restriction. Their consumption comes from the shared pool, subject to user budgets and other controls.

Enterprise would cost 10 × $39 = $390, with 39,000 credits worth $390. The same $321.50 usage fits, so its Copilot invoice is $390, which is $68.50 more than Business in this example. That excludes the underlying GitHub Enterprise Cloud subscription and any Actions charges.

Do not upgrade this team solely to enlarge the credit pool. At today's allowances, each Business or Enterprise seat contributes exactly its subscription value in credits. For identical model usage and permitted overage, Enterprise cannot reduce the combined seat-and-credit bill just by supplying more credits; its extra features have to earn the difference.

GitHub Copilot Pricing for Individuals: Which Tier Wins?

Start with Free or Pro, and move up when measured model spending or a needed plan feature justifies it. Reaching the included allowance is not automatically the cheapest upgrade point.

Free: Choose it for occasional coding if the inline allowance and limited Auto access are sufficient. You never need to pay merely because you use Copilot regularly; the question is whether its limits interrupt work you value.

Pro: Choose it for unlimited inline suggestions and modest chat or agent use. Its included model value ends at $15, but paying some overage can still cost less than Pro+.

The current usage-only break-even is $44 of monthly model usage: $10 + ($44 minus $15) = $39, exactly Pro+'s subscription. Below $44, Pro is cheaper on this calculation. Above it, Pro+ is cheaper, assuming the same model workload is available on both plans.

Pro+: Choose it when your modeled or recorded usage exceeds that crossover, or when you need its premium-model access. Its current allowance adds $55 over Pro while the subscription rises $29. At usage of at least $70, the monthly saving against Pro is $26.

Max: Choose it for sustained higher consumption or its priority model access. Its break-even against Pro+ is $131 of model usage: $39 + ($131 minus $70) = $100. Above $131, Max wins the usage calculation; at $200 or more, its saving against Pro+ reaches $69.

Business: Choose it when your organization needs centrally managed licenses, policies and pooled usage. Replacing that with individual subscriptions may lower subscription fees while losing the administrative controls you are buying.

Enterprise: Choose it when GitHub Enterprise Cloud integration, added customization or priority model access matters. Its larger pool alone is not a discount on model work. GitHub describes these plan differences in Plans for GitHub Copilot.

GitHub Copilot Usage-Based Pricing: Stop or Buy More

You can keep working past the included balance by paying for additional usage, or deliberately stop spending until credits reset. The correct setting depends on whether you want a warning or a hard limit.

For an individual paid plan, set an additional-usage budget in dollars, upgrade, or wait for the monthly reset. A $10 extra budget buys 1,000 AI Credits. GitHub may also cap further additional usage until already-consumed overage is paid. Individual overage rules.

For Business and Enterprise, paid overage is enabled by default. An administrator who wants no additional spending must disable the GitHub AI Credits paid usage policy in AI Controls. Organization overage policy.

A user-level budget covers consumption from both the included pool and paid overage. Organization, cost-center and enterprise spending limits govern additional charges after the pool is exhausted. Setting a user's budget to $0 blocks that user immediately; it does not give them unlimited access to included credits. There is no automatic fallback to a cheaper model once a budget blocks usage. How budgets interact.

1. 1

   Read the usage before changing the plan

   Open Billing & licensing > AI usage in enterprise settings and inspect consumption by user and model. Export it, then apply the monthly invoice formula. GitHub's spending guide.

2. 2

   Allow pooling without an unlimited individual draw

   Set a universal user-level budget and deliberate overrides for heavy users. GitHub recommends a universal limit above the per-license value so pooling can help heavier users. A temporary sprint override can have an expiration date.

3. 3

   Choose the overage policy and enforce it

   Disable paid usage if the included pool is your ceiling. If overage is useful, configure a spending limit and enable Stop usage when budget limit is reached. Budget alerts alone do not enforce your intended ceiling.

4. 4

   Review the first complete month

   Look for unexpectedly early blocks, heavy consumers and paid usage. Adjust budgets around the work you want completed, rather than forcing every developer into the same consumption pattern. GitHub's budget rollout guide.

GitHub Copilot Pricing Changes: Annual Plans and Other Costs

The June change kept the established seat prices while changing what controls model usage. Monthly Pro and Pro+ moved to AI Credits on June 1, 2026. A short chat and a long agent task stopped being comparable merely because both began with a prompt. GitHub's transition announcement.

Annual versus monthly: existing annual Pro and Pro+ subscribers can remain on legacy premium-request billing until their plans expire. GitHub says expiry moves them to Free, with the option to choose a paid monthly plan; converting early provides prorated credits for the unused annual value. The current plans page lists monthly offers, so an old annual deal should not be treated as a current AI-credit subscription. Verify which billing system your account uses before applying the examples above.

GitHub's old Business $30 and Enterprise $70 credit promotion was for June, July and August, not a permanent allowance. October budgeting uses the current $19 and $39 per-seat contributions. Transition terms.

Other limits matter even when your credit arithmetic is correct:

• Unused included credits expire. They reset on the first calendar day of the month at 00:00 UTC, independently of your payment date. A quiet month does not fund a later release sprint. Credit reset rules.
• Code review runs another meter. It consumes AI Credits and GitHub Actions minutes. GitHub does not disclose the automatically selected review model, so you cannot promise a universal credit price per pull request. Code-review cost rules.
• A mobile subscription can constrain overage. GitHub says additional AI-credit purchases are unavailable if you subscribe, or have subscribed, through GitHub Mobile on iOS or Android. Purchase restriction.
• Auto can change the calculation. Paid plans receive a 10% model-cost discount using Auto in the documented Copilot surfaces. The worked months use manually selected models; they do not assume that discount or an unchanged model mix. Auto discount.

The model's API-style rate inside Copilot is not a separate API account purchase. You are paying GitHub for Copilot usage under its subscription and credit rules. A model with higher output or long-context rates can consume the allowance faster even when the plan fee stays the same.

When Cursor or Claude Code Is the Better Buy

Move when the other product completes your important work with a better total budget or review workflow. An identical model name does not establish identical subscription economics.

Cursor: pay for the editor workflow you use

Cursor is an AI development environment whose Agent can read and edit files, run shell commands and restore file checkpoints. It is the better buy when that integrated editing and review workflow is what you want to work in every day. Cursor's Agent documentation.

Normalize the comparison by using the same model, token categories and completed task. Cursor's current pricing documentation lists separate Cursor Models and Other Models pools, with third-party models consuming the latter at API rates and additional on-demand usage available. It does not publish fixed dollar totals for those individual pools in the current plan table. Cursor's current usage rules.

For the Sonnet 5.5 workload above, Cursor and GitHub list the same underlying input, cache and output rates: the calculated model value is $77 before each product applies its plan allowance and any applicable platform charges. That does not make the Cursor invoice $77, or prove either subscription cheaper. Compare the actual included balance and extra charges in your account.

Stay with Copilot when editor continuity and its priced credit allowance already meet your needs. Consider Cursor when its workflow is worth the move and the normalized bill supports it. The Cursor vs GitHub Copilot comparison expands the workflow decision; use today's vendor pricing for the purchase.

Claude Code: use the subscription or terminal workflow that fits

Claude Code is an agent that reads a codebase, edits files and runs commands, available in the terminal and other development surfaces. It is the better buy when that agent workflow is your main requirement, especially if an existing Claude subscription already provides sufficient included coding usage. Claude Code overview.

Check the billing route before comparing costs. Anthropic distinguishes subscription-included usage from API billing, and says the session's displayed API/list-price dollar estimate is not the subscription invoice. Additional usage credits can introduce spending beyond the subscription. A projected token value and a charge on your statement are different quantities. Claude Code cost documentation.

The decision rule is whether your desired workload fits the subscription's available usage, including the limits you actually encounter. Copilot's AI-credit conversion does not describe a Claude subscription's capacity. Without that information, a claimed fixed-price winner would be guesswork.

Before adding a terminal subscription, try the CLI already included with your Copilot plan. Its model work draws from your Copilot credits. The GitHub Copilot CLI terminal setup guide shows how to begin.

GitHub Copilot Pricing FAQ

Is Copilot free or paid?

GitHub Copilot offers both. Free costs $0 and includes 2,000 inline suggestions monthly plus limited AI-credit use. Paid individual plans start with Pro at $10 monthly. Verified students have a separate free Student plan. Current plans.

GitHub Copilot Pricing Student: Is There a Student Discount?

Verified students can get the free Copilot Student plan, with unlimited code completions, an AI-credit allowance and Auto model selection. Verified teachers and maintainers of popular open-source projects may qualify for free Pro. Check eligibility before paying for a personal subscription. Eligibility and plan differences.

Can you provide a comparison of GitHub Copilot models?

For pricing, compare the model's input, cached-input, cache-write and output rates for your token mix. For example, Claude Opus 5.5 has $4 input, $0.20 cached input, $5 cache write and $20 output rates per million tokens. Applying the agent scenario's volumes gives $40 + $2 + $10 + $100 = $152, compared with Sonnet 5.5's $77. This is a cost comparison, not a claim about coding quality. GitHub's rates.

Can GitHub Enterprise be self-hosted?

GitHub Enterprise Server is the self-hosted product, but GitHub says Copilot is not available for Enterprise Server. Copilot Enterprise is designed for GitHub Enterprise Cloud. Do not purchase the Copilot tier assuming it supplies a self-hosted deployment. Copilot availability.

What is the GitHub Copilot controversy?

For this buying decision, the concrete issue is the change from premium-request counting to token-based AI Credits. The seat fee does not cap model spending when paid additional usage is permitted. GitHub documents the transition and its annual-plan exception; your usage and budgets establish your own cost. GitHub's announcement.

Does GitHub Copilot offer refunds?

GitHub explicitly documents a prorated refund when a Business or Enterprise seat replaces an active personal Pro, Pro+ or Max plan. Ordinary cancellation takes effect at the end of your current billing cycle; that rule is not a general promise of an immediate refund. Personal-plan billing rules and cancellation instructions.

Can I still pay annually for GitHub Copilot?

The current live plan grid lists monthly pricing. Existing annual Pro and Pro+ plans are a legacy exception that can remain on premium requests until expiry. GitHub describes moving to a monthly plan early with prorated credits, or choosing a paid monthly plan after expiry. Annual transition terms.

What to Do Before the Next Billing Cycle

Start next week by reading your model usage, selecting a plan at the calculated crossover and choosing a hard spending boundary. For a team, give the engineering lead ownership of the shared pool and user overrides before agents become a routine part of delivery.

The useful buying question is whether the work you want completed fits that budget. A larger credit balance is valuable when you consume it; idle capacity expires.

Before adding another developer subscription, get the AI Business Workflow Audit Checklist.