How to Subscribe to GitHub Copilot 2026: Step by Step

Buying GitHub Copilot is not hard. Buying it correctly for a team is where people get stuck. The individual flow is four clicks. The organization flow involves a billing owner, a seat policy, sometimes an Azure subscription, and a cancellation path that behaves differently depending on whether you pay monthly or annually. This guide walks the whole thing, including the parts GitHub's own marketing pages skip.

One thing up front: I have not run this purchase flow myself. What follows is assembled from GitHub's billing and subscription documentation, the public pricing page, Azure billing docs, and the long trail of GitHub Community threads where people describe paying and then waiting for access. Where a number is not published, I say so rather than guess.

Before you subscribe: free tier vs paid check

GitHub ships a free Copilot tier. The docs describe it as including a monthly allowance of code completions and chat requests, with access to a limited set of models. The exact caps have moved more than once since launch, so check the current pricing page rather than trusting a blog post from last year — including this one, if you are reading it in 2027.

The honest question is not "is free enough" in the abstract. It is whether you hit the ceiling in a normal week. If you write code most days and lean on chat for explanations, refactors and test generation, the free allowance tends to run out before the month does. If you open Copilot a few times a week for autocomplete, it may not.

Signals that you should pay:

• You hit the completion or chat cap and the tool goes quiet mid-task.
• You want access to the higher-capability models, which the paid tiers include and free does not.
• You need Copilot in an IDE or surface that free does not cover.
• You are on a team and want one bill, one policy, and admin visibility.

Signals that you should not:

• You tried it for a week and stopped opening it. Paying will not fix that.
• Your employer already has a Business or Enterprise seat for you. Check before buying a personal one — you cannot stack them usefully.
• You only want occasional autocomplete. Free covers that.

If you are still undecided, the free tier is the correct place to start. It costs nothing and it tells you more about your own habits than any comparison table will.

Subscribe as an individual: exact click path

Individual plans are bought from your personal GitHub account. They are not tied to an organization, and they bill to you, not your employer.

The path, as the docs describe it:

1. Sign in to GitHub as the account that will own the subscription.
2. Go to your account settings, then the Copilot section.
3. Pick a plan. You will see the individual tiers side by side.
4. Choose monthly or annual billing. The toggle is on the same screen.
5. Confirm the payment method and complete checkout.

What you should expect on screen: a plan comparison with the feature differences spelled out, a billing period selector, and a payment form. If you have a saved card on the account, it is preselected. If you do not, you add one here.

Monthly vs annual. Annual is cheaper per month and locks you in for a year. Monthly costs more and lets you leave at the end of any month. If you are unsure whether you will still want this in six months, take monthly. The savings from annual only pay off if you actually stay, and the refund path for an unused annual term is not generous.

Payment methods and regional availability. GitHub accepts major credit and debit cards through its payment processor. Availability varies by country, and some regions have restrictions on which plans can be purchased at all. If checkout rejects your card, the cause is usually regional rather than a problem with the card itself. GitHub's docs list supported regions; check that list before you spend an afternoon on support tickets.

What you get immediately. The subscription activates on the account right away. Access in your editor depends on the editor picking up the new entitlement, which is usually fast but not instant. More on that below.

Subscribe as an organization: Business vs Enterprise

Organization plans are where the real decisions live. Two tiers, and the difference matters more than the price gap suggests.

Copilot Business is the standard team tier. It covers the core Copilot experience with organizational controls: policy management, the ability to exclude certain files or repositories from suggestions, and audit logging. It is aimed at companies that want Copilot available to engineers under a policy they control.

Copilot Enterprise adds the things large orgs ask for: integration with your knowledge bases, the ability to customize the model against your own repositories, and deeper enterprise-grade controls. It costs more per seat and is aimed at companies where Copilot is meant to understand internal context, not just general code.

I would not pick Enterprise for a ten-person startup. The extra capability is real but it is aimed at organizations with enough internal documentation and enough compliance surface to justify it. Business is the right default for most teams.

Seat minimums. GitHub's pricing page lists per-seat pricing for both tiers. Whether a minimum seat count applies depends on the plan and how you buy it; the docs are the authority here, and the number has changed over time. Check the current page rather than assuming.

Billing owner setup. This is the step people miss. An organization subscription needs a billing owner — an account with permission to manage payment. If your organization has no billing owner configured, or if the person who was billing owner has left, the purchase will stall. Set this up before you try to buy. It takes two minutes and saves a support thread.

SSO and SCIM. If your organization enforces SAML SSO, members must have linked their accounts before they can receive a seat. If you use SCIM provisioning, seats can be assigned automatically through your identity provider. Without SSO, you assign seats by hand. With it, you get the automated path but you also inherit the requirement that every user has an active, linked identity. A user who has never signed in through SSO cannot be given a working seat.

Azure billing path. Organizations can pay through Azure instead of a card on file. The Azure billing docs describe this as connecting the GitHub organization to an Azure subscription, after which Copilot charges appear on the Azure invoice. This is the path most enterprises take, because it puts the spend in the same place as the rest of their cloud bill and lets finance apply existing cost controls. It also means the person who can fix a billing problem is whoever administers the Azure subscription, not necessarily the GitHub org owner. Know who that is before you start.

Seat assignment and access propagation

Paying does not grant access. Assigning a seat does. These are separate steps and conflating them is the single most common source of "I paid but Copilot does not work" complaints.

For an organization, an admin assigns seats to members. Depending on your setup, this is either a manual selection in the organization's Copilot settings or an automatic assignment driven by SCIM groups. Once a seat is assigned, the member's account carries the entitlement.

Propagation is the part that generates forum threads. The entitlement lands on the GitHub account quickly, but the editor only sees it after it refreshes its auth state. In practice that means:

• The user may need to sign out of the editor and sign back in.
• The editor extension may need to be reloaded or updated.
• If the user was previously on a personal subscription, the editor may still be holding the old token.
• If SSO is enforced and the user has not linked their identity, no amount of reloading will help.

The fixes, in the order I would try them:

1. Confirm the seat is actually assigned. Not "we bought seats" — assigned to this specific user.
2. Confirm the user's GitHub account is the one the seat was assigned to. People have work accounts and personal accounts and mix them up constantly.
3. Sign out of the editor and back in.
4. Reload or update the Copilot extension.
5. If SSO is on, confirm the identity is linked and the session is fresh.
6. If it still fails, check whether a policy is blocking the user's organization membership from receiving Copilot.

Most of these resolve within minutes. A minority need an admin to re-save the seat assignment, which forces a re-sync.

Billing, invoices, and renewal traps

Three things bite people here: annual lock-in, mid-cycle seat changes, and proration.

Annual lock-in. If you buy annual, you are committed for the term. Downgrading mid-term does not refund the unused portion in the way people expect. The subscription runs to the end of the period and then changes. Budget accordingly — an annual purchase is a twelve-month decision, not a monthly one with a discount.

Mid-cycle seat changes. Adding seats mid-cycle generally bills for the remainder of the period. Removing seats does not usually produce an immediate credit; the reduction takes effect at renewal. This asymmetry is normal for seat-based SaaS and it is worth knowing before you buy fifty seats "just in case."

Proration. When you change plans or seat counts mid-term, GitHub prorates the difference. The direction of the proration depends on whether you are adding or removing. The docs describe the mechanics; the practical takeaway is that upgrades cost money immediately and downgrades save money later.

Invoices. Card-billed subscriptions produce receipts in the account's billing settings. Azure-billed subscriptions produce Azure invoices, and the GitHub side may show the charge without the same level of detail. If your finance team needs line-item detail per seat, the Azure path is usually easier for them and the card path is usually easier for you.

How to cancel or downgrade

Cancellation is straightforward, but what you lose and when you lose it depends on the plan.

For an individual subscription:

1. Sign in to the account that owns the subscription.
2. Go to the Copilot section of account settings.
3. Find the subscription and choose to cancel or downgrade.
4. Confirm. The change takes effect at the end of the current billing period.

For an organization subscription, an admin cancels from the organization's billing settings. If the organization pays through Azure, cancellation may also require action on the Azure side, or the charge may continue until the Azure subscription link is removed. Check both sides.

What you lose immediately vs at cycle end. Cancelling does not cut you off mid-period. You keep access until the period you paid for ends. What changes immediately is your ability to add seats or upgrade. What changes at cycle end is access itself — the account drops to the free tier, and any seats assigned to members stop working.

If you are downgrading from Enterprise to Business, the Enterprise-only features stop at the end of the term, not the moment you click. Plan the transition so nobody is mid-project on a feature that is about to disappear.

Cheaper ways to get the same capability

If the budget is the constraint, there are two honest routes.

Free alternatives. The free Copilot tier is the obvious one. Beyond that, several editors ship their own assistants, and some open-source completion models run locally. These are not equivalent to a paid Copilot seat — the model quality and the integration depth differ — but for autocomplete and simple chat they cover a lot of ground at zero cost.

Bring-your-own-key agents. This is the route that has grown fastest. Instead of paying a per-seat subscription, you run an agent in your editor and point it at a model API you pay for by usage. The economics are different: no seat fee, but you pay per token, and heavy use can cost more than a seat would. The live pricing data makes the spread clear. At the top end, openai/o1-pro lists at $150 per million input tokens and $600 per million output tokens, with a batch variant at $75 and $300. Mid-tier reasoning models like openai/o3-pro list at $20 in and $80 out. Cheaper general models sit far below that. A developer doing light agent work on a mid-tier model can come in under a seat price; a developer running long agent loops on a frontier model will not.

The tradeoff is operational. A per-seat subscription is one line item and zero configuration. A BYO-key setup means managing API keys, watching spend, and accepting that your editor's integration may be less polished than Copilot's. For a solo developer who wants control, that is often worth it. For a fifty-person org, it is usually not.

Beetlix is our own product, and it sits in this BYO-key space — worth mentioning only because if you are evaluating that route, it is one of the options to compare against a seat subscription. It is not a replacement for Copilot's IDE integration, and I would not frame it as one.

How this review was researched

This guide is built from GitHub's billing and subscription documentation, the public GitHub pricing page, Azure billing documentation, and GitHub Community threads where users describe seat propagation delays and billing surprises. No purchase was made and no account was tested for this article. Where a figure is not published by GitHub, the text says so instead of estimating. Pricing for third-party models comes from the live pricing snapshot available at the time of writing.

For related reading: how to use GitHub Copilot, the free tier explained, plan comparison for 2026, and what Copilot actually costs.