Grok Message & Rate Limits: What You Get & How to Get More

"Grok message limit" means two completely different things, and confusing them wastes hours. One is the consumer app limit — how much you can use Grok inside X, the Grok apps, and SuperGrok, which as of a June 2026 rollout is now a single compute-metered weekly usage pool rather than fixed per-product message counts. The other is the xAI API rate limit — exact requests-per-second and tokens-per-minute caps keyed to how much you have spent. This guide separates the two, gives you a real limits table for each (with an honest note on which numbers xAI actually publishes), and shows the three ways to get more: upgrade, move to the API, or route through a gateway that fails over. All consumer figures are dated to July 2026 because they change often.

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, jump to consumer limits. If your code got an HTTP 429, jump to API tiers. The two rarely need the same answer.

Consumer app limits: one weekly usage pool

As of a June 2026 rollout, paid Grok users no longer have separate fixed per-product daily message limits — each subscription includes one shared weekly usage pool spent across any Grok product. That pool covers Chat, Imagine, Voice, Build and API access within the subscription, and it drains at different rates depending on how much compute each action needs.

• Compute-metered, not message-counted. A chat message uses little compute; generating a high-quality video or running a long coding task uses far more. So "how many messages" has no fixed answer — it depends what you do with them.
• You can see it drain. Usage shows as a percentage in Settings → Usage, with a per-product breakdown and the weekly reset time. Watch that number rather than guessing.
• Running out is not a lockout. When a paid user's weekly pool is exhausted, paid features pause until the weekly reset — but you keep Grok's separate free-tier Chat and Voice limits, which reset on their own schedule.
• You can top up. Extra Usage Credits can be bought for as little as $5 from the web Usage tab; top-up credits expire one year after purchase.

The tiers themselves are described qualitatively by xAI: paid SuperGrok plans raise limits versus free, and SuperGrok Heavy (available with an upgraded or organization license) provides a larger weekly usage allowance and more powerful performance. xAI describes these in words, not with published numeric per-tier caps.

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.

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:

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 class has its own RPS (requests per second) and TPM (tokens per minute) cap, and both rise with your tier. For the standard xAI text models — grok-4.3, grok-4.20-0309-reasoning, grok-4.20-0309-non-reasoning, and the code model grok-build-0.1 — the published caps across Tiers 0–4:

Two things to design around:

• Multi-agent is much tighter. The grok-4.20-multi-agent-0309 model tops out at 45 RPS on Tier 4 versus 166 for standard text — budget for it separately if you orchestrate agents.
• Image and video are flat and low. 5 RPS for images and 1 RPS for video regardless of tier, so spend does not buy you more generation throughput there — queue and batch instead.

Model IDs and pricing you will pair with these limits (July 2026): grok-4.3 ships a 1M-token context, and it plus the grok-4.20 variants are priced at $1.25 / 1M input and $2.50 / 1M output tokens; the code model grok-build-0.1 (256k context) is $1.00 input / $2.00 output. Image and video APIs price separately (grok-imagine-image $0.02/image, grok-imagine-video $0.050/sec). All from xAI's models page.

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. SuperGrok raises limits over free; SuperGrok Heavy adds a larger weekly usage allowance and more powerful performance. Best when your cap is the in-app weekly pool.
2. Buy Extra Usage Credits. From the web Usage tab, as little as $5, when you just need to finish the week. Top-up credits expire one year after purchase.
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: let cumulative spend advance you automatically to a higher tier, keep multi-agent calls under their tighter separate cap, queue image/video work behind their flat low RPS, or fail over. The generic version of all of this is in our rate-limit fix guide, and every status code is decoded in the LLM API error-code reference. Because xAI's API is OpenAI-compatible, the same retry code works if you later swap models.

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, and best LLM for AI agents covers where the multi-agent model fits.

FAQ