GitHub Copilot pricing

About

GitHub Copilot is the AI pair-programmer and coding-agent suite from GitHub (a Microsoft subsidiary). It delivers code completions, an agentic chat experience, a cloud coding agent, automated code review, and a CLI across GitHub.com, VS Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse, Neovim, and more. Launched in 2021 as a completion tool, it has grown into one of the most widely adopted AI developer products and a flagship of Microsoft’s AI strategy.

Copilot serves the full buyer spectrum: individual developers and students on self-serve plans, small and mid-market teams on Copilot Business, and large organizations on Copilot Enterprise (available on GitHub Enterprise Cloud). It competes directly with Cursor, Codeium/Windsurf, Amazon Q Developer, and a growing field of agentic coding tools — but ships with the structural advantage of living inside the world’s largest code host and shipping pull requests, reviews, and Actions where developers already work.

Copilot’s pricing was remarkably static for its first three years — a single $10/month individual seat from late 2021 through 2024 — before changing structure four times in twelve months: a Free tier (December 2024), a Pro+ tier and premium-request metering (April 2025), and finally the dollar-denominated AI Credits model (June 2026). In that last move GitHub re-architected usage billing from a “premium request” quota system to GitHub AI Credits, a pool where 1 credit equals exactly $0.01 USD. That change aligned Copilot’s metered layer with the underlying token economics of the frontier models it routes to (Anthropic Claude, OpenAI GPT-5.x), while keeping bread-and-butter code completions unlimited and free of metering on every paid plan. The migration was the most contentious of Copilot’s history, drawing 767 points on Hacker News and press reports of projected 10×–50× cost increases for heavy agentic users.

Pricing summary : Per-seat subscription plus a dollar-denominated AI Credits pool

GitHub Copilot runs a hybrid pricing model: every plan carries a fixed per-seat subscription, and model-heavy features draw from a monthly GitHub AI Credits allowance where 1 credit equals $0.01 USD. The credit layer is a seat-plus-usage overage mechanism — once included credits run out, additional usage is billed at $0.01 per credit against a US-dollar budget.

• Seat fee — Free $0, Pro $10/mo, Pro+ $39/mo, Max $100/mo (individuals); Business $19/user/mo, Enterprise $39/user/mo (organizations).
• Included AI Credits — each plan bundles a monthly allowance split into Base credits (matched to the subscription price) and a variable Flex allotment. The pricing page now shows these as dollar totals: Pro $15/mo total ($10 base + $5 flex) · Pro+ $70/mo total ($39 base + $31 flex) · Max $200/mo total ($100 base + $100 flex) — i.e. 1,500 · 7,000 · 20,000 credits. Business 1,900/user · Enterprise 3,900/user (pooled).
• What consumes credits — Copilot Chat, Copilot CLI, Copilot cloud agent, Copilot Spaces, Spark, and third-party coding agents, priced by model and token count. Code completions and next-edit suggestions are excluded and stay unlimited on all paid plans.
• Credit expiry — included credits do not carry over; the allowance resets to the full monthly amount at 00:00:00 UTC on the 1st of each calendar month, independent of your subscription billing date.
• Overage — $0.01 per AI credit, capped by user-, organization-, cost-center-, and enterprise-level budgets.
• Rate modifiers — paid plans get a 10% discount on model costs while using auto model selection; data-resident and FedRAMP-compliant requests carry a 10% model-multiplier increase.
• Legacy track — annual Pro/Pro+ subscribers from before June 2026 remain on premium-request billing: 300 (Pro) or 1,500 (Pro+) requests/month, $0.04 per additional request, with per-model multipliers.

What makes this different: GitHub fused a transparent token pass-through ($0.01 = 1 credit) onto a per-seat SaaS plan while carving out completions as an unlimited, non-metered staple — so casual users feel a flat subscription and heavy agent users feel a usage meter.

Pricing by product

GitHub Copilot (Individual plans)

Copilot Student is free for verified students (unlimited code completions plus an AI Credits allowance, auto model selection only). The April 20, 2026 pause on new Pro/Pro+/Max/student sign-ups is no longer shown: the plans page now offers a self-serve “Get started” button on every individual tier, and the docs’ “temporarily paused” notice has been removed.

GitHub Copilot (Organization plans)

Promotional period (June 1 – September 1, 2026): existing Business customers receive 3,000 credits/user and existing Enterprise customers 7,000 credits/user before reverting to the standard 1,900 / 3,900. Overage beyond the pool is billed at $0.01 USD per AI credit. Data-resident and FedRAMP-compliant Copilot requests include a 10% model-multiplier increase. Since April 22, 2026, GitHub has paused new self-serve purchases (including self-serve trials) of Copilot Business and Copilot Enterprise; the docs describe self-serve sign-ups for credit-card/PayPal customers as “reopening soon,” but as of this check the Copilot for Business page still routes new organization customers to “Contact sales” with no self-serve purchase flow. List prices ($19 / $39 per user/month) are unchanged for existing subscribers.

GitHub AI Credits (usage layer)

Legacy premium-request billing (grandfathered annual plans)

Applies only to Copilot Pro and Copilot Pro+ subscribers on an existing annual plan who remained on legacy premium request-based billing after June 1, 2026. Additional premium requests are not available to users who subscribe(d) through GitHub Mobile on iOS or Android.

Sales motions across products: PLG / self-serve for Free, Pro, Pro+, and Max; Copilot Business and Copilot Enterprise are currently sales-led — new self-serve purchases of both have been paused since 2026-04-22 (contact sales), on top of the sales-assisted path large-volume Business deployments and Enterprise already used.

Hidden costs : What heavy agent and large-org Copilot usage actually adds up to

The seat fee is only the floor. The real bill is driven by how much agent, chat, and code-review work consumes AI credits beyond the included allowance — and by the 13× multiplier on code review under the legacy request model.

Archetype 1 — A heavy individual agent user on Pro+ ($39/mo). Pro+ includes 7,000 credits (= $70 of underlying model usage). A developer running multiple daily cloud-agent sessions on frontier models can exhaust that and rely on additional budget.

So a single power user can more than double their effective Copilot cost once agent sessions outrun the bundled credits — the meter, not the seat, sets the ceiling.

Archetype 2 — A 50-seat Copilot Business org with active code review. Fifty Business seats pool 95,000 AI credits (1,900 × 50). A team leaning on cloud agents and automated PR review across many repos can burn the pool and spill into per-credit overage.

At moderate agent and review intensity the metered overage can approach two-thirds of the seat spend — which is exactly why GitHub ships user-, cost-center-, and enterprise-level budget caps.

Want to estimate your own GitHub Copilot bill? Use the GitHub Copilot pricing calculator to model your monthly cost based on seats, included credits, and expected agent/chat usage.

Pricing evolution : From premium-request quotas to dollar-denominated AI Credits

For three years Copilot pricing barely moved — a single $10 individual seat from late 2021 through 2024. Then in twelve months it went through four structural shifts: a free tier, a Pro+ tier, premium-request metering, and finally the dollar-denominated AI Credits model. The chronology below is reconstructed from archived github.com/features/copilot pricing pages.

Cadence

Tracked range: 2021-12–2026-08. Quarters not listed were verified stable (0 price changes, 0 SKU additions) against archived pricing snapshots.

Notable changes

• 2021-06-29 — Copilot launched in free technical preview (2,905 points / 1,272 comments on Hacker News), immediately drawing a public-code-training controversy (“GitHub Copilot as open source code laundering?”, 1,028 points).
• 2021-12 — General availability at $10/mo / $100/yr for individuals; this single tier persisted unchanged through 2024.
• 2024-02 — Copilot Business ($19/user/mo) and Copilot Enterprise ($39/user/mo, GitHub Enterprise Cloud only) became generally available.
• 2024-12-18 — A $0 Free plan launched and Copilot Individual was renamed Copilot Pro (still $10/mo); the Free/Pro/Business/Enterprise grid is visible in archived January 2025 snapshots.
• 2025-04-04 — Copilot Pro+ ($39/mo) launched and premium-request metering appeared: Free 50, Pro 300, Pro+ 1,500 monthly premium requests at $0.04 per additional request, with per-model multipliers.
• 2025-06-18 — Enforcement of premium-request limits and paid overage began on GitHub.com (August 1, 2025 on GHE.com), after the enforcement date slipped from an originally-planned June 4.
• 2026-04-20 — New sign-ups for Pro, Pro+, Max, and student plans were temporarily paused (544 points / 230 comments on Hacker News); existing customers retained upgrade paths.
• 2026-04-22 — GitHub also paused new self-serve purchases of Copilot Business and Copilot Enterprise, including self-serve trials — two days after pausing individual sign-ups. New organization customers were directed to “Contact sales” instead of a self-serve checkout. Unlike the individual pause, which lifted after about ten weeks, this one was still in effect at the most recent check (2026-08-27), more than four months after it began.
• 2026-06-01 — GitHub AI Credits (1 credit = $0.01 USD) replaced premium requests; individual plans gained Base + Flex allowances, the Max tier ($100/mo) launched, and organizations gained pooled per-user credits with $0.01/credit overage.
• 2026-06-29 — The sign-up pause was lifted. The “New plan sign-ups are temporarily paused” banner still sat on every paid individual tier in the June 2, 2026 capture and is absent from every capture since June 29; the matching docs notice is gone and Free, Pro, Pro+ and Max all carry a self-serve “Get started” button again. No price or allowance moved, so the effect is purely on distribution: Copilot’s product-led front door reopened after roughly ten weeks in which only existing customers could move between tiers.

The usage-based-billing migration in detail

The June 2026 switch reframed usage from an opaque “request” count — where a single chat and a multi-file agent session both counted as “one request × a model multiplier” — to a token-priced dollar pass-through. Under AI Credits, every interaction’s token cost (input, output, cached) is priced per model and converted at 1 credit = $0.01 USD.

GitHub’s April 27, 2026 announcement drew the loudest pricing reaction of Copilot’s history — 767 points and 553 comments on Hacker News — because the new model also removed the old safety net: when premium requests ran out, Copilot used to fall back to a lower-cost base model so work could continue; under AI Credits, credit-consuming features simply stop until the budget resets or is topped up. Press coverage reported power users projecting 10×–50× monthly cost increases for heavy agentic workflows (e.g. $50 → $3,000 in worst-case projections) once the fallback was removed. To soften the transition, annual Pro/Pro+ subscribers who were mid-term were left on the legacy request model rather than force-migrated, so two billing systems now run in parallel through the annual cycle.

The sign-up pause reads as part of the same operation rather than a separate event. GitHub closed the individual front door on 2026-04-20, one week before the 2026-04-27 migration announcement, and reopened it on 2026-06-29 — four weeks after AI Credits went live. For that window, every net-new individual would have been onboarded onto a meter that was already scheduled for replacement, then migrated within weeks; pausing acquisition avoided selling a dying SKU and kept the noisy transition confined to the existing base. The reopening is the signal that GitHub now considers the credit meter, its budget controls, and its support load stable enough to put back in front of unknown-usage strangers. It also removes the awkward state where Max — the tier that most needs a running start on credits — could only be reached by upgrading from a plan you already held.

The organization side tells a different story, and it hasn’t resolved yet. GitHub paused new self-serve purchases of Copilot Business and Copilot Enterprise on 2026-04-22 — two days after the individual pause, five days before the migration announcement — but where the individual pause lifted after roughly ten weeks, the org-level pause was still in effect at the most recent check (2026-08-27), over four months on. New Business and Enterprise customers are routed to “Contact sales” rather than a self-serve checkout, even though list prices ($19 and $39 per user/month) haven’t moved. One reading is that GitHub is using the sales conversation to walk new org buyers through AI-Credit budgeting — pooled allowances, cost-center caps, enterprise spending limits — before they commit seats at scale, since a system that took individual users weeks to adjust to is harder to self-serve correctly when someone is provisioning hundreds of seats at once. Another reading is simply that reopening org self-serve is a lower priority than reopening the individual funnel that drives Copilot’s top-of-funnel growth. Either way, “reopening soon” has now outlasted the individual pause by a wide margin, and GitHub has not published a reason or a date.

What’s unique : Unlimited completions, dollar-denominated credits, org-pooled allowances

Completions stay unlimited and unmetered. Unlike token-metered competitors, GitHub carves out code completions and next-edit suggestions from credit billing entirely — they are unlimited on every paid plan. The meter only applies to chat, agents, review, CLI, and Spaces, so the staple workflow never produces a surprise bill.

1 credit = $0.01 USD is a literal pass-through. GitHub priced its usage unit at an exact penny, so customers can reason about model spend in dollars. The “credit” abstraction exists mainly to absorb per-model token-rate differences without exposing raw token prices.

Base + Flex split builds in adjustability. Each allowance splits into Base credits (fixed, matched to the seat price) and a Flex allotment GitHub can re-tune “as the economics of AI evolve.” That gives GitHub a lever to keep margins stable as model prices move, without changing the headline seat price.

Organization credits are pooled, not per-seat-locked. Business and Enterprise credits aggregate at the billing-entity level — 100 Business seats share a 190,000-credit pool — so heavy users draw from light users automatically, with budget controls to govern the draw.

Strengths & weaknesses

Billing UX : Budgets, pooled credits, and granular spend controls

• GitHub AI Credits usage dashboard — shows available allowance and consumed credits across IDE, GitHub.com, and CLI in one view.
• User-level budget (ULB) — caps how many AI credits a single user can consume per cycle across both pool and metered phases; always a hard stop (a $0 budget blocks the user immediately).
• Universal vs individual user-level budgets — a default budget applied to every licensed user, overridable per power user.
• Cost center budgets — cap metered charges for a defined group of users or an organization; only active once the shared pool is exhausted.
• Cost center included-usage cap — caps how much of the shared pool a cost center can draw. The cap is computed from the licenses assigned to its members (1,900 credits per Copilot Business license, 3,900 per Copilot Enterprise license), so 10 Business + 5 Enterprise licenses gives a 38,500-credit cap. The cost center home page shows “AI credit pool enabled” plus credits consumed against the cap.
• Organization-level budgets — cap metered charges for users whose Copilot seats are billed to the organization, after the pool is exhausted.
• Enterprise spending limit — caps total metered charges across the entire enterprise after the pool is spent; can block a user before their own user-level budget runs out.
• Additional-usage budget (US dollars) — set a dollar cap for overage; credits draw it down at $0.01 each (a $10 budget = 1,000 credits).
• Pooled credit allocation — org allowances aggregate at the billing-entity level (100 Business users = a shared 190,000-credit pool); adding licences mid-cycle grows the pool immediately, removing them takes effect at the start of the next billing cycle.
• Per-feature SKU attribution — Spark and Copilot cloud agent premium usage are tracked in dedicated SKUs for cost visibility.
• In-product upgrade prompt — as an individual approaches their limit Copilot offers an upgrade priced at only the difference between the current and new plan, with earlier usage counted inside the larger allowance rather than double-billed.
• No automatic model downgrade — GitHub documents that there is no fallback to lower-cost models when a budget is exhausted; credit-consuming features stop until the pool resets or budget is added.

Strategic wins : Why unlimited completions and a penny-credit unit landed

1. Carving completions out of the meter removed the biggest adoption blocker

By keeping code completions unlimited and never billing them in credits, GitHub ensured the highest-frequency, lowest-margin interaction never triggers a bill. That makes the seat price feel flat for typical users while still metering the expensive agent workloads — a clean answer to the bill-shock problem that plagues pure token meters.

2. The $0.01 = 1 credit unit made usage legible in dollars

Pricing the credit at exactly a penny turned an abstract usage unit into a transparent dollar pass-through, so customers can map model spend directly to budget. It is a textbook example of choosing a value metric buyers can actually reason about. The shift from request quotas to dollar-denominated credits mirrors the broader entitlement-to-credits billing shift sweeping AI products.

3. Org-pooled credits plus four budget levels gave finance real control

Pooling credits across the billing entity and layering user, cost-center, and enterprise budgets means a CFO can cap Copilot spend without blocking the whole team. That governance story is what lets large orgs adopt usage-based billing without fear of runaway invoices.

4. The Base + Flex split future-proofs margins

Splitting each allowance into a fixed Base and a variable Flex layer lets GitHub absorb swings in model pricing by re-tuning Flex, instead of repricing seats every time Anthropic or OpenAI change token rates.

5. Pausing acquisition through the meter swap, then reopening it

Closing new individual sign-ups on 2026-04-20 — a week before announcing the migration — and reopening them on 2026-06-29, four weeks after AI Credits shipped, meant no customer was sold onto the premium-request meter only to be migrated off it weeks later. The cost was roughly ten weeks of net-new individual acquisition; the benefit was that the pricing migration only ever had to be explained to an existing base with existing usage history, not to strangers forming their first impression of the product. Reopening self-serve on all four tiers is the clearest signal GitHub has given that it now trusts the credit meter and its budget controls under unknown-usage traffic. That trust hasn’t extended to the org side yet: self-serve purchases of Copilot Business and Enterprise, paused on 2026-04-22, remained closed as of 2026-08-27.

Areas to improve : Dual billing systems, Flex opacity, and review-multiplier surprises

1. Collapse the dual billing systems faster

Running AI Credits and legacy premium requests in parallel for annual subscribers is confusing and support-heavy. GitHub should publish a clear conversion path and target date so no customer has to learn two metering models at once — a lesson other vendors mid-pricing migration should heed.

2. Make the Flex allotment more predictable

Because Flex is explicitly variable, customers can’t fully forecast included usage. A published change-notice window (e.g. 60 days before any Flex reduction) would preserve trust while keeping the adjustability lever.

3. Surface the code-review multiplier before it bites

The legacy 13× multiplier on code review can drain a request allowance fast for teams that review every PR. An in-product estimate (“this will consume ~13 requests”) at review time would prevent silent burn-down.

4. Publish the Free tier’s actual credit allowance

Pro, Pro+ and Max each carry an exact number on the plans page ($15 / $70 / $200 of monthly total credits). Free carries only “limited chat and agent usage” — so the one tier used to evaluate whether Copilot is worth paying for is the one whose included usage a buyer cannot check, forecast, or compare against a rival’s free tier. Now that the self-serve funnel is open again (2026-06-29), that gap sits directly on the conversion path: a developer who hits an invisible ceiling learns the limit by being stopped rather than by reading it. Publishing a credit figure for Free would cost GitHub nothing structurally — the Base + Flex mechanic already gives it room to re-tune the number — and would make the free-to-paid step legible.

5. Bring back a graceful degradation path

The biggest driver of the 767-point Hacker News backlash to the April 2026 usage-based-billing migration was that AI Credits removed the old fallback — once premium requests ran out, Copilot used to drop to a cheaper base model so work could continue; now credit-consuming features simply stop. Press reported power users projecting 10×–50× cost jumps. A default “downgrade to base model on budget exhaustion” toggle would preserve continuity and defuse most of the bill-shock anxiety the change created.

6. Explain why the Business/Enterprise self-serve pause is still open after four months

GitHub paused new self-serve purchases of Copilot Business and Copilot Enterprise on 2026-04-22 — two days after pausing individual sign-ups — and, unlike the individual pause (lifted 2026-06-29 after roughly ten weeks), it was still in effect at the most recent check (2026-08-27), over four months in. The docs still describe self-serve as “reopening soon,” but for org buyers — including small teams that would once have self-served a Business seat block — that language has stopped functioning as a real timeline. Publishing either a reopening date or a stated reason (for example, changes to how AI-Credit budgeting is configured for new orgs) would turn an open-ended pause into a legible rollout status instead of a silent stall that erodes the same trust GitHub is trying to rebuild after the April usage-based-billing migration.

Key takeaways

1. Exempt the staple workflow from metering. GitHub keeps code completions unlimited and unbilled so the most frequent interaction never causes bill shock — meter only the expensive, high-variance work.
2. Denominate usage units in real money. Pricing a credit at exactly $0.01 makes usage legible and defensible; abstract units that don’t map to dollars erode trust.
3. Split included usage into fixed + variable layers. A Base (fixed) plus Flex (adjustable) allowance lets you absorb upstream cost swings without repricing the headline seat.
4. Pool usage at the buying entity, not the seat. Org-wide credit pools let power users borrow from light users and make per-seat pricing feel generous without raising the rate.
5. Give finance multi-level budget caps. User, cost-center, and enterprise budgets are what make usage-based overage acceptable to buyers wary of runaway bills.

UBP implications

1. Hybrid seat + usage is the default for AI dev tools. Copilot, like Cursor, pairs a predictable seat with a metered pool — confirming that buyers want baseline predictability plus pay-for-power upside.
2. Carve-outs shape perception more than headline price. By exempting completions, Copilot lets most users perceive a flat subscription even though a meter exists underneath — a powerful packaging move for any usage model.
3. Transparent unit economics build durability, but pooled usage-based billing raises the sales-assistance bar for orgs. A penny-per-credit pass-through ties the vendor’s price to model cost so directly that customers accept usage billing as fair, easing the path for outcome- and consumption-based models across the category — yet a pooled-credit system with multi-level budgets is harder to get right self-serve on day one than a flat per-seat plan. GitHub routing every new Business/Enterprise buyer to sales since 2026-04-22, a pause still open four months later, suggests usage-based pricing for organizations may need a guided setup step flat per-seat plans never required.

Sources

• GitHub Copilot plans & pricing (accessed 2026-07-22)
• Plans for GitHub Copilot — plan comparison (docs) (accessed 2026-07-22)
• About individual GitHub Copilot plans (docs) (accessed 2026-07-22)
• Billing for GitHub Copilot in organizations and enterprises (docs) (accessed 2026-07-22)
• Usage-based billing for individuals (docs) (accessed 2026-07-22)
• Usage-based billing for organizations and enterprises (docs) (accessed 2026-07-22)
• Requests in GitHub Copilot — premium requests (docs) (accessed 2026-07-22)
• Budgets for usage-based billing (docs) (accessed 2026-07-22)
• Copilot for Business (accessed 2026-07-22)
• Browse the full pricing blueprint corpus for peer comparisons.

Bottom line

GitHub Copilot in 2026 is a textbook hybrid: a per-seat subscription wrapped around a dollar-denominated AI Credits pool, with the highest-frequency workflow — code completions — deliberately kept unlimited and unmetered. The penny-per-credit pass-through, Base-plus-Flex allowances, and four-level budget controls show how to make usage billing feel fair and governable at developer, team, and enterprise scale. See how it compares across the pricing blueprint corpus.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Self-serve sign-ups reopen on every individual tier

Jun 2026

GitHub lifted the April 20, 2026 pause on new individual sign-ups. The 'New plan sign-ups are temporarily paused' banner is present in June 2, 2026 captures and gone from every capture since June 29, the matching docs notice was removed, and Free, Pro, Pro+ and Max each show a self-serve Get started button again. No price moved — Free $0, Pro $10, Pro+ $39, Max $100 — so this reopens distribution rather than repricing it.

GitHub AI Credits replace premium requests

Jun 2026

On June 1, 2026, Copilot moved usage billing from premium requests to GitHub AI Credits (1 credit = $0.01 USD). Individual plans got Base + Flex credit allowances (Pro 1,500, Pro+ 7,000, Max 20,000 total); the new Max tier launched at $100/mo (upgrade-only while sign-ups were paused); Business and Enterprise got pooled allowances (1,900 and 3,900 per user) with $0.01/credit overage. Existing annual Pro/Pro+ stayed on legacy premium-request billing.

Usage-based-billing migration announced

Apr 2026

GitHub announced (April 27, 2026) that premium request units would be replaced by GitHub AI Credits on June 1, 2026 and that annual Pro/Pro+ plans would be retired at term end. The announcement drew 767 points / 553 comments on Hacker News and press reports of projected 10×–50× agentic cost increases for power users.

Self-serve purchases of Business and Enterprise paused

Apr 2026

Two days after pausing individual sign-ups, GitHub also paused new self-serve purchases of Copilot Business ($19/user/mo) and Copilot Enterprise ($39/user/mo), including self-serve trials; new organization customers are directed to 'Contact sales.' List prices and existing subscriptions were unaffected. Unlike the individual pause, which lifted on 2026-06-29, this one was still in effect at the most recent check (2026-08-27) — over four months after GitHub's docs first described it as 'reopening soon.'

New individual sign-ups paused

Apr 2026

From April 20, 2026, new sign-ups for Copilot Pro, Pro+, Max, and student plans were temporarily paused to protect experience quality; existing customers could still upgrade between tiers. The change drew 544 points / 230 comments on Hacker News.

Premium-request billing enforced

Jun 2025

Enforcement of premium-request limits and paid overage began June 18, 2025 on GitHub.com (August 1, 2025 on GHE.com), after the cap-enforcement date slipped from June 4. Paid plans kept their allowances (300 Pro, 1,500 Pro+) with $0.04 per additional request.

Pro+ tier ($39) and premium requests introduced

Apr 2025

Copilot Pro+ launched at $39/mo ($390/yr) and premium-request metering appeared: Free 50, Pro 300, Pro+ 1,500 monthly premium requests, with additional requests at $0.04 each and per-model multipliers. Archived pricing pages from May 2025 confirm the new tier and meter.

Free tier launches; Individual renamed Pro

Dec 2024

GitHub added a $0 Free plan (2,000 completions + 50 chat/agent requests per month) and renamed Copilot Individual to Copilot Pro (still $10/mo). The archived pricing page shows the Free/Pro/Business/Enterprise grid by January 2025.

Copilot Business ($19) and Enterprise ($39) ship

Feb 2024

By February 2024 the org tiers were live: Copilot Business at $19/user/mo and Copilot Enterprise at $39/user/mo (GitHub Enterprise Cloud only), alongside the $10 Individual plan — a clean three-step seat ladder with no usage metering.

General availability at $10/mo for individuals

Dec 2021

Copilot reached general availability for individuals in late 2021 at $10/month or $100/year, with free access for verified students, teachers, and popular open-source maintainers. This single individual tier persisted unchanged through 2024.

Copilot launches in technical preview

Jun 2021

GitHub Copilot launched as a free technical preview on June 29, 2021. The launch (2,905 points / 1,272 comments on Hacker News) was immediately followed by a 'code laundering' controversy over training on public GitHub code.