Copilot, Cursor, and Claude Code Pricing in 2026: Credits, Requests, and Usage Limits Compared

Comparing what GitHub Copilot, Cursor, and Claude Code cost is harder than comparing sticker prices, because each one measures usage in a different unit. Copilot sells credits worth a cent each, Cursor sells a weekly pool plus prepaid credit, and Claude Code draws on five-hour and weekly limits shared with Claude chat. This guide lays out each plan as the vendors document it, explains what happens at the limit, and gives you a script to compare total cost for your own usage.

Three different meters

The practical consequence: a dollar figure for “included usage” exists for Copilot (credits times $0.01), but Cursor and Anthropic do not state included usage as a dollar amount in the pages we read. Cursor gives multiples of its Plus plan, and Anthropic gives multiples of Pro. That is why a precise cost-per-token ranking across all three cannot be built from public pages, and why we compare total cost for your own usage instead.

GitHub Copilot

Per GitHub's documentation, 1 AI credit equals $0.01 USD, and base credits are used before the flex allotment, which GitHub describes as something that can change over time. Included credits do not carry over, and the allowance resets at 00:00:00 UTC on the first day of each calendar month. Business and Enterprise credits are pooled across the organization, and admins can set budgets; additional usage is enabled by default. Free and Student plans also receive a credit allowance through auto model selection. GitHub's announcement said all plans moved to usage-based billing on June 1, 2026, replacing premium request units. Full detail: Copilot rate limits and AI credits explained.

Cursor

As Cursor's documentation describes it, each paid plan has one weekly pool for Cursor models, shared across the editor, CLI, and cloud agents, and different models draw from the pool at different rates. Beyond the pool, Cursor models are billed at per-model rates per million tokens, and credit can be bought manually or by auto top-up, with a monthly additional usage limit capping paid overage. The documentation says requests are not downgraded in quality or speed when the pool runs out. Auto has a Cost mode on individual plans; Balance and Intelligence modes are for Teams and Enterprise. Legacy plans (Hobby, Start, Pro, Pro+, Ultra, and Teams Standard and Premium seats) continue for existing customers with two monthly pools and on-demand usage. The pricing page does not give dollar amounts for the legacy plans, so use Cursor's legacy plans page if you are on one.

Claude Code

Anthropic's support article says individual Pro, Max, and Ultra subscriptions include Claude Code, in the terminal and in supported IDEs, and that limits are shared across Claude and Claude Code. If you hit the five-hour limit mid-response, Claude Code can finish its current step and show “Usage limit reached · wrapping up”; that small allowance counts toward your weekly limit and is rolling out gradually. Anthropic may add other limits and does not guarantee uninterrupted service. One billing trap: if an ANTHROPIC_API_KEY environment variable is set, Claude Code authenticates with that key instead of your subscription and you pay API charges. See Top Claude Code errors.

What happens when you run out

• Copilot: upgrade (individuals pay only the price difference), set a budget for additional usage, or wait for the reset. Inline completions keep working.
• Cursor: a notification appears in the editor; continue on prepaid credit, wait for the weekly reset, or upgrade. Legacy plans: enable on-demand usage or upgrade.
• Claude Code: Pro can upgrade to Max, enable usage credits, use Console API credits, or wait. Max can move to Ultra or use the same options. Ultra can enable usage credits, use API credits, or wait. Use /status to check your remaining allocation.
• None of them roll over unused included usage. Cursor's prepaid credit is the exception, lasting until used or 365 days after purchase.

Compare total cost for your own usage

To compare plans, estimate your monthly usage as an API-equivalent dollar amount (what the same tokens would cost at API rates), then ask what each plan would cost you in total. The script below does that. Plans whose vendors do not state included usage in dollars are listed separately rather than ranked, and plans that hard-stop with no paid overage are reported as unable to cover heavy usage. Copilot is prefilled from GitHub's credit figures; for the others, enter a value only if you have a defensible estimate. Its tests run without any of the tools installed.

from dataclasses import dataclass
from typing import Optional

CREDIT_USD = 0.01        # GitHub: 1 AI credit = $0.01


@dataclass
class Plan:
    name: str
    monthly_price: float
    included_usd: Optional[float]      # API-equivalent value of included usage; None if the vendor does not state it
    overage_multiplier: float = 1.0    # extra usage billed at this multiple of API-equivalent cost
    can_buy_more: bool = True          # False if the plan hard-stops with no paid overage
    note: str = ""


def copilot(name: str, price: float, credits: int) -> Plan:
    return Plan(name, price, credits * CREDIT_USD, 1.0, True, "credits from GitHub billing docs")


def monthly_cost(plan: Plan, usage_usd: float) -> Optional[float]:
    """Total monthly cost for a given amount of API-equivalent usage, or None if it cannot be computed."""
    if plan.included_usd is None:
        return None
    extra = max(0.0, usage_usd - plan.included_usd) * plan.overage_multiplier
    if extra > 0 and not plan.can_buy_more:
        return None
    return round(plan.monthly_price + extra, 2)


def compare(plans, usage_usd: float) -> dict:
    priced, unknown, blocked = [], [], []
    for p in plans:
        if p.included_usd is None:
            unknown.append(p.name)
            continue
        c = monthly_cost(p, usage_usd)
        (priced if c is not None else blocked).append((p.name, c))
    priced.sort(key=lambda x: x[1])
    return {"ranked": priced, "unknown_included_usage": unknown, "cannot_cover": [n for n, _ in blocked]}


def break_even(a: Plan, b: Plan, max_usd: float = 2000.0, step: float = 1.0) -> Optional[float]:
    """Smallest usage (USD, API-equivalent) at which plan b becomes cheaper than plan a; None if it never does."""
    u = 0.0
    while u <= max_usd:
        ca, cb = monthly_cost(a, u), monthly_cost(b, u)
        if ca is not None and cb is not None and cb < ca:
            return u
        u += step
    return None

PRO = copilot("Copilot Pro", 10, 1500)          # $10 includes $15 of usage
PROPLUS = copilot("Copilot Pro+", 39, 7000)     # $39 includes $70 of usage


def test_credit_conversion():
    assert PRO.included_usd == 15.0
    assert PROPLUS.included_usd == 70.0


def test_cost_within_and_beyond_included_usage():
    assert monthly_cost(PRO, 10) == 10
    assert monthly_cost(PRO, 25) == 20.0          # $10 plan + $10 over
    assert monthly_cost(PROPLUS, 100) == 69.0


def test_hard_stop_plan_cannot_cover_overage():
    capped = Plan("capped", 20, 30, can_buy_more=False)
    assert monthly_cost(capped, 30) == 20
    assert monthly_cost(capped, 31) is None


def test_unknown_included_usage_is_never_ranked():
    unknown = Plan("vendor-without-numbers", 30, None)
    r = compare([PRO, PROPLUS, unknown], 40)
    assert r["unknown_included_usage"] == ["vendor-without-numbers"]
    assert [n for n, _ in r["ranked"]] == ["Copilot Pro", "Copilot Pro+"]


def test_ranking_changes_with_usage():
    light = compare([PRO, PROPLUS], 5)["ranked"]
    heavy = compare([PRO, PROPLUS], 100)["ranked"]
    assert light[0][0] == "Copilot Pro"
    assert heavy[0][0] == "Copilot Pro+"


def test_break_even_between_pro_and_pro_plus():
    be = break_even(PRO, PROPLUS)
    assert be is not None
    assert monthly_cost(PROPLUS, be) < monthly_cost(PRO, be)
    assert monthly_cost(PROPLUS, be - 1) >= monthly_cost(PRO, be - 1)


def test_break_even_none_when_never_cheaper():
    worse = Plan("worse", 50, 0)
    assert break_even(PRO, worse, max_usd=200) is None
    assert break_even(PROPLUS, PRO) == 0.0

The script's output is only as good as the usage estimate you give it. Track a typical month first, using Copilot's status dashboard, Cursor's usage view, and Claude's /status and Settings, Usage pages, before deciding.

How to choose without false precision

• Light, steady use (completions and occasional chat): Copilot's entry plan is the clearest, because completions are not billed in credits and the credit allowance is stated in dollars.
• Heavy agent use all day: compare the top tiers on limits, not just price. Claude's Ultra has no five-hour limit for verified accounts, Cursor's higher tiers scale the weekly pool, and Copilot's higher plans scale credits.
• You want predictable bills: prefer plans where overage is opt-in. Copilot additional usage needs a budget on individual plans, Cursor's overage needs prepaid credit, and Claude's needs usage credits to be enabled.
• Team purchasing: check pooling and admin controls. Copilot pools credits and offers user, cost center, and enterprise budgets; Cursor Teams matches each seat's tier; Claude Team and Enterprise are covered by separate Anthropic articles.
• Mixed use is normal. Many developers keep one tool for completions and another for agents. Compare combined cost, and see how the tools fail too.

If your own code calls model APIs directly, the cost levers are different; see the AI API cost optimization playbook.

Sources

• GitHub Docs: Usage-based billing for individuals
• GitHub Docs: Usage-based billing for organizations and enterprises
• The GitHub Blog: GitHub Copilot is moving to usage-based billing
• Cursor documentation: Models and pricing
• Cursor Help: Usage limits
• Claude Help Center: Use Claude Code with your Pro, Max, or Ultra plan
• Claude Help Center: What is the Pro plan?
• Claude Help Center: What is the Max plan?
• Claude Help Center: What is the Ultra plan?

Frequently asked questions

Keep reading