Grok Limits in 2026: Free Tier, the Shared Weekly Usage Pool, Reset Time & API Caps

Grok's free tier has its own Chat and Voice limits, which reset on their own schedule, and xAI publishes no message count for them. Paid plans share one weekly usage pool across Chat, Imagine, Voice, Build and API, metered by compute rather than messages. Your share used, the per-product breakdown and your exact reset date and time are in Settings → Usage. Developers on the xAI API get published per-model RPS and TPM caps that rise with cumulative spend. This guide covers each limit, shows how to work out your own message count from the Usage tab, and explains what to do when you hit the wall. Every consumer statement is attributed to xAI's Grok FAQ, re-checked 2026-10-03, and where xAI publishes no number we say so instead of guessing.

Correction, October 3, 2026: single-model benchmark latency is a mean, not a median. Labels were corrected; measured values and the original run dates are unchanged. Measurement details.

The two Grok limits, separated

"Grok message limit" refers to two different systems, and the fix depends entirely on which one you hit. Before anything else, figure out which side you are on:

• The consumer app limit — how much you can use Grok inside X, the Grok apps, and SuperGrok. As of a rollout beginning June 2026, paid users share a single compute-metered weekly usage pool across all Grok products. There are no official per-tier message counts anymore.
• The xAI API limit — if you build on Grok in code, your ceiling is a set of requests-per-second (RPS) and tokens-per-minute (TPM) caps that scale with your cumulative API spend. These are published as exact numbers.

If you are chatting in an app and got cut off, read the next five sections. If your code got an HTTP 429, jump to API tiers. The two rarely need the same answer, and one detail catches people out: API access inside a consumer subscription draws on the consumer pool, while a developer key on the xAI API is governed by the spend-tier system instead.

What the shared weekly usage pool is, and what shares it

The shared weekly usage pool is one allowance included with your Grok subscription that you can spend across any Grok product — Chat, Imagine, Voice, Build and API — instead of a separate daily message limit per feature. xAI's Grok FAQ describes it as one shared weekly usage pool you can spend however you like across any Grok product, and says you are free to consume the entire pool on a single product or spread it across several.

Three properties follow from that design, and they are the reason "how many messages do I get" has no answer:

• It is metered by compute, not by messages. Per the FAQ, different products cost different amounts depending on how much compute that product requires: a chat message uses little compute, while generating a high-quality video or running a long coding task uses far more. So the same pool might be hundreds of chat turns or a handful of video renders.
• It is one pool across five surfaces. The FAQ names them: API, Build, Chat, Imagine, Voice. A heavy afternoon in Imagine takes budget away from Chat later in the week. That is the intended trade, not a bug.
• It replaced per-product daily limits. The rollout began June 2026. Any guide describing fixed daily message counts per feature is describing the previous system — see the stale numbers below.

The tiers themselves are described only qualitatively, and more thinly than most guides admit. What the FAQ actually says is generic: you can upgrade to a higher plan for a larger weekly allowance, and upgrading gives significantly more weekly usage at a lower cost per action than repeatedly buying credits. It never states which named plan sits where, and it publishes no numeric per-tier allowance. SuperGrok Heavy appears in the FAQ only as a yearly subscription type; that it carries the biggest pool is the obvious commercial reading, not a sentence xAI has written.

Settings → Usage: where it is, and what every field means

Open Settings and select Usage — the tab shows four things: a progress bar with your current usage percentage, a percentage breakdown by product, your weekly reset date and time, and your Extra Usage Credits balance if you have one. That tab is the only authoritative statement of your own allowance; nothing published anywhere else tells you how much you have left.

Step by step:

1. Open Settings in Grok.
2. Select the Usage tab.
3. Read the progress bar for the week, then the per-product breakdown underneath it.
4. Note the reset date and time — it is specific to your account (see below).
5. If you want to top up, do it here on the web. The FAQ states Extra Usage Credits can currently only be purchased on the web, so if you are in a mobile app and cannot find a buy button, that is expected rather than a bug.

What each field actually tells you:

• Progress bar / usage percentage. The share of this week's included allowance you have already spent. It is a percentage, not a message counter — because the pool is compute-metered, there is no message number for it to count.
• Percentage breakdown by product. The FAQ lists these as API, Build, Chat, Imagine and Voice. This is the field worth checking first when your pool drains faster than expected: one heavy generation surface can dominate a week that felt like light usage.
• Weekly reset date and time. Your account's own reset moment. xAI does not publish a global reset day or hour, so this field is the answer and a guess is not.
• Extra Usage Credits balance. Shown only if you hold credits. This balance is separate from the included pool and is spent after the pool is exhausted, not alongside it.

Work out your own message limit from Settings → Usage

The Usage tab gives you a percentage, and a percentage plus arithmetic gives you a message count. This is the durable version of the answer — it survives every xAI pricing change, because it reads your own account rather than a published table.

The two-minute derivation. Do this once and you will never need a published number again:

1. Open Settings → Usage and write down the percentage. Call it used.
2. Note how many days into your week you are. Call it d. Your burn rate is used / d points per day.
3. Runway in days is (100 − used) / (used / d). Compare that against the days remaining until the reset time shown on the same tab.
4. To make the pool last the full week, your ceiling is 14.3 points per day — that is 100 divided by 7, and it is the only universal number on this page.
5. For a message count: note the percentage, send a measured batch of your normal work — say 20 chat turns — and read the percentage again. If it moved by Δ points, your remaining allowance is roughly (100 − used − Δ) × 20 / Δ turns of that kind — the batch you just sent comes off the top before you divide.

Step 5 is the one nobody does, and it is the only way to get a real message number for your own account. It is also model-dependent and product-dependent: measure it again if you switch between quick chat and long agentic runs, because the compute cost per turn is not the same thing.

When the weekly limit resets, and on what clock

The pool resets once a week on a schedule specific to your account, shown as a date and time in Settings → Usage — xAI does not publish a fixed reset day, hour or timezone. The FAQ's wording is that the usage pool limit resets every week on a schedule shown in the Usage tab in Settings. That is the whole of what the vendor states.

So four practical consequences, and one honest gap:

• Do not assume Monday, and do not assume midnight UTC. No such anchor is published. If a page tells you the exact hour Grok resets for everyone, ask where it got that.
• What the weekly anchor is tied to is not documented. Signup date, billing date, first use — xAI does not say, and we did not find a primary source that does, so we will not guess. The tab shows your reset moment; treat that as ground truth and plan around it.
• Two clocks, not one. Free-tier Chat and Voice limits are separate from the weekly pool and reset on their own schedule, per the FAQ. Hitting one does not reset the other.
• Credits do not reset. The weekly reset restores your included allowance. It does not refill or refund Extra Usage Credits, which expire one year after purchase (see below).
• The API side has no weekly reset at all. Developer rate limits are per-second and per-minute windows, not weekly buckets — a different mechanism entirely, covered in API tiers.

What Extra Usage Credits are, what they cost, and how they stack with the pool

Extra Usage Credits are pay-as-you-go funds you buy on the web from Settings → Usage, with a minimum purchase of $5, and they are consumed only after your included weekly pool is exhausted. They are a top-up, not an upgrade: they extend the current week rather than raise the weekly allowance.

What xAI's FAQ states about them, re-checked 2026-10-03:

• Minimum purchase $5, from the Usage tab on the web. Web-only purchase.
• Spent after the included pool. The FAQ says credits are used after your plan's included weekly usage is exhausted — so a credit balance sitting in your account does not stop the included pool from running down first.
• They expire one year after purchase unless otherwise stated.
• They are priced at standard rates, which the FAQ notes means the cost per action is higher than the effective rate you get from the included weekly usage. In other words: credits buy the same compute at a worse rate than your subscription does.
• Auto Top Up exists. You can set automatic top-ups that add credits when your balance gets low, choosing the amount and a monthly cap.

What is not published: the per-action or per-token price of a credit. xAI states that credits bill at standard rates and that this is worse than the included effective rate, but it does not publish a consumer rate card mapping credits to chat turns, images or video seconds. So $5 buys $5 of standard-rate compute, and how far that goes depends entirely on which product you spend it in. Anyone quoting you "$5 = N messages" is inventing the N.

That last point has a real consequence. Because credits are deliberately priced above your subscription's effective rate, repeatedly topping up is the most expensive way to buy Grok compute. If the work is programmatic rather than conversational, the developer API prices per token on a published rate card instead — the current Grok token rates are in our Grok API pricing guide.

What happens the moment you hit the limit

Paid features pause until your weekly limit resets — your account is not suspended, your history is not deleted, and you keep Grok's free-tier Chat and Voice limits, which are separate and reset on their own schedule. The FAQ's wording is that when your weekly usage limit is met, paid features will pause until your weekly limit resets, and that you still have access to Grok's free tier limits on Chat and Voice.

So the practical experience is a downgrade, not a lockout. From there you have four documented moves:

1. Wait for the reset shown in Settings → Usage. Free.
2. Buy Extra Usage Credits — $5 minimum, web only, spent immediately since the pool is already empty.
3. Enable Auto Top Up so the next exhaustion is invisible. You set the amount and the monthly cap.
4. Upgrade to a higher plan for a larger weekly allowance. The FAQ lists this as one of your options and adds that upgrading gives significantly more weekly usage at a lower cost per action than repeatedly topping up — but it does not say what any named plan's pool is.

One thing that is not what happens: an HTTP 429. That error belongs to the developer API, where the mechanism is a per-second or per-minute cap rather than a weekly pool. If you got a 429 from code, you did not exhaust a weekly pool — see handling a Grok 429. Every status code the xAI endpoint can return is decoded in our LLM API error-code reference.

About those "1,000 messages a day" numbers

You will find specific consumer counts on third-party blogs — SuperGrok ~1,000 text messages/day, SuperGrok Heavy ~10,000/day, free tier ~10 messages per 2 hours. These are not confirmed by xAI and appear superseded. They circulate widely, but xAI's official pages do not state them, and the June 2026 weekly-pool system replaced the fixed per-product model they came from. Treat them as unofficial and likely stale estimates — useful as rough intuition, wrong as a spec. If a number about consumer Grok limits does not appear on an xAI page, do not build a decision on it. The only authoritative source for your own current allowance is the in-app Usage percentage.

This is also why this page keeps saying "xAI does not publish that." A compute-metered pool cannot be expressed as a message count without knowing which products you use, so a message count is not a number xAI is withholding — it is a number that does not exist under the current system.

xAI API rate limits: keyed to your spend

On the xAI API, your rate-limit tier is set by cumulative API spend since January 1, 2026 — and tiers unlock automatically and never downgrade. This is the layer you design against when you build on Grok in code. The thresholds, from xAI's rate-limits page (re-checked 2026-10-03):

Because tiers are spend-cumulative and one-way, you do not lose headroom in a slow month — once you cross a threshold you stay there. Exceed a limit and the API returns HTTP 429; the fix is below.

API RPS and TPM caps per model

Each model has its own RPS (requests per second) and TPM (tokens per minute) cap, and both rise with your tier — but grok-4.5, grok-4.6 and grok-4.7 sit on a far larger allocation than the other text models. The published caps across Tiers 0–4, from xAI's rate-limits page (re-checked 2026-10-03):

Three things to design around:

• The model you pick moves the ceiling more than your tier does. A brand-new Tier 0 account gets 150 RPS and 50M TPM on grok-4.5, grok-4.6 or grok-4.7 — more than a Tier 3 account, $1,000 of cumulative spend in, gets on grok-4.3 (125 RPS, 45M TPM). If throughput is your constraint, switching model beats grinding up a tier.
• Multi-agent is much tighter. grok-4.20-multi-agent-0309 tops out at 56 RPS and 21M TPM on Tier 4, against 208 RPS / 85M TPM for standard text and 500 RPS / 100M TPM for the grok-4.5 to grok-4.7 group — budget for it separately if you orchestrate agents.
• Image and video now scale with tier. In July they were flat at 5 and 10 RPS. The page as updated on September 17, 2026 gives images 6 RPS at Tier 0 rising to 100 at Tier 4, and video 10 rising to 158. Voice agents are capped by concurrent sessions instead, 10 at Tier 0 and 200 at Tier 4.

Prices to pair with these limits: xAI's models page (last updated September 21, 2026, read 2026-10-03) now leads with grok-4.7, a 500k-token context at $2.00 per 1M input and $6.00 per 1M output, with image generation starting at $0.02 an image and video at $0.02 a second. On OpenRouter's catalogue the same day, grok-4.5 and grok-4.6 also list at $2 / $6 and grok-4.3 at $1.25 / $2.50. The July version of the models page also listed higher rates above a 200k-token context; the current page no longer shows that table, so check before you price long-context work. The xAI docs also note that logprobs are silently ignored on grok-4.20 and newer, which matches what our Chat Completions parameter test saw on Grok 4.7.

How to get more Grok usage (the four levers)

Whether you are capped in the app or in code, there are exactly four ways to raise the ceiling. Pick by which limit you hit:

1. Upgrade your consumer plan. The FAQ states that a higher plan carries a larger weekly allowance at a lower cost per action; it does not publish what any individual plan's pool is. Best when your cap is the in-app weekly pool.
2. Buy Extra Usage Credits. From the web Usage tab, $5 minimum, when you just need to finish the week — with the caveat that they bill at standard rates, which is worse than your subscription's effective rate.
3. Move to the xAI API. Limits become explicit RPS/TPM instead of an opaque pool, and they rise automatically as your cumulative spend crosses each tier — no plan negotiation. This is the right move if you are building a product, not chatting. Start with a Grok API key.
4. Route through a gateway that fails over. When Grok returns a 429, a gateway can reroute the request to an equivalent model so your users never see the error — covered below.

Handling a Grok API 429

Exceeding your tier's RPS or TPM cap returns HTTP 429 — treat it as transient, back off, and spread load. The standard, correct retry loop against the OpenAI-compatible xAI endpoint:

import time, random, httpx

def call_grok(payload, key, tries=6):
    url = "https://api.x.ai/v1/chat/completions"
    headers = {"Authorization": f"Bearer {key}"}
    for i in range(tries):
        r = httpx.post(url, json=payload, headers=headers)
        if r.status_code == 429:                # RPS/TPM cap for this tier
            wait = float(r.headers.get("retry-after", 2 ** i))
            time.sleep(wait + random.random())      # backoff + jitter
            continue
        r.raise_for_status()
        return r.json()
    raise RuntimeError("exhausted retries")

Beyond the retry, the structural fixes map to the tiers above: move throughput-critical work onto grok-4.5, grok-4.6 or grok-4.7, whose caps start far above the other text models, let cumulative spend advance you automatically to a higher tier, keep multi-agent calls under their tighter separate cap, queue image and video work behind their per-tier RPS, or fail over. The generic version of all of this is in our rate-limit fix guide. Because xAI's API is OpenAI-compatible, the same retry code works if you later swap models.

Pay for more Grok, or route elsewhere: what we measured

If the work behind your limit is code generation, buying more Grok is not automatically the cheapest fix — on our own executed benchmark, several models finished the same nine tasks at a fraction of Grok's measured cost with the same 9/9 score. This is the one part of this page that is ours rather than xAI's: we ran it, and the numbers below are measured, not quoted.

We put 23 models through one harness of nine executed Python tasks. The original sweep was 13 models run in one sitting; the other 10 ran later on the same harness with the same settings. 20 of the 23 scored 9/9. Grok 4.5 is one of them; Grok 4.3 is not — it missed flatten. Since then we have run Grok 4.6 (2026-08-22) and Grok 4.7 (2026-10-02) on the same harness. Both scored 9/9, at $4.99 and $4.70 per 1,000 tasks, more than Grok 4.5. Part of the reason is input tokens. Grok 4.7 read 11,761 input tokens across the nine prompts, against 2,437 for Grok 4.6, which our hidden system prompt investigation looks into.

The spread between the cheapest 9/9 in that table and Grok 4.5 is 29x — $0.10 against $2.93 per 1,000 tasks — on nine tasks that neither model found hard. Grok 4.5's own detail is in our Grok 4.5 review, Grok 4.3's miss in the Grok 4.3 review, and the whole field ranked four different ways in the AI coding ranking.

How those numbers were produced, and what they do not cover. Nine executed Python tasks — two_sum, valid_parentheses, merge_intervals, roman_to_int, lcs_len, flatten, top_k_words, token_bucket, parse_csv_line. The model gets a signature and a prose spec and never sees the assertions; the returned code runs in an isolated python3 -I subprocess with a 12-second timeout; temperature 0, max_tokens 4000, one scored attempt per task, retried only on an API error. Calls go through OpenRouter's OpenAI-compatible endpoint, deliberately not through the DataLLM Lab gateway. Cost is measured token counts multiplied by list price on the stated date — a measured cost, not a billed invoice; 49 of roughly 396 catalogue models repriced in the twelve days to 2026-07-29, so an undated cost figure is not a fact.

The harness does not measure long-context reasoning, multi-file refactoring, agentic or multi-turn tool use, non-Python work, or vision, and the 4,000-token ceiling can truncate a verbose model. Two boundaries matter especially here: this table is about API models, so it does not help a consumer chatting in the Grok app — you cannot route a SuperGrok conversation elsewhere — and it says nothing about the features people actually pay a Grok subscription for, like Imagine or Voice. It is evidence for one decision only: if the workload behind your quota is bounded code generation, the cheap route exists and we measured it.

When a gateway removes the ceiling

A single provider's rate limit does not have to be your application's rate limit. A Grok 429 — your tier's RPS or TPM cap, or a momentary burst — is exactly the kind of transient error a gateway can absorb: on a 429 it retries the request on an equivalent model from another provider, so the end user never sees the error. You still design within Grok's limits for Grok-specific work, but the not-your-fault ceiling becomes an invisible reroute instead of a failed request. See routing & failover for how that is wired. If you are choosing between Grok and other options, our Grok vs Groq comparison clears up the name confusion, how to use Grok covers the app side, and best LLM for AI agents covers where the multi-agent model fits.

FAQ