Free tool · no sign-up

LLM Rate Limit Calculator: which limit binds, and how long the job takes

With 600 requests per minute and 400,000 tokens per minute, a 4,000-token request is capped at 100 requests per minute by TPM, not 600 by RPM. At an 80% safety margin you can sustain 80 requests per minute, and a 50,000-request batch takes about 10 hours 25 minutes.

Your limits

Advanced: daily token cap

Per-key limits are often not additive. Enter multiple keys only if your provider enforces limits per key rather than at the organization or project level.

See plans

Tokens per request is input plus the max_tokens reserve, not the tokens actually generated. Use your p95 request size, not the mean.

Result TPM binds

TPM binds at 100 RPM — 6× below the 600 RPM ceiling. At a 20% margin you can sustain 80 RPM, one request every 0.75 seconds, with 4 concurrent requests at a 2.5-second p95. 50,000 requests take about 10 h 25 m.
Tokens / request4,000
Effective RPM100
Safe sustained RPM80
Interval0.75 s
Concurrency4
Drain time10 h 25 m

Arithmetic only. It uses the limits you enter and does not know your provider's token accounting, retry rate or rolling-window behaviour. Treat the result as a plan, then verify against response headers.

Throughput grid: RPM implied by TPM

RPM implied by each TPM limit before the account's RPM cap. Divide by tokens per request, then apply your safety margin.
Tokens / request100K TPM200K TPM400K TPM1M TPM2M TPM
1,0001002004001,0002,000
2,000501002005001,000
4,0002550100250500
8,000122550125250
16,0006122562125
32,00036123162

Cells are TPM-derived RPM before the account's RPM cap and before any safety margin. The binding limit is the lower of this value and the RPM limit.

Two limits, one throughput number

Most hosted LLM APIs enforce at least two independent limits: requests per minute and tokens per minute. Some add requests per day, tokens per day, concurrent-request caps and separate limits for batch traffic. The limit that matters is the lower of the two converted to the same unit, which is almost always requests per minute.

rpm_from_tpm = TPM ÷ tokens_per_request
effective_rpm = min(RPM, rpm_from_tpm)

If rpm_from_tpm is below RPM, TPM binds. Adding requests will not help; each request makes the token ceiling arrive sooner. If rpm_from_tpm is above RPM, RPM binds and token size is irrelevant until you make requests much larger.

This is why “we have a 600 RPM limit” is not a capacity statement. At 4,000 tokens per request and 400,000 TPM, the real ceiling is 100 RPM. The account is six times smaller than the headline number suggests.

Tokens per request is not the token count you see

Rate limits are charged against the tokens the provider reserves for a request, and that number is usually input tokens plus max_tokens, not input plus the tokens actually generated. If you send a 1,000-token prompt with max_tokens: 4,000, many providers account for 5,000 tokens when admitting the request, then reconcile after completion. Check your provider's accounting; the details differ by API version and endpoint.

The practical consequence: lowering max_tokens raises your effective RPM. A workload at 1,000 input and 4,000 max output, limited by 400,000 TPM, gets 80 RPM. Set max_tokens to 1,000 and the same TPM limit admits 200 RPM. If your answers average 400 tokens, reserving 4,000 is buying headroom you do not need at four times the throughput cost.

There is a second consequence. Token counts are estimated before the request is tokenized, often from characters. A prompt that is 3,900 tokens by the provider's tokenizer can be counted as 4,100 at admission. That is why a request can pass your own count and still trip the limit.

Worked examples: three workloads, three binding limits

Three accounts with the same 600 RPM ceiling and different token limits. Safe RPM uses a 20% margin.
RPMTPMTokens / requestRPM from TPMWhich bindsSafe RPMIntervalBatch of 50KConcurrency at p95
600400,0004,000100TPM800.75 s625 min (10 h 25 m)4 at 2.5 s
6002,000,0001,5001,333RPM4800.125 s104 min (1 h 44 m)10 at 1.2 s
600400,0008,00050TPM401.5 s1,250 min (20 h 50 m)2 at 3.0 s

The first row is the common production shape: a healthy RPM allowance and a token ceiling that quietly cuts it by 6×. The third row is the same account after someone adds a 6,000-token RAG context to every request. Throughput halves, and the batch that took 10 hours now takes 21.

Concurrency is computed from Little's Law:

concurrency = ceil(target_RPS × p95_latency_seconds)

At 80 RPM, target RPS is 1.33. With a 2.5-second p95, you need 4 in-flight requests to sustain it. More concurrency does not raise the ceiling when TPM binds; it only fills the queue and makes the 429s arrive in bursts.

Why your 429 happens below the limit

A 429 below the published limit is normal. Seven mechanisms explain most of it:

  1. Sliding windows, not clock minutes. A limit of 600 RPM is often enforced over a rolling 60-second window. Sending 400 requests in the last 20 seconds of one minute and 300 in the first 10 seconds of the next puts 700 requests inside a rolling minute. The per-minute average is compliant; the window is not.
  2. Token reservation. As above, max_tokens is counted at admission. A prompt that looks like 2,000 tokens may be charged as 6,000, tripling the effective load.
  3. Burstiness. Even at a compliant average, a worker pool that fires 50 requests at once creates a spike no smoothed limiter can absorb. Add jitter and a token-bucket client-side limiter; do not rely on retry-after alone.
  4. Separate limits. Organizations, projects, API keys, models and batch queues can each carry their own limits. You can be under the organization limit and over the limit for the specific model you are calling. The hierarchy differs by provider.
  5. Retries. A retry is a new request. A 10% retry rate at 95% of the limit pushes you to 104.5%, so the retry storm sustains the throttling it is trying to escape. Cap retries, use exponential backoff with jitter, and shed load rather than amplify it.
  6. Concurrency caps. Some accounts limit in-flight requests separately from RPM. If concurrency is 10 and latency rises to 5 seconds, throughput falls to 2 RPS regardless of the RPM allowance.
  7. Tier changes. Limits are account-level and can change with spend, verification or a plan change. A limit that worked last month is not a guarantee this month. Read the response headers (for example x-ratelimit-limit-requests, x-ratelimit-remaining-tokens and retry-after) rather than trusting a number from a blog post. Header names differ by provider.

Concurrency is not throughput

Adding workers is the most common wrong fix. Throughput is bounded by the tightest of three things:

throughput_RPS = min(
  RPM ÷ 60,
  TPM ÷ (60 × tokens_per_request),
  concurrency ÷ latency_seconds
)

If TPM binds, doubling concurrency doubles the rate at which you hit the ceiling. If concurrency binds, raising RPM does nothing. The calculator tells you which term is smallest and by how much, so you fix the right one.

A useful diagnostic: measure the ratio of 429s to successful requests at increasing concurrency. If 429s rise while throughput is flat, you are past the binding limit and adding load. If throughput rises linearly with concurrency, concurrency is the constraint. If throughput plateaus with no 429s, the server or the network is the constraint.

Planning a batch

Batch jobs need a duration estimate, not a rate. The arithmetic is:

drain_minutes = requests ÷ safe_RPM
drain_hours = drain_minutes ÷ 60

For 50,000 requests at a safe 80 RPM, that is 625 minutes, or 10 hours 25 minutes. If the provider's batch endpoint has its own, higher limit, use that instead — batch quotas are often separate from synchronous quotas and are sometimes several times larger. Check the current batch guide rather than assuming synchronous limits apply.

Three planning rules make the estimate usable:

Reading the provider table

Provider limits are account-specific and change. A static table is therefore a starting point, not an answer. A useful row carries four things: the limit values, the scope (organization, project, model, tier), the source URL, and the date it was verified. A row without a date is a liability.

For Plugsky's own plans the values are published and stable:

Plugsky published plan caps, 19 Nov 2026. “Unlimited fair use” still has RPM, concurrency and max input/output limits.
PlanPrice/moRPMConcurrentRequests/dayTokens/dayMax input / output
Free$0302500250K32K / 2K
Hobby$812041,0002M64K / 8K
Starter$2024062,0005M128K / 16K
Builder$6060010Unlimited fair useUnlimited fair use256K / 32K
Scale$1201,20016UnlimitedUnlimited512K / 32K

Source: plugsky.com/pricing, retrieved 19 Nov 2026. Free-tier “new account” limits are lower for the first period; legacy accounts may have different daily terms. Concurrency and max input/output still apply on unlimited plans.

For third-party providers, do not copy a limit from a blog post. The calculator accepts your own numbers, and the table exists only to give a realistic starting range. Add a “check your console” link per provider and a visible verified date. If a value cannot be verified, leave it out rather than guessing.

What to do when the limit binds

When TPM binds, you have five levers, in order of cost:

  1. Reduce max_tokens. Free throughput if your answers are shorter than the reserve.
  2. Reduce input tokens. Trim retrieved context, summarise history, shorten tool schemas. This is the same work that reduces cost.
  3. Cache the prefix. Cached input tokens are often still counted against TPM, so caching helps cost more than throughput. Check your provider's accounting.
  4. Batch the deferrable traffic. Batch quotas are often separate and the discount is real, but the completion window is hours, not seconds.
  5. Raise the limit. A higher tier, a committed-use contract, or a provider with a higher TPM allowance. This is the only lever that changes the ceiling itself.

When RPM binds and TPM has headroom, the opposite applies: larger requests are efficient, and the constraint is request count. Combine small requests where the product allows, and use streaming to improve perceived latency without changing throughput.

Methodology

The calculator is arithmetic, not measurement. It uses the limits you enter, the token size you enter, and a safety margin you choose. It does not know your provider's actual accounting rules, your p95 latency or your retry rate. The default margin is 80% of the effective limit because rate limiters are not perfectly smooth and because a client that runs at 100% has no room for a retry.

Daily request and token caps are converted to a per-minute planning rate and can override the RPM/TPM headline. Per-key limits are not assumed to be additive. The provider table is compiled from the published pricing page; where a value is unavailable, the cell is omitted rather than guessed.

Related: LLM API cost calculator · context window calculator · API latency tester · OpenAI error decoder · free API limits tracker · plans and caps.

FAQ

What is the difference between RPM and TPM?

RPM caps how many requests you send per minute. TPM caps how many tokens those requests contain, including reserved output. The effective limit is the lower of the two after converting tokens to requests, which is why a 600 RPM account can behave like a 100 RPM account.

Why do I get 429 errors below the published limit?

The usual causes are a rolling window rather than a clock minute, max_tokens counted at admission, bursty traffic from a worker pool, per-model or per-key limits, and retries that amplify load. Read the rate-limit headers and retry-after value rather than trusting the headline number.

How do I calculate the concurrency I need?

Multiply the target requests per second by the p95 latency in seconds, then round up. At 80 RPM (1.33 RPS) and a 2.5-second p95, you need 4 in-flight requests. More concurrency does not help when TPM is the binding limit.

Do batch requests count against the same rate limit?

Often not. Many providers give batch traffic a separate, higher quota, and some count batch tokens differently. Check your provider's batch documentation and your account console; the calculator lets you enter the batch limits separately if you have them.

Want published RPM and concurrency caps instead of a surprise 429?

Plugsky plans start at $8/month. Builder is $60/month with unlimited fair use, 600 RPM, 10 concurrent requests and a 7-day money-back guarantee. Check the caps against your p95 request size first.

See plans and caps → Start free