GitHub Copilot “You’ve Hit a Rate Limit” and AI Credits Quotas Explained

“You've hit a rate limit” sounds like a quota message, but in GitHub Copilot it usually is not one. Since GitHub moved Copilot to usage-based billing, there are two separate mechanisms that can stop a request: a temporary rate limit, and your monthly allowance of AI credits. They look similar, last for different lengths of time, and have different fixes. This guide explains which is which, what an AI credit is, when it resets, and what to do at each level, using GitHub's own documentation.

Rate limit vs credits: how to tell them apart

GitHub defines rate limits as a mechanism that controls how many requests a user or application can make in a given time period, used for capacity, fairness, handling demand spikes, and abuse prevention. Its troubleshooting page says most people see the message on select models because of limited capacity. That means a rate limit is not necessarily your fault and is not a billing event. The VS Code documentation says the same from the other direction: the error means the service is temporarily limiting requests, and it can occur even when monthly AI credits are not used up.

What changed: premium requests to AI credits

GitHub announced that all Copilot plans move to usage-based billing on June 1, 2026. Premium request units were replaced by GitHub AI Credits, which are consumed by token usage (input, output, and cached tokens) at each model's published API rates. Code completions and next edit suggestions stay included and do not use credits. The announcement also said the fallback to a lower-cost model when premium requests run out is ending, so usage is limited by available credits and admin budgets. Monthly Pro and Pro+ subscribers migrated automatically; annual subscribers keep premium-request pricing until their plan expires.

What an AI credit is

Per GitHub's billing documentation for individuals, 1 AI credit equals $0.01 USD. Every interaction consumes input, output, and cached tokens, and each token is priced by the model used. That is why long conversations, large attached context, and expensive models drain credits faster than short chats on a cheaper model.

These figures are from GitHub's individual billing page as we read it, which describes the flex allotment as something that can change over time. Base credits are used first, then the flex allotment applies automatically. Copilot Free and Student also receive a credit allowance, but only through auto model selection. For Business and Enterprise, GitHub documents included credits of 1,900 and 3,900 per user per month, pooled across the organization or enterprise.

When credits reset

GitHub's documentation states that included credits do not carry over, and unused credits are forfeited. The allowance resets at 00:00:00 UTC on the first day of each calendar month, independent of your billing date. In Pakistan Standard Time (UTC+5) that is 5:00 a.m. on the first. Both the inline suggestions allowance and the AI credits allowance reset every month.

What you can do at each level

For individuals, GitHub says the upgrade cost is only the price difference between your current plan and the new plan, and that you can instead stay on your plan and pay for additional usage by setting a budget in US dollars (a $10 budget covers 1,000 credits). Additional usage may be capped, and if the cap is reached you must pay off the consumed additional usage before continuing.

Business and Enterprise: pools and budgets

• Pooled credits. Usage draws from the shared pool first and is billed separately only after the pool is exhausted. A hundred Business users create a 190,000-credit pool, per GitHub's example.
• Additional usage. If allowed, usage continues at published per-credit rates; it is enabled by default on Business and Enterprise. If not allowed, usage is blocked until the next billing cycle.
• User-level budgets always hard-stop. A $0 user-level budget immediately blocks credit-consuming features. The most specific applicable budget wins, and the one with the least remaining headroom blocks you first.
• Other budgets only stop usage if enabled. Cost center, organization, and enterprise budgets hard-stop only when “Stop usage when budget limit is reached” is on, which is off by default.
• Blocked does not mean removed. Budget restrictions do not remove assigned seats, and unlimited inline completions keep working.
• To get unblocked: wait for the next cycle, have an admin raise the relevant budget, or request additional budget and have it approved. Raising a cost center or enterprise budget does not unblock someone who hit their user-level budget.

What keeps working when credits run out

Inline code completions and next edit suggestions are not billed in credits, and the VS Code documentation says that if you have only reached the AI credits limit you can still use inline suggestions. Credit-consuming features include Copilot Chat, Copilot CLI, the cloud agent, Spaces, Spark, and third-party coding agents. Free-plan users can also hit a separate monthly cap on inline suggestions.

A planner and diagnosis script

The script converts token counts into credits using rates you supply (take them from GitHub's models and pricing page, since they change), computes the next reset in UTC, projects whether you will run out before month end, and maps what you observe to the likely cause and fix. Its tests run without Copilot installed.

from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
import calendar

CREDIT_USD = 0.01          # 1 AI credit = $0.01 (GitHub billing docs for individuals)


@dataclass
class Rates:
    """USD per 1,000,000 tokens. Take these from GitHub's models-and-pricing page; they change."""
    input: float
    output: float
    cached: float = 0.0


def credits_for(input_tokens: int, output_tokens: int, rates: Rates, cached_tokens: int = 0) -> float:
    usd = (input_tokens * rates.input + output_tokens * rates.output + cached_tokens * rates.cached) / 1_000_000
    return usd / CREDIT_USD


def next_reset(now: datetime) -> datetime:
    """Allowances reset at 00:00:00 UTC on the first day of each calendar month."""
    now = now.astimezone(timezone.utc)
    year, month = (now.year + 1, 1) if now.month == 12 else (now.year, now.month + 1)
    return datetime(year, month, 1, tzinfo=timezone.utc)


def projection(used: float, allowance: float, now: datetime) -> dict:
    now = now.astimezone(timezone.utc)
    days_in_month = calendar.monthrange(now.year, now.month)[1]
    elapsed = (now - datetime(now.year, now.month, 1, tzinfo=timezone.utc)) / timedelta(days=1)
    elapsed = max(elapsed, 1 / 24)
    daily = used / elapsed
    projected = daily * days_in_month
    out = {"daily_burn": daily, "projected_month": projected, "runs_out": projected > allowance, "run_out_in_days": None}
    if used >= allowance:
        out["run_out_in_days"] = 0.0
    elif daily > 0 and projected > allowance:
        out["run_out_in_days"] = (allowance - used) / daily
    return out


def diagnose(credits_left=None, completions_work=True, retry_helped=False, org_plan=False,
             own_budget_reached=False, paid_usage_allowed=True) -> list:
    """Return likely causes in order, with what to do."""
    out = []
    if retry_helped:
        out.append(("Temporary rate limit", "Wait a few minutes and retry. Rate limits are temporary and can occur even when credits remain."))
        return out
    if credits_left is not None and credits_left > 0 and not own_budget_reached:
        out.append(("Rate limit or model capacity", "Retry shortly, try another model, or contact GitHub Support if it persists."))
    if credits_left is not None and credits_left <= 0:
        if org_plan and not paid_usage_allowed:
            out.append(("Pool exhausted and paid usage is off", "Ask an admin to allow additional usage or raise the budget, or wait for the monthly reset."))
        elif org_plan:
            out.append(("Pool or budget exhausted", "Request additional budget from an admin, or wait for the monthly reset."))
        else:
            out.append(("Monthly AI credits used up", "Upgrade, set a budget for additional usage, or wait for the monthly reset."))
    if own_budget_reached:
        out.append(("User-level budget reached", "Only an increase to your own user-level budget unblocks you; raising a broader budget does not."))
    if completions_work and out:
        out.append(("Note", "Inline completions and next edit suggestions are not billed in credits and should keep working."))
    if not out:
        out.append(("Unknown", "Open the Copilot status dashboard to compare credits used against your allowance."))
    return out

NOW = datetime(2026, 11, 10, 12, 0, tzinfo=timezone.utc)


def test_credits_follow_the_one_cent_rule():
    r = Rates(input=3.0, output=15.0, cached=0.3)
    # 1M input + 100k output = $3 + $1.50 = $4.50 = 450 credits
    assert abs(credits_for(1_000_000, 100_000, r) - 450.0) < 1e-6
    assert credits_for(0, 0, r) == 0
    assert abs(credits_for(0, 0, r, cached_tokens=1_000_000) - 30.0) < 1e-6


def test_next_reset_is_first_of_next_month_utc():
    assert next_reset(NOW) == datetime(2026, 12, 1, tzinfo=timezone.utc)
    dec = datetime(2026, 12, 31, 23, 59, tzinfo=timezone.utc)
    assert next_reset(dec) == datetime(2027, 1, 1, tzinfo=timezone.utc)


def test_next_reset_converts_other_timezones():
    pk = timezone(timedelta(hours=5))
    late = datetime(2026, 11, 30, 23, 0, tzinfo=timezone.utc).astimezone(pk)   # already Dec 1 in PKT
    assert next_reset(late) == datetime(2026, 12, 1, tzinfo=timezone.utc)


def test_projection_flags_overspend_and_gives_days_left():
    p = projection(used=1000, allowance=1500, now=NOW)       # 9.5 days elapsed
    assert p["runs_out"] is True
    assert 4 < p["run_out_in_days"] < 5
    ok = projection(used=100, allowance=1500, now=NOW)
    assert ok["runs_out"] is False and ok["run_out_in_days"] is None
    assert projection(used=1500, allowance=1500, now=NOW)["run_out_in_days"] == 0.0


def test_diagnose_rate_limit_vs_exhausted():
    assert diagnose(retry_helped=True)[0][0] == "Temporary rate limit"
    assert diagnose(credits_left=500)[0][0] == "Rate limit or model capacity"
    assert diagnose(credits_left=0)[0][0] == "Monthly AI credits used up"
    assert diagnose(credits_left=0, completions_work=True)[-1][0] == "Note"


def test_diagnose_org_and_user_budget():
    a = diagnose(credits_left=0, org_plan=True, paid_usage_allowed=False)
    assert a[0][0] == "Pool exhausted and paid usage is off"
    b = diagnose(credits_left=200, org_plan=True, own_budget_reached=True)
    assert b[0][0] == "User-level budget reached"
    assert diagnose()[0][0] == "Unknown"

Spend fewer credits

• Match the model to the task. Credits are priced by model, so routine edits do not need the most expensive one.
• Keep context lean. Input tokens count every turn; start a new chat when the topic changes.
• Watch long agent runs. Autonomous sessions consume tokens continuously.
• Check the dashboard weekly, not at the end of the month.
• Keep your client current. GitHub notes older IDE, client, or extension versions can show incorrect pricing or usage alerts.

For how other coding tools handle limits, see Cursor vs Claude Code vs Copilot and Top Claude Code Errors in 2026. If your own code hits API limits, see OpenAI 429 rate limit and Anthropic 429.

Sources

• GitHub Docs: Usage limits for GitHub Copilot
• GitHub Docs: Usage-based billing for individuals
• GitHub Docs: Usage-based billing for organizations and enterprises
• GitHub Docs: Budgets for usage-based billing
• The GitHub Blog: GitHub Copilot is moving to usage-based billing
• GitHub Docs: Troubleshooting common issues with GitHub Copilot
• Visual Studio Code Docs: GitHub Copilot FAQ

Frequently asked questions

Keep reading