Search for “LLM API rate limits” and you get blog tables that disagree with each other, often because they copy old numbers. This page reads every figure from the provider’s own documentation on 15 November 2026, says which tier and model it applies to, and leaves a cell blank when the provider does not publish one. For the same data as a downloadable dataset, with free credits and data-use terms, see LLM API free tiers and rate limits. BroadRouter is BroadNet’s own site, and BroadNet’s limits are in the table too.
What do RPM, TPM, RPD and concurrency mean?
A rate limit caps how much you can send in a time window. Providers count different things:
| Limit | What it counts | Hurts most when |
|---|---|---|
| RPM, requests per minute | Requests started in a minute | You send many short calls (classification, embeddings-style loops) |
| RPS, requests per second | The same, over one second | You send bursts, even if the minute average is low |
| TPM, tokens per minute | Tokens processed in a minute, sometimes input (ITPM) and output (OTPM) separately | You send long prompts or long documents |
| RPD / TPD, per day | Requests or tokens in a day | You run a batch job on a free tier |
| Concurrency | Requests in flight at the same moment | Requests are slow: reasoning, long outputs, agents |
The one that bites depends on your request shape. With concurrency limits, throughput depends on request length: DeepInfra’s own docs give the example that 200 concurrent requests at a 1-second average works out to roughly 12,000 RPM. A 30-second reasoning request at the same concurrency gives a fraction of that.
Most providers also enforce limits over shorter windows than they publish. Anthropic says a 60 RPM limit “might be enforced as 1 request per second”, and xAI derives its per-second limit from the per-minute budget (“RPM / 48, with a minimum of 2”).
How do usage tiers work?
The large closed-model providers raise your limits as you spend more:
| Provider | Tiers (checked 2026-11-15) | How you move up |
|---|---|---|
| OpenAI | Free, Build, Launch, Grow | Free: user must be in an allowed geography; monthly usage limit USD 100 (a cap on spend, not a credit). Then total credit purchases of USD 5, USD 100 and USD 500, with monthly usage limits of USD 500, USD 5,000 and USD 200,000 |
| Anthropic | Evaluation, Start, Build, Scale, Custom | Automatic, by usage history and account standing. Monthly spend caps: Start USD 500, Build USD 1,000, Scale USD 200,000 |
| Google Gemini API | Free, Tier 1, Tier 2, Tier 3 | Tier 1 needs a linked billing account; Tier 2 needs USD 100 paid plus 3 days; Tier 3 USD 1,000 plus 30 days. Google says specified rate limits are “not guaranteed” and offers “no guarantees” on increase requests |
| Fireworks AI | Tier 1 to Tier 4 | Payment method for Tier 1, then USD 50, USD 500 and USD 5,000 in spend or credits. Tiers raise TPM, not RPM |
| xAI | Tier 0 to Tier 4, Enterprise | Cumulative spend since 1 January 2026: USD 0, 50, 250, 1,000 and 5,000 |
Two details matter in practice. Anthropic’s spend cap returns HTTP 429 with no retry-after header when you reach it, so automatic retries keep failing until the month resets or you move tier. And Anthropic’s input limit counts only uncached input: cache reads do not count, so a high cache rate raises your real throughput.
LLM API rate limits by provider: the entry tier
Figures for each provider’s free or first paid tier, from its own rate-limits page. A dash means the page publishes no number for that limit; it does not mean unlimited.
| Provider | Tier and model | RPM | TPM | Per day | Concurrency |
|---|---|---|---|---|---|
| OpenAI | Build; Astra, Sol, Terra | 5,000 | 1,000,000 | – | – |
| OpenAI | Build; Luna | 5,000 | 2,000,000 | – | – |
| Anthropic | Start; Sonnet 5.5, Opus 5.5, Haiku 5.5 | 4,000 | 2,000,000 input (uncached), 400,000 output | – | – |
| Google Gemini API | Free; Gemini Decision 1 (only model with free numbers on the page) | 200 | 50,000 | 10,000 requests | – |
| Google Gemini API | Tier 1; Gemini Decision 1 | 1,500 | 1,000,000 | 50,000 requests | – |
| Groq | Free plan table; openai/gpt-oss-120b, qwen/qwen3.8-27b | 30 | 8,000 | 1,000 requests, 200,000 tokens | – |
| Groq | Developer plan table; openai/gpt-oss-120b, qwen/qwen3.8-27b | 1,000 | 250,000 | 500,000 requests | – |
| Cerebras | Free Trial; gpt-oss-120b | 5 | 30,000 uncached (90,000 total) | 1,000,000 tokens | – |
| Cerebras | Developer (pay as you go); gpt-oss-120b | 1,000 | 500,000 uncached (1,500,000 total) | No cap | – |
| Fireworks AI | No payment method or credits; account-wide | 10 | – | – | – |
| Fireworks AI | With payment method and credits; account-wide | 6,000 | Set by spending tier | – | – |
| DeepInfra | Default; per public model | – | – | – | 200 |
| DeepSeek | Default; deepseek-flash (DeepSeek-V4.1-Flash-1017), per account |
– | – | – | 2,500 |
| DeepSeek | Default; deepseek-v4-pro (DeepSeek-V4-Pro-0813), per account |
– | – | – | 500 |
| xAI | Tier 0; grok-4.7 (150 RPS) | – | 50,000,000 | – | – |
| OpenRouter | :free models, under USD 10 of credits bought | 20 | – | 50 requests | – |
| OpenRouter | :free models, USD 10 or more of credits bought | 20 | – | 1,000 requests | – |
| Cohere | Trial key; Command A | 20 | – | 1,000 calls a month | – |
| Cohere | Production key; Command A | 500 | – | – | – |
| BroadNet Inference | Pay-as-you-go key; any model | 30 | – | – | 4 |
| BroadNet Inference | Hourly key; Gemma 4 VL 26B | 120 | 300,000 | – | 1 stream |
| BroadNet Inference | Flat plan session; DeepSeek V4.1 Flash | – | No token meter | – | 1 request at a time |
Notes on the rows:
- Groq. The page has two tabs, “Free Plan Limits” (open by default) and “Developer Plan Limits”. The sentence above them calls the figures “the base limits for the Developer plan”, which fits only the second tab; the table above shows both. Exact limits for your organization are on its limits page.
- Google. Limits apply per project, not per API key. Most models’ numbers appear only inside AI Studio. Gemini Decision 1 is a classification model for Google’s Decisions API: it returns probabilities, not text, so its limits say little about Gemini chat models.
- Mistral and Together AI publish no numbers. Mistral shows your limits in its console rather than publishing a table, and offers no free API access (“It doesn’t include API access”). Together says it “may limit requests” when demand is high and may set custom limits on popular models.
- OpenRouter. Paid model variants have “no platform-level request cap”, but the providers behind each model still have their own limits.
- DeepSeek. When busy, DeepSeek keeps the connection open with empty lines or
: keep-alivecomments, and closes it if inference has not started within 10 minutes. Set your client timeout with that in mind.
How do BroadNet’s limits compare, honestly?
They are low for high-volume work. A BroadNet pay-as-you-go key allows 30 requests a minute and 4 in flight, while OpenAI’s and Anthropic’s first paid tiers allow thousands of requests a minute and Fireworks allows 6,000 once a card is on file. If you need to push thousands of short requests a minute through one key, a big provider’s paid tier fits better.
The limits fit other shapes:
- Agents and chat. One agent sends one request at a time and waits. 4 in flight covers a few agents per key; a key per app or teammate spreads the load.
- Flat plans. A Full Moon, Orbit or Meteor session has no token meter and no daily or weekly cap, but runs one request at a time at a typical speed of about 100 tokens per second. To run agents in parallel, buy a session for each. How many sessions you need.
- Hourly key. $0.50 an hour buys one Gemma 4 VL 26B stream at 120 requests and 300,000 tokens a minute.
All BroadNet limits return HTTP 429. The API reference gives no retry-after timing, so use bounded backoff with jitter.
How do you plan around a rate limit?
- Find your binding limit. Work out requests a minute, tokens a minute and requests in flight for your peak traffic. The LLM rate limit calculator does this from request size and latency.
- Throttle on the client. A token bucket that matches the published limit avoids most 429s. Anthropic uses the same algorithm server-side.
- Read the headers. Anthropic returns
anthropic-ratelimit-*headers; Groq returnsx-ratelimit-*headers, where its requests header “always refers to Requests Per Day”. Useretry-afterwhen it is present. - Retry with backoff and jitter, and cap the retries. Handle 429 errors has working code, and errors and retries covers BroadNet’s status codes.
- Cache stable prefixes. On Anthropic, cached input does not count toward the input limit. Everywhere, it cuts cost.
- Spread bulk jobs. Anthropic also applies ramp limits: a sudden jump in traffic can return 429 below your limit. Start batch jobs slowly. Without a Batch API, a resumable batch runner keeps a job inside its limits.
- Ask for more. DeepSeek, DeepInfra, Mistral and Anthropic all describe a request path for higher limits.
Where BroadNet Inference fits
BroadRouter is BroadNet’s own website, so weigh this section accordingly. BroadNet Inference is not the option for very high request rates on one key: its published per-key limits are well below the paid tiers of OpenAI, Anthropic, Fireworks or Cerebras. It fits agent and chat workloads that send a few requests at a time, especially on a flat plan where a busy agent has no token meter or daily cap. New accounts get a $5 starting credit for Gemma 4 VL 26B, the two transcription models and Gemma hourly keys; DeepSeek, GLM and Qwen need a top-up. Self-serve has no SLA. Read the API limits or compare plans.
