---
title: "LLM API rate limits by provider, compared | BroadRouter"
description: "Entry-tier LLM API rate limits from 13 providers, read from their docs: OpenAI, Anthropic, Gemini, Groq, DeepSeek, Fireworks and others, plus what RPM and TPM mean."
url: https://broadrouter.com/blog/llm-api-rate-limits-by-provider/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# LLM API rate limits by provider: RPM, TPM and concurrency compared

By the BroadNet Inference team · 8 min read · Published 2026-11-15 · Updated 2026-11-16

LLM API rate limits differ in kind, not just size. OpenAI, Anthropic and Gemini cap requests and tokens per minute by usage tier. DeepSeek and DeepInfra cap concurrent requests. Groq and Cerebras free tiers add daily caps. On first paid tiers, OpenAI and Anthropic allow thousands of requests a minute; BroadNet pay-as-you-go keys allow 30.

## Key takeaways

-   Providers limit different things: requests per minute (RPM), tokens per minute (TPM), requests or tokens per day, requests per second, or requests in flight.
-   Tiered providers raise limits with spend: OpenAI Build (USD 5 paid) gives 5,000 RPM; Anthropic Start gives 4,000 RPM on its newest models (checked 2026-11-15).
-   Concurrency-based providers publish no RPM: DeepInfra allows 200 requests in flight per model, DeepSeek 2,500 per account on deepseek-flash (its V4.1 Flash model ID).
-   Free tiers are small: Groq's free table shows 30 RPM and 1,000 requests a day on gpt-oss-120b; OpenRouter :free models allow 20 RPM.
-   BroadNet pay-as-you-go keys allow 30 requests a minute and 4 in flight, far below big providers' paid tiers. Flat plans run one request at a time per session.

**On this page**

1.  What do RPM, TPM, RPD and concurrency mean?
2.  How do usage tiers work?
3.  LLM API rate limits by provider: the entry tier
4.  How do BroadNet’s limits compare, honestly?
5.  How do you plan around a rate limit?
6.  Where BroadNet Inference fits

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](https://broadrouter.com/data/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](https://broadrouter.com/glossary/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](https://broadrouter.com/glossary/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-alive` comments, 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](https://broadrouter.com/blog/run-parallel-coding-agents-flat-rate/).
-   **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?

1.  **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](https://broadrouter.com/tools/llm-rate-limit-calculator/) does this from request size and latency.
2.  **Throttle on the client.** A token bucket that matches the published limit avoids most 429s. Anthropic uses the same algorithm server-side.
3.  **Read the headers.** Anthropic returns `anthropic-ratelimit-*` headers; Groq returns `x-ratelimit-*` headers, where its requests header “always refers to Requests Per Day”. Use `retry-after` when it is present.
4.  **Retry with backoff and jitter, and cap the retries.** [Handle 429 errors](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/) has working code, and [errors and retries](https://broadrouter.com/guides/errors-and-retries/) covers BroadNet’s status codes.
5.  **Cache stable prefixes.** On Anthropic, cached input does not count toward the input limit. Everywhere, it cuts cost.
6.  **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](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) keeps a job inside its limits.
7.  **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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-api-rate-limits-by-provider&utm_content=body) or [compare plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-api-rate-limits-by-provider&utm_content=body).

Free tools for this

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Rate limit](https://broadrouter.com/glossary/rate-limit/)

A rate limit is a cap an API places on how much a client can use it in a time window, such as requests per minute or tokens per minute. Requests over the limit are refused, usually with HTTP 429 Too Many Requests, until usage falls back under it.

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Concurrency](https://broadrouter.com/glossary/concurrency/)

Concurrency is the number of requests a client has in flight at the same time. LLM APIs often cap it per key or plan, separately from requests per minute, because each open request holds GPU capacity until its response has finished.

[Pay-as-you-go](https://broadrouter.com/glossary/pay-as-you-go/)

Pay-as-you-go is a pricing model in which you pay only for what you use, metered per unit such as tokens, requests or audio minutes, with no subscription or minimum commitment. Most LLM APIs bill this way, from a prepaid balance or a periodic invoice.

[Throughput](https://broadrouter.com/glossary/throughput/)

Throughput, in LLM serving, is the total amount of work a system completes per unit of time across all concurrent requests, usually measured as output tokens per second or requests per second. It differs from per-stream speed, which is how fast a single request receives its tokens.

[Exponential backoff](https://broadrouter.com/glossary/exponential-backoff/)

Exponential backoff is a retry strategy in which a client waits longer after each failed attempt, typically doubling the delay up to a cap, before trying again. Adding random jitter to each wait spreads out retries from many clients so they do not hit the server at the same moment.

[Spend limit](https://broadrouter.com/glossary/spend-limit/)

A spend limit is a cap on how much an API account, project or key may spend in a period, usually a month. When usage reaches it, the provider rejects further requests, often with an HTTP 429 or 400 error, until the period resets or the limit is raised.

[API key](https://broadrouter.com/glossary/api-key/)

An API key is a secret string that identifies and authorizes a client calling an API. LLM APIs usually expect it in an Authorization: Bearer header, and anyone who holds the key can make requests that are billed to the account that owns it.

## Questions

### What are OpenAI's API rate limits on the first paid tier?

OpenAI's rate-limits guide (checked 15 November 2026) puts the Build tier at USD 5 in total credit purchases, with a USD 500 monthly usage limit. Build allows 5,000 RPM and 1,000,000 TPM on Astra, Sol and Terra, and 5,000 RPM and 2,000,000 TPM on Luna. Limits apply per organization and per project.

### What are Anthropic's API rate limits?

On the Start tier, Claude Sonnet 5.5, Opus 5.5 and Haiku 5.5 each allow 4,000 RPM, 2,000,000 input tokens a minute and 400,000 output tokens a minute (checked 15 November 2026). Only uncached input counts toward the input limit. New organizations may begin in a lower Evaluation tier.

### What are Groq's free rate limits?

Groq's published Free plan table (checked 15 November 2026) shows 30 requests a minute, 1,000 requests a day, 8,000 tokens a minute and 200,000 tokens a day for openai/gpt-oss-120b and qwen/qwen3.8-27b. Groq notes your organization's exact limits are on its limits page. Its Developer plan table shows 1,000 requests a minute, 500,000 requests a day and 250,000 tokens a minute for the same models.

### Does the DeepSeek API have rate limits?

Yes, as concurrency. DeepSeek allows 2,500 concurrent requests per account on deepseek-flash and 500 on deepseek-v4-pro, and returns HTTP 429 above that. Higher limits are available on request at no extra cost (checked 15 November 2026).

### What is the difference between RPM, TPM and concurrency?

RPM counts requests started per minute. TPM counts tokens processed per minute, sometimes input and output separately. Concurrency counts requests in flight at the same moment, so long requests use it up even at a low RPM.

### What are BroadNet Inference's rate limits?

A pay-as-you-go key allows 30 requests a minute and 4 in flight. An hourly key allows 120 requests a minute, 300,000 tokens a minute and 1 stream on Gemma 4 VL 26B. A flat-plan session runs one request at a time. All return HTTP 429 when exceeded.

## Keep reading

-   [How to handle LLM API 429 errors: backoff, jitter and limiters](https://broadrouter.com/blog/handle-llm-api-429-rate-limits/)
-   [How to run parallel coding agents on a flat-rate LLM API](https://broadrouter.com/blog/run-parallel-coding-agents-flat-rate/)
-   [LLM batch processing without a Batch API: a resumable runner](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/)
-   [How to choose an LLM API provider: a 20-point checklist](https://broadrouter.com/blog/choose-llm-api-provider-checklist/)
-   [Free LLM API credit: how far a starting credit really goes](https://broadrouter.com/blog/free-llm-api-credit/)
-   [A private endpoint starts with a clear workload](https://broadrouter.com/blog/private-endpoint-planning/)
-   [Before fine-tuning: define the problem to solve](https://broadrouter.com/blog/fine-tuning-readiness/)
-   [Guide: BroadNet Inference error codes and when to retry](https://broadrouter.com/guides/errors-and-retries/)
-   [Guide: How the unlimited LLM API plans work for agents](https://broadrouter.com/guides/unlimited-llm-api-sessions/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-api-rate-limits-by-provider&utm_content=page-cta) ·

**Sources**

-   [OpenAI API docs, rate limits and usage tiers (checked 2026-11-15)](https://developers.openai.com/api/docs/guides/rate-limits)
-   [Claude API docs, rate limits, spend caps, cache-aware ITPM and ramp limits (checked 2026-11-15)](https://platform.claude.com/docs/en/api/rate-limits)
-   [Google AI Studio docs, Gemini API rate limits and usage tiers (checked 2026-11-15)](https://aistudio.google.com/docs/rate-limits)
-   [Mistral docs, usage limits (checked 2026-11-15)](https://docs.mistral.ai/admin/billing-usage/usage-limits)
-   [Groq docs, rate limits table and headers (checked 2026-11-15)](https://console.groq.com/docs/rate-limits)
-   [Together AI docs, rate limits (checked 2026-11-15)](https://docs.together.ai/docs/rate-limits)
-   [Fireworks AI docs, rate limits and spending tiers (checked 2026-11-15)](https://docs.fireworks.ai/guides/quotas_usage/rate-limits)
-   [DeepInfra docs, rate limits (checked 2026-11-15)](https://docs.deepinfra.com/account/rate-limits)
-   [Cerebras inference docs, rate limits by tier (checked 2026-11-15)](https://inference-docs.cerebras.ai/support/rate-limits)
-   [DeepSeek API docs, rate limit and concurrency (checked 2026-11-15)](https://api-docs.deepseek.com/quick_start/rate_limit)
-   [DeepSeek API docs, models and pricing: model IDs and versions (checked 2026-11-15)](https://api-docs.deepseek.com/quick_start/pricing)
-   [OpenRouter docs, API limits (checked 2026-11-15)](https://openrouter.ai/docs/api_reference/limits)
-   [Cohere docs, rate limits (checked 2026-11-15)](https://docs.cohere.com/docs/rate-limits)
-   [xAI docs, rate limits and tiers (checked 2026-11-15)](https://docs.x.ai/developers/rate-limits)
-   [BroadNet Inference API reference, limits (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-api-rate-limits-by-provider&utm_content=sources)
-   [BroadNet Inference plans, sessions (checked 2026-11-15)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-llm-api-rate-limits-by-provider&utm_content=sources)
