Muse Wonder Rate Limits Explained: How 3000 RPM and 4M TPM Are Shared Across Teams

Core Mechanics of Muse Wonder API Rate Limits

Meta Model API sets the rate limits for the Muse Wonder model at 3,000 requests per minute (RPM) and 4 million tokens per minute (TPM). These two limits apply per model and per team, not per API key — calls made by any key within the organization draw from the same quota pool.

Background responses enjoy an extra quota: 600 new submissions per minute, independent of the main limits. Meta has not published any usage tiers, nor is there a documented limit-increase process. Once you exceed the limit, the API returns an HTTP 429 status code. Meta recommends an exponential backoff strategy with jitter, starting at roughly 500 milliseconds, and paying attention to the Retry-After header in the response.

The same set of limits (3000 RPM / 4M TPM) also applies to Muse Spark 1.3. Spark's Contributor variant is capped at 150 RPM and 3 million TPM. Each model has its own independent quota pool, so a surge in Wonder traffic won't starve Spark channels, and vice versa. Control context injected by Meta does not count toward TPM and does not appear in the usage field.

Tokens Hit the Ceiling Before Requests

With a budget of 4 million tokens per minute, the request-count limit is rarely the tightest bottleneck for Agent scenarios. The number of requests you can actually send depends directly on context size:

Workload	Tokens per Request	RPM Before TPM Becomes the Bottleneck
Short conversation turns	3000	1333
Document review	50000	80
Long Agent turns (400K context)	400000	10
Full-window request	1000000	4

When a team runs multiple large-context Agents, just a dozen concurrent requests can hit 4 million TPM. Cached input still counts toward TPM — the cache discount is a billing perk, not a rate-limit perk. Reasoning tokens count toward max_output_tokens and billing, and output tokens likewise consume TPM.

So the TPM budget should be allocated by context size, not by request count. An Agent that resends a 300K-token conversation every turn generates a 300K-token request each time. Ten such Agents each firing once per minute will consume 75% of the team quota.

Planning Concurrency with Math

The capacity formula is compact:

number of concurrent Agents × tokens per turn × turns per minute < 4000000

Calculate this value before deploying your heaviest pipeline:

Agents	Tokens per Turn	Turns per Minute per Agent	Required TPM	Headroom
4	150000	2	1200000	70%
8	250000	1	2000000	50%
12	300000	1	3600000	10%
20	300000	1	6000000	Over limit

Leave at least 40% headroom when planning. Agent work tends to be bursty, a retry storm after a transient error can double demand within a minute, and others on the team share the same quota pool. The third row in the table is safe on paper but fails in practice when two Agents execute for the first time simultaneously.

Two levers can reduce demand:

• Context compression: prevents per-turn token demand from growing without bound. Summarize or discard old tool-call results once a run exceeds a threshold.
• Stateless encrypted replay: the Responses API lets you control exactly what gets resent. By contrast, server-managed history with previous_response_id resends everything.

All Keys Share One Quota Pool

Meta limits usage by team. A key for pre-release, a key for production, and a key on a colleague's laptop all access the same 3000 RPM and 4 million TPM.

Two rules follow from this:

1. A developer's stress test can slow down production. Isolate experiments in time, or use a separate team if your organization allows it.
2. Per-key monitoring doesn't show the full picture. You need to aggregate x-ratelimit-* headers across all callers; otherwise you may see 429 errors on a key that appears to be well under the limit.

Reading the Rate Limit Headers

Token-based responses carry x-ratelimit-* headers. Log them on every call. The key pattern is: remaining capacity approaching zero within a minute across all callers. That's the signal to slow down before the next 429 arrives. Transcript responses don't carry these headers; Wonder's responses do.

When you hit a 429, Meta's recommendation is specific: use exponential backoff with jitter, starting at about 500 milliseconds, and if a Retry-After header is present, wait at least the specified time. Retry loops that ignore Retry-After and keep hammering at fixed intervals prolong rate limiting for the entire team.

Building a Retry Path

A robust retry path combines Retry-After, exponential backoff, jitter, and a wait-time ceiling:

import os
import random
import time

from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)

def call(input_text, attempts=6):
    delay = 0.5
    for attempt in range(attempts):
        try:
            return client.responses.create(
                model="muse-wonder-1.0",
                input=input_text,
            )
        except RateLimitError as e:
            retry_after = e.response.headers.get("retry-after")
            if retry_after:
                wait = float(retry_after)
            else:
                wait = delay + random.uniform(0, delay)
            time.sleep(wait)
            delay = min(delay * 2, 30)
    raise RuntimeError("rate limited after retries")

Three key design points: cap the backoff so wait times don't spiral out of control during a long outage; distinguish between a slow model and a rate-limited state, logging the time of each 429 in your traces; and record enough information in tool-call traces to debug.

Using Background Responses for Long-Running Tasks

Long-running tasks don't need to hold a connection open. Setting background: true puts the response into a queue and lets you poll lifecycle events via GET /v1/responses/{id}?stream=true.

Background submissions have an independent quota of 600 per minute in addition to the main limits. So migrating batch work to background frees up RPM for interactive traffic.

Note these constraints:

• stream: true is not allowed on POST
• Request body is limited to 1 MiB
• Cancel via POST /v1/responses/{id}/cancel

When 3000 RPM Isn't Enough

Meta currently doesn't publish tiers or a limit-increase form. Options available today:

• Reduce tokens per request. Prompt caching lowers the bill, not TPM. Trimming context lowers both.
• Spread work across models. Muse Spark 1.3 has its own 3000/4M quota pool and costs one-third as much. Route work that doesn't need Wonder-quality output there.
• Use a gateway. Vercel AI Gateway and Cloudflare Workers AI serve meta/muse-wonder-1.0. Whether you get a separate quota depends on how the gateway is deployed.

Don't wait until request 3001 to discover your retry is broken. In Apidog you can:

1. Create a Responses request, set MODEL_API_KEY as a secret variable, and add a post-processor to store the x-ratelimit-* headers in environment variables.
2. Create a Mock for /v1/responses that returns HTTP 429 and Retry-After: 2 when the request includes a specific header, verifying the client waits at least 2 seconds and succeeds on the next attempt.
3. Run a performance test, increasing request volume against the Mock, to confirm the rate limiter fires before the real API rate limits you.

FAQ

Are Muse Wonder rate limits per key or per account?

Per team. All keys within a team share the same per-model 3000 RPM and 4 million TPM quota pool.

Do cached inputs count toward TPM?

Yes. Caching lowers the price of those tokens but doesn't change their weight against the tokens-per-minute limit.

Can I request a higher limit?

Meta's pricing and rate limit pages currently don't list tiers or a process. Watch that page for changes; new models typically get usage tiers added within a few weeks.

What status code and headers are returned when over limit?

HTTP 429, optionally carrying Retry-After, along with x-ratelimit-* headers on token-based responses.

Next Steps

Measure the tokens per request for your heaviest Agent turn, multiply by concurrency, and compare the result against 4000000. If it's close, build the rate limiter and Mock test this week — before your team shares the same quota pool with production.

One-line Summary

Muse Wonder shares 3000 RPM/4M TPM per team; in Agent scenarios TPM hits the ceiling first, requiring context-based concurrency planning and backoff retries.

Paragraph Summary

Meta Muse Wonder's rate limits are 3000 requests per minute and 4 million tokens per minute, applied per model and per team, with all API keys in a team sharing one quota pool, and background responses having a separate quota of 600 submissions per minute. In practice TPM tends to hit the ceiling before RPM: a full-context 1M-token request can only be sent 4 times per minute, and cached input still counts toward TPM. The article provides the concurrency planning formula "number of concurrent Agents × tokens per turn × turns per minute < 4 million" and recommends keeping at least 40% headroom for bursts and retry storms. Exceeding limits returns HTTP 429, and you should adopt exponential backoff with jitter, starting at about 500 milliseconds and prioritizing the Retry-After header. Mitigation options include context compression, stateless encrypted replay, routing to the cheaper Muse Spark 1.3, and using gateways like Vercel AI Gateway or Cloudflare Workers AI. Meta currently doesn't publish usage tiers or a limit-increase process.