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, while eligible GitHub Enterprise Cloud customers can now choose Copilot access with no separate Copilot subscription and pay for AI usage from the first request. Pro still includes $15 of GitHub AI Credits, its monthly allowance for model work. Choose between a subscription with included credits and credit-only billing by comparing total usage, eligibility and spending controls.

Verified against GitHub's live pricing page, Plans for GitHub Copilot, and Models and pricing for GitHub Copilot on 29 October 2026, including the current Enterprise access, Fusion and code-review billing docs linked below. 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, now has two organizational billing models: Business and Enterprise include pooled credits, while Copilot access bills metered usage from the first request. Paid plans and organizational Copilot access 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. All plans include Copilot CLI and the Copilot app; model and feature availability remain subject to plan eligibility, administrator policies and spending controls. GitHub's plan documentation and individual plan grid supply the comparisons. The $0 Copilot access charge does not include the underlying GitHub Enterprise Cloud license. Access eligibility and transition rules.

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 automatically routed 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. That conversion is explicitly stated in the AI-credit billing documentation.

Since October 26, 2026, OpenAI GPT-6.1 Terra has been generally available on Pro, Pro+, Max, Business and Enterprise, billed at provider list pricing under usage-based billing. Rollout is gradual and organization model policies still control access. The release adds a lower-cost option for everyday agent work; the included-credit allowances of those subscriptions remain unchanged. GitHub's Terra announcement, individual allowances and organization billing.

Terra's rates below are per million tokens, with dollar rates converted to AI Credits at $0.01 each. GitHub lists the default tier at an input threshold of 272,000 tokens or fewer and long context above 272,000. Apply the relevant tier to each request, not to the cumulative tokens in a month. GitHub's model rates.

Divide a table rate by one million for its per-token credit cost. For example, default input costs 0.0001 AI Credits per token and default output costs 0.0005. Cache writes have their own charge; do not leave that category out of an agent budget.

For a subscription with included credits and 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.

Does Copilot Fusion Cost More?

Copilot Fusion charges for the models it uses, with no separate Fusion fee. GitHub does not publish a fixed per-task multiplier. It chooses models and, when needed, coordinates extra drafting and review work. GitHub's docs confirm that paid Copilot plans receive a 30% discount on Fusion model costs through November 30, 2026. Extra model calls can still make a task consume more credits than a single-model run. Fusion billing.

Copilot Fusion is the generally available successor combining Project HydraFusion with automatic model selection. It is available across Copilot plans in VS Code, the Copilot app, CLI and JetBrains, subject to eligible models and administrator policies. Existing Auto, HydraFusion and HydraFusion Max selections transition to corresponding Fusion effort levels. GitHub's Fusion announcement.

Start with Fusion Standard for everyday work, where it selects one model for a task. Use Fusion High for a substantial, well-scoped change that warrants extra checking, such as a difficult bug across several files. Reserve Fusion Max for the deepest reasoning and analysis. High and Max can call multiple models, each billed at its standard rate before the applicable discount. Fusion Max is an effort setting, separate from both the Copilot Max subscription and code-review Max. Effort levels and policies.

For a trial, update your client, select Copilot Fusion in the model picker and choose an available effort level. Compare consumption and the finished change before making High or Max the default. Review the workspace edits too: GitHub warns that discarding a Fusion draft does not automatically undo changes it already made. Fusion limitations.

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 use the default context tier unless stated otherwise and 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-6 Luna, with no cached input or cache writes. This is GitHub's recommended replacement for the deprecated GPT-5 mini. GitHub's model retirement notice.

At the default tier, GitHub lists input at $0.10 per million, cached input at $0.01, cache write at $0.125 and output at $0.50. Each request in this example stays within the 272,000-input-token default threshold. GitHub's model rates.

The month adds up as follows:

• Input: 1 × $0.10 = $0.10.
• Output: 1 × $0.50 = $0.50.
• Model usage: $0.10 + $0.50 = $0.60, or 60 credits.
• Pro overage: max(0, $0.60 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.0001 + $0.0005 = $0.0006 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 automatic model selection and limited allowance mean this manually selected workload is not a promise about Free's capacity.

A daily agent user: $33 on Pro with Terra

A cheaper model can make the smaller subscription the better buy, even when the amount of agent work stays the same.

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 GPT-6.1 Terra. These are separate billing buckets; cache-write tokens are not also counted as ordinary uncached input. Each request stays within Terra's default context tier.

The calculation uses Terra's $1.00 input, $0.05 cached input, $1.25 cache write and $5.00 output rates per million tokens. GitHub's model rates.

• Uncached input: 10 × $1.00 = $10.
• Cached input: 10 × $0.05 = $0.50.
• Cache writes: 2 × $1.25 = $2.50.
• Output: 5 × $5.00 = $25.
• Model usage: $10 + $0.50 + $2.50 + $25 = $38, or 3,800 credits.

Now apply the current plan allowances to that same workload:

Pro: $38 minus $15 = $23 overage. $10 + $23 = $33 billed.

Pro+: $38 fits inside $70. $39 + $0 = $39 billed.

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

Pro saves $6 against Pro+ in this month. Max costs $67 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.

For comparison, Anthropic Claude Sonnet 5.5 and OpenAI GPT-6.1 Sol at its default tier both list $2.00 input, $0.10 cached input, $2.50 cache write and $10.00 output per million tokens. The same token mix costs $76, or 7,600 credits, making Pro+ the cheaper plan at $45 billed, versus Pro at $71. Terra halves that modeled usage cost and lowers the cheapest invoice from $45 to $33. This compares identical token volumes, not equivalent coding results; measure completed work before switching a team. Model-rate comparison.

Long context changes the decision again. If those token volumes are all billed at Terra's long-context rates, model usage is $63.50, Pro costs $58.50, and Pro+ costs $39. Check the request-level tier before assuming the cheaper plan wins.

A 10-seat Business team: $190 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 or cost-center included-usage cap. 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 × $0.60 = $3.60.
• Agent work: 4 × $38 = $152.
• Total model usage: $3.60 + $152 = $155.60, or 15,560 credits.
• Overage: max(0, $155.60 minus $190) = $0.
• Final invoice: $190 seats + $0 overage = $190.
• Effective cost per seat-month: $190 ÷ 10 = $19.

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 $155.60 usage fits, so its Copilot invoice is $390, which is $200 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.

Should a Business or Enterprise Team Switch to Credit-Only Billing?

If you already license your developers for GitHub Enterprise Cloud and routinely leave pooled credits unused, Copilot access deserves a quote. It removes the separate Copilot seat fee for those licensed users and retains Copilot Enterprise feature and model eligibility. You also give up the included pool, so compare all consumed credits, including usage currently covered by that pool. Comparing only your overage line would understate the new bill. GitHub's transition guide.

For the same hypothetical team above, if all developers already have Enterprise Cloud licenses, Copilot access would cost $155.60 in metered usage, compared with $190 on Business or $390 on Enterprise. That is $34.40 or $234.40 less for the same workload. These are calculations from the published rates, before the underlying GitHub platform license, Actions charges, taxes or account-specific terms, and without a Fusion discount.

The decision rule is straightforward at the published subscription rates: Business or Enterprise costs the greater of its seat fees and total model usage, because the included credit value equals the seat fees. Copilot access costs total model usage plus $10 for each Copilot Standalone user. If all users already hold Enterprise Cloud licenses and consume at least the existing pool, removing the seat fee does not reduce this like-for-like model-usage bill; the lost allowance offsets it. Standalone seat charges can make switching more expensive. Confirm your actual prices and migration terms with Sales.

Keep your current plan while the comparison is unresolved. GitHub Free and Team organizations are not eligible for this access model. Self-serve Enterprise customers cannot activate it yet, and buying Enterprise Cloud solely for Copilot changes the platform side of the calculation. Existing Business and Enterprise subscriptions remain available and are not automatically migrated. Eligibility.

Before requesting a transition, check these together:

• The whole enterprise's usage and licenses. Access cannot coexist with Business or Enterprise seats inside the same enterprise, including its organizations. Count users who need the paid Standalone option, and model any expansion in adoption.
• Budgets from the first request. Access has no included pool. Keep AI credits paid usage enabled and size spending limits for all metered usage. A former overage-only budget can block work much earlier after migration.
• Assignments, policies and network access. Administrators still assign Copilot seats. Confirm required models and features are allowed; if the firewall only permits *.business.githubcopilot.com, add *.enterprise.githubcopilot.com for the new access route.
• The effective date and contract. Have your GitHub or Microsoft account team confirm eligibility, account-specific pricing and the transition date. Transitions take effect on the first day of a month. Migration checklist.

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 automatically routed 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+. Terra is available on Pro, so choosing that model alone does not require Pro+; the $38 Terra month above is one example where Pro remains cheaper.

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.

Since October 13, 2026, Google Gemini 4 Argon is available in Copilot's model picker on Pro+, Max, Business and Enterprise, subject to rollout and organization model policies. Pro is not on the eligible-plan list, so needing Argon can justify Pro+ before the usage crossover. GitHub's availability announcement. GitHub's billing docs list $2.00 input, $0.10 cached input and $10.00 output per million tokens, at promotional pricing until December 1, 2026. The Google table lists no separate cache-write rate. Treat those as temporary model rates, not extra included credits. Argon pricing and promotion.

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, additional enterprise capabilities or priority model access matters and you want the subscription with included credits. Eligible enterprises should also compare Copilot access above, which has the same feature and model eligibility without the included pool. A 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 beyond the included pool must disable the AI credits paid usage policy in AI Controls. On Copilot access, that policy must remain enabled for any credit-consuming feature to work, because there is no included allowance; use budgets to control spending. 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 on Business and Enterprise, but from the first metered use on Copilot access. Setting a user's budget to $0 blocks credit-consuming features immediately; it does not give them unlimited access to included credits. Inline completions and next edit suggestions remain available. Separate cost-center included-usage controls can also restrict how much of the pool a group draws before overage. An enforced budget blocks metered work regardless of whether a cheaper model would otherwise be available. 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. On Business and Enterprise, GitHub recommends a universal limit above the per-license value so pooling can help heavier users. On Copilot access, size it for expected consumption, not the access fee. A temporary sprint override can have an expiration date.

3. 3

   Choose the overage policy and enforce it

   On Business or Enterprise, disable paid usage if the included pool is your ceiling. If overage is useful, or you use Copilot access, keep paid usage enabled, 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. Its model work consumes AI Credits, while its agentic infrastructure consumes GitHub Actions minutes. The effort levels and published estimates below help with budgeting; they are not fixed prices 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.
• Fusion can change the calculation. The current Fusion promotion described above applies to routed model work. The worked months use manually selected models; they assume neither a Fusion discount nor the same token mix under orchestration. Fusion billing.

What Do Code Review Lite, Balanced and Max Cost?

Code-review Max consumes AI Credits for its model work and can also incur GitHub Actions usage for its agentic infrastructure. It is a review effort level in public preview, not a subscription tier or a fixed-price review bundle. GitHub automatically selects the review models and does not disclose them, so a per-token rate from the model table cannot establish the price of an individual review. Code-review billing.

GitHub publishes these estimated AI-credit costs, expressed in USD, for budgeting:

• Lite: typically $0.05 to $1 per review, approximately $0.25 on average, for fast, targeted feedback.
• Balanced: typically $0.25 to $5, approximately $1.50 on average. This is the default, with deeper analysis for complex or security-sensitive changes.
• Max: typically $1.50 to $25, approximately $10 on average, using multiple high-reasoning models for intensive review.

These are estimates, not caps or guaranteed charges. Actual consumption can fall outside the ranges and increases with factors such as pull-request size and repository instructions. The estimates exclude Actions minutes; runner choice affects that separate usage, and self-hosted runners do not consume GitHub Actions minutes. GitHub's review estimates and effort definitions.

For routine edits, start with Lite; use Balanced where the change needs deeper scrutiny, and reserve Max for high-risk or release-critical pull requests. Set an intentional default for automatic reviews and inspect actual consumption before expanding Max across repositories. You can select effort when requesting a review; organization defaults and repository overrides are also supported.

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 plans include a weekly pool for Cursor models; third-party models on Premium and above are billed at API list price from prepaid credit. Separate Cursor Models and Other Models monthly pools with on-demand usage now describe legacy plans. Check which billing system your account uses. Cursor's current usage rules.

For the Sonnet 5.5 comparison above, Cursor and GitHub list the same underlying input, cache and output rates: the calculated model value is $76 before any applicable plan allowance or platform charges. That does not make the Cursor invoice $76, 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 automatic 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 $152, or 15,200 credits, compared with Sonnet 5.5's $76, or 7,600 credits, and GPT-6.1 Terra's $38, or 3,800 credits, at its default tier. Terra's default input, cached-input, cache-write and output rates are 100, 5, 125 and 500 AI Credits per million tokens; its long-context rates are 200, 10, 250 and 750. 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, Enterprise or Copilot access 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 exporting your full model usage, selecting a plan at the calculated crossover and choosing a hard spending boundary. For an eligible Enterprise Cloud team, compare the current seat-plus-overage invoice with all usage billed from the first request, including any Standalone seats, before asking Sales to schedule a transition. Give the engineering lead ownership of Fusion effort choices, code-review defaults and user budgets.

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.