Categories AI and Tools

GitHub Copilot Pricing 2026: What $10 Actually Buys You

GitHub Copilot still costs $10 a month for Pro. That number hasn’t moved. What changed — on June 1, 2026 — is what the $10 buys. Copilot stopped counting “premium requests” and started metering chat and agent work in GitHub AI Credits, one cent each, burned at whatever rate your chosen model charges per token. The sticker price is now the floor, not the bill.

And today, November 16, 2026, the ground shifts again: three models — Claude Opus 4.8, Claude Opus 5, and GPT-5.6 Terra — retire from Copilot entirely. If your workflow is pinned to one of them, your picker changes this morning whether you like it or not.

This guide walks through every Copilot plan as it stands on November 16, 2026, what an AI credit actually buys, what your real monthly bill looks like at five different usage levels, and how Copilot stacks up against Claude Code and Cursor now that all three have reshuffled their pricing this fall. All prices are US list prices before tax, checked against GitHub’s own plans page and multiple trackers in November 2026 — and prices here move often, so confirm on GitHub’s plans page before you buy.

What changed on June 1, 2026 — and why your bill is a meter now

Before June, Copilot’s paid plans worked on premium requests: a fixed monthly count of fancy-model prompts, with a multiplier per model. On June 1, 2026, GitHub replaced that system with GitHub AI Credits on every monthly plan. One credit is worth $0.01 of metered usage, consumed by the actual tokens your prompts use — input, output, and cached tokens — at each model’s published API rate.

Two things did not change, and they matter more than the new billing unit. First, code completions and next-edit suggestions are still unlimited on paid plans and cost zero credits. If Copilot is mostly autocomplete for you, the credit system barely touches your day. Second, the sticker prices didn’t move: Pro stayed $10, Pro+ stayed $39, Business stayed $19 a seat, Enterprise stayed $39 a seat. What changed is that the meter now runs on the work that actually costs GitHub money — chat, agent mode, the CLI, the cloud agent, code review, Spaces, and Spark.

There’s one wrinkle worth knowing before you do any math: every plan’s allowance is split into base credits and flex credits. Base credits equal the plan’s price and never change. Flex is a top-up GitHub says may change over time as model economics shift. On Pro, 500 of your 1,500 credits are flex. On Pro+, 3,100 of 7,000 are flex. On Max, half the allowance — 10,000 of 20,000 — is flex. So the headline allowance is real today, but the flex portion is the part GitHub can trim later without touching the price.

One more group is on a different system entirely. If you pay Pro or Pro+ annually, you stay on the old premium-request billing until your plan expires — 300 requests a month on annual Pro, 1,500 on annual Pro+, with extra requests at $0.04 each and model multipliers on top. At renewal you move to credits.

Every GitHub Copilot plan, and what each one actually includes

Plan Price Monthly AI credits Who it’s for
Free $0 Limited chat and agent use Trying Copilot out
Pro $10/mo ($100/yr) 1,500 (1,000 base + 500 flex) One developer, a selection of models
Pro+ $39/mo 7,000 (3,900 base + 3,100 flex) Daily agent users, premium models
Max $100/mo 20,000 (10,000 base + 10,000 flex) All-day agent workflows, priority access
Business $19/seat/mo 1,900 pooled per seat Small teams
Enterprise $39/seat/mo 3,900 pooled per seat Larger orgs, admin controls

A few details that change the value of each row:

Free is genuinely usable now. It includes 2,000 code completions a month plus limited chat and agent use, and the Copilot CLI is included. Students get a free plan too. Free is the right way to find out whether you even like working with an agent before you spend anything.

Pro is the autocomplete plan. You get unlimited completions, the CLI, agent mode, the cloud agent, and code review — but only a selection of models. As of November 2026 that selection includes Claude Sonnet 5.5, GPT-6.1 Terra, Gemini 3.8 Flash, and Grok 4.7. What it doesn’t include is the frontier tier: no Claude Opus, no Claude Fable, no GPT-6.1 Sol, no Gemini 4 Argon or Carbon.

Pro+ is the cheapest way to the frontier models. That’s the single most important fact about this tier. Pro+ is the lowest individual plan that unlocks Claude Opus 5.5, Claude Fable 5.1, and GPT-6 Sol, plus audit logs. The $29 jump from Pro buys you $55 more in credits ($70 of usage for $39) and the models that do the hardest work.

Max is for people who run agents most of the day. At $100 a month it includes $200 of usage and priority access to premium models when demand is high. It’s the only individual tier where the allowance is big enough that most developers stop thinking about the meter at all.

Teams pool their credits. On Business and Enterprise, each seat’s credits go into a shared organizational pool, and admins decide whether paid overage is allowed. If it isn’t, Copilot pauses for the heavy user until the next cycle — which is worth knowing before one teammate’s agent session eats the whole team’s month. Since October 28, 2026, eligible enterprises buying through an account team can also get Copilot included with GitHub Enterprise at $0 a seat plus metered use, or as a $10-per-user standalone.

The ladder gets better value as you climb: Pro returns 1.5x its price in credits, Pro+ about 1.8x, Max 2x.

What an AI credit actually buys

Here’s the part most pricing pages skip: a credit is a cent, but a task costs whatever its tokens cost. GitHub publishes per-model API rates, and your credit burn follows them. A few rates from GitHub’s rate card, verified November 13, 2026:

Model Input (per 1M tokens) Cached input Output (per 1M tokens)
Claude Opus 5.5 $4.00 $0.20 $20.00
Claude Opus 4.8 $5.00 $0.50 $25.00
GPT-5.6 Terra $2.00 $0.20 $12.00

Output tokens cost roughly five times input tokens, which is why long agent sessions — where the model writes thousands of lines across multiple turns — burn credits far faster than short questions. A heavy agent session on Opus 5.5 with, say, 100,000 input tokens and 20,000 output tokens costs $0.40 of input plus $0.40 of output: $0.80, or 80 credits. Run eighteen sessions like that in a month and you’ve spent Pro’s entire 1,500-credit allowance. Run them on a lighter model and the same work costs a fraction of that.

An independent measurement puts real numbers on the lighter end. Sidehub, testing on November 3, 2026, measured an average Copilot CLI run at 15.9 AI credits — about $0.16 — using Claude Haiku 4.5 as the default model, against $0.19 per run for Claude Code on Opus 5.5 at API prices. At that burn rate, Pro’s 1,500 credits cover roughly 94 CLI runs a month. Your mileage will vary with the model you pick and how long your conversations run, but the shape of it is right: light models stretch the allowance a long way, frontier models eat it in big bites.

Three habits decide how far your credits go:

  1. Let Copilot pick the model. Paid plans get a 10% discount on model costs when you use automatic model selection in Chat, the CLI, and the cloud agent. It’s free money, and it also routes simple tasks to cheaper models automatically.
  2. Don’t park agent mode on a frontier model. Long conversations re-read context every turn, and agent mode fans out into multiple model calls per task. That’s where the meter spins. For routine refactors, a lighter model does the same job for a tenth of the credits.
  3. Watch the flex share. Remember that a third of Pro’s allowance, nearly half of Pro+’s, and half of Max’s is flex — GitHub can adjust it. If your usage sits right at the edge of your plan, you’re one flex adjustment away from overage.

The real monthly bill: five developers, five answers

Sticker prices lie by omission. Here’s what the same five usage levels cost on each individual plan, at $0.01 a credit for overage. These are worked examples with stated assumptions, not quotes — your token mix will differ, but the break-even points are the useful part.

Monthly usage Pro ($10) Pro+ ($39) Max ($100) Cheapest
500 credits — autocomplete + occasional chat $10 $39 $100 Pro
1,500 credits — light agent use $10 $39 $100 Pro
3,000 credits — regular agent mode $25 ($10 + $15 overage) $39 $100 Pro
4,000 credits — heavy agent use $35 ($10 + $25 overage) $39 $100 Pro, barely — Pro+ wins on models
8,000 credits — agent-first workflow $75 ($10 + $65 overage) $49 ($39 + $10 overage) $100 Pro+
15,000 credits — agents all day $145 $119 ($39 + $80 overage) $100 Max

Two break-even points do the deciding for you. The Pro-to-Pro+ switch pays off once your overage on Pro would run past about $29 a month — roughly 4,400 credits of monthly use. Below that, stay on Pro and pay the overage; above it, Pro+ is cheaper and hands you the frontier models as a bonus. The Pro+-to-Max switch pays off at about $61 of overage on Pro+ — roughly 13,100 credits a month. If you’re not near those lines, don’t upgrade on speculation. Set a small overage budget first — a $10 top-up buys 1,000 credits and beats a $29 jump to Pro+ for a spike that happens one week a quarter.

For teams, the math is simpler and harsher: a 10-person team on Business costs $190 a month before any extra usage, with 19,000 pooled credits. One developer running Opus 5.5 agents all day can drain a noticeable share of that pool, so the admin’s overage setting is a real budget decision, not a toggle to ignore.

What happens when you run out of credits

You have three options, and GitHub spells them out in its billing docs:

  1. Set a dollar budget and keep working. Extra usage bills at $0.01 a credit, so $10 buys another 1,000 credits. GitHub sends alerts at 75%, 90%, and 100% of any budget you configure, and your Copilot settings page shows usage and the reset date. This is the right answer for a spike.
  2. Switch to a lighter model. GitHub’s own advice is that lightweight models use fewer credits per interaction. A Sonnet or Haiku session costs a fraction of an Opus one, and for many tasks the output is indistinguishable.
  3. Wait for the reset. Unused credits don’t roll over — they reset at 00:00 UTC on the first of every month, and the reset date doesn’t shift with your billing date. Subscribe on the 25th and your first allowance resets a week later. That’s the one that catches new subscribers by surprise.

On Business and Enterprise, the admin controls whether paid overage is even possible. If it isn’t, you see a banner offering to request more budget from your administrator, and Copilot pauses until the next cycle. And one limitation to know: you can’t buy additional credits at all if you subscribed through GitHub Mobile on iOS or Android — that billing path doesn’t support it.

Three models retire today — what to switch to

Today, November 16, 2026, GitHub retires three models across every Copilot experience — Chat, inline edits, ask and agent modes, and code completions:

Retiring today Suggested replacement
Claude Opus 4.8 Claude Opus 5.5
Claude Opus 5 Claude Opus 5.5
GPT-5.6 Terra GPT-6.1 Sol or GPT-6 Luna

This is the third wave in ten weeks. GitHub retired four models on October 2 and six more on October 19, and a fourth wave is already scheduled for December 14, 2026 — Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon, Grok 4.6, and Kimi K3. That’s 19 models retired or scheduled in about ten weeks, and the churn is the new normal, not a one-off cleanup.

Two details matter for your bill. First, the replacements are cheaper to run than what they replace: GitHub’s own tracking shows a typical agent session dropping from about 22.5 credits on GPT-5.5 to about 16 on GPT-6.1 Sol. Second, there’s one exception to today’s retirements — individual subscribers on annual plans keep Claude Opus 4.8, so they retain an Opus offering on the old premium-request billing. Everyone else loses it.

If your workflow pins a model ID — in a config file, a team policy, or a CI setup — grep for the retiring names before the end of the day. On Business and Enterprise, admins may also need to enable the replacement model in the model policy before developers can see it. And watch out for one naming trap: GPT-5.6 Terra retires today, but GPT-6.1 Terra is a different, newer model that stays. They are not the same thing, and mixing them up is an easy way to pin the wrong model.

For the full retirement timeline and the model-by-model mapping, our companion piece has the details: GitHub Copilot retires 3 models today — what to switch to.

Copilot vs Claude Code vs Cursor: the verdict after the fall reshuffle

All three tools changed their pricing this fall, so last spring’s comparison is stale. Here’s where they stand in November 2026.

Claude Code comes with a Claude Pro subscription at $20 a month ($17 billed annually), or Claude Max at $100 or $200. Instead of credits, you get usage limits per five-hour session, with the same Opus, Sonnet, and Haiku models as Pro — Max buys more usage, not smarter models. In Sidehub’s November 3 head-to-head, a Copilot CLI run cost about $0.16 in credits against about $0.19 for Claude Code at API prices — close enough that the choice is about workflow, not price. Pick Claude Code if you live in the terminal and want the deepest Claude integration; pick Copilot Pro at $10 if you want the same models inside your editor for half the subscription price.

Cursor changed the most. On October 12, 2026, new buyers stopped getting the old $20 Pro plan and started getting The X Subscription, shared with Grok and X Premium: Free, Plus at $8 a month, Premium at $30, Super at $100, and Ultra at $200, with one weekly usage pool shared between Cursor and Grok. The catch is the models: Plus runs Grok models only, and on Premium and up, Claude and GPT inside Cursor bill separately at API list prices. Existing Pro ($20), Pro+ ($60), and old Ultra ($200) subscribers keep their plans. Our full breakdown is here: X Subscription explained — Cursor, Grok, and X Premium plans.

The honest comparison, in one table:

Copilot Pro Claude Pro (Claude Code) Cursor Premium
Subscription $10/mo $20/mo ($17 annual) $30/mo
Meter 1,500 AI credits/mo Per-session usage limits Weekly pool + API billing for Claude/GPT
Frontier models Pro+ ($39) and up Included Billed separately at API rates
Best for Editor-first devs who want the cheapest entry Terminal-first devs who want Claude Grok users who also want Cursor

Copilot is now the cheapest way into a frontier-model coding agent if you count the total bill: $10 for Pro, $39 for Pro+ with Opus 5.5 included. Claude Code costs twice the Pro subscription but charges nothing per token inside its session limits. Cursor Premium looks comparable at $30 until you add the API bill for Claude on top — which is where its real cost hides.

Which plan should you actually pay for?

Run this test on your own usage before you upgrade:

  • Stay on Free if you’re evaluating Copilot or you code a few hours a week. The 2,000 free completions tell you whether you like it.
  • Buy Pro ($10) if Copilot is mostly autocomplete with some chat, and your usage dashboard still has credits left at month-end. The 1,500 credits cover light agent use, and a $10 overage budget handles spikes.
  • Move to Pro+ ($39) if agent mode, the CLI, or the cloud agent empties Pro’s credits most months, or if you need Opus 5.5, Fable 5.1, or GPT-6 Sol for real work. The break-even is about $29 of monthly overage on Pro.
  • Move to Max ($100) if Pro+ still empties mid-month on real agent weeks — roughly 13,100 credits a month of use — or you need priority access to premium models at peak times.
  • Don’t upgrade on a hunch. Check your usage dashboard first. If you can’t see your credit burn, you’re guessing, and guessing is how a $10 tool becomes a $100 subscription.

One last thing, and it’s the one that would have saved me a headache: your credits reset on the 1st of the month at midnight UTC, not on your billing date. If you sign up on November 28, you get three days of allowance before it resets. Start on the 1st if you can — or at least know the clock you’re on.

Frequently Asked Questions

How much does GitHub Copilot cost in 2026?

Individual plans are Free ($0), Pro at $10 a month, Pro+ at $39, and Max at $100. Business is $19 per seat per month and Enterprise is $39 per seat. Since June 1, 2026, chat and agent work is metered in GitHub AI Credits at $0.01 each, with a monthly allowance included in every paid plan. Code completions are unlimited on paid plans and don’t use credits.

What is a GitHub AI Credit worth?

One AI credit equals $0.01 of metered usage. Credits are consumed by the tokens your prompts use at each model’s published API rate, so a light model costs a fraction of a credit per interaction and a long frontier-model agent session can cost 80 credits or more. Unused credits reset at 00:00 UTC on the first of each month and don’t roll over.

Which Copilot plan is best for most developers?

Pro at $10 a month is the right plan for most individual developers: unlimited completions, the CLI, agent mode, and 1,500 credits a month cover light agent use. Move to Pro+ at $39 when your overage on Pro would regularly pass about $29 a month, or when you need the frontier models — Opus 5.5, Fable 5.1, and GPT-6 Sol — that Pro doesn’t include.

What happens when I run out of Copilot credits?

Set a dollar budget for extra usage at $0.01 a credit, switch to a lighter model, or wait for the monthly reset on the 1st. On Business and Enterprise plans, your admin decides whether paid overage is allowed; if it isn’t, Copilot pauses until the next cycle. You can’t buy extra credits if you subscribed through GitHub Mobile.

Which Copilot models are retiring in November 2026?

Claude Opus 4.8, Claude Opus 5, and GPT-5.6 Terra retire on November 16, 2026, replaced by Claude Opus 5.5 and GPT-6.1 Sol or GPT-6 Luna. A fourth wave follows on December 14, 2026, retiring Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon, Grok 4.6, and Kimi K3. Individual subscribers on annual plans keep Claude Opus 4.8.

Is Copilot Pro cheaper than Claude Code or Cursor?

On subscription price alone, yes: Copilot Pro is $10 a month against $20 for Claude Pro (which includes Claude Code) and $30 for Cursor Premium. The full comparison depends on usage — Claude Code charges no per-token fees inside its session limits, while Cursor Premium bills Claude and GPT separately at API rates on top of the $30. For editor-first developers who want frontier models included, Copilot Pro+ at $39 is the cheapest all-in option of the three.

Leave a Reply

Your email address will not be published. Required fields are marked *