Rate limits and quotas
Three limits apply to every organisation: requests per minute, requests per calendar month, and records per UTC day from endpoints that return lists. All three are shared by every key in the organisation. Response headers tell you where you stand.
What are the limits per plan?#
| Plan | Requests per minute | Requests per month | Records per day | Max page size |
|---|---|---|---|---|
| Sandbox | 10 | 100 | 500 | 50 |
| Starter | 60 | 50,000 | 50,000 | 200 |
| Pro | 300 | 500,000 | 500,000 | 500 |
| Enterprise | 1,200 | Unlimited | Unlimited | 500 |
GET /v1/plans returns these values (except the record budget and page size), and GET /v1/me returns your current plan and requests used this month.
How is the per-minute limit counted?#
Every authenticated request to /v1 and every /mcp request counts. Requests are counted per organisation in one-minute windows; X-RateLimit-Reset gives the end of the current window. Over the limit, the API answers 429 with code rate_limited and a Retry-After header in seconds.
How does the monthly quota work?#
- The quota counts requests from 00:00 UTC on the first of the month. It resets at the start of the next month.
- Requests that fail with
400,404or422still count. Requests refused with429do not. - When it is used up, every request gets
429 quota_exceededuntil the month ends or you upgrade. There is noRetry-After, because waiting a few seconds does not help. - Enterprise has no monthly quota, so the
X-Quota-*headers are absent.
What is the daily record budget?#
Endpoints that return records count how many they return, per organisation per UTC day. It stops bulk downloads; integrations that poll with since and filters stay far below it.
| Endpoint | Records counted |
|---|---|
GET /v1/signals | Signals in data |
GET /v1/events | Events in data |
GET /v1/airports/{iata} | Active and country signals returned |
GET /v1/carriers/{code} | Active outages and past events returned |
MCP list_signals, list_events | Rows returned |
The call that crosses the budget is still answered in full; the next one gets 429 daily_data_limit. The budget resets at 00:00 UTC. Exposure checks, watchlists, single signals, forecasts and webhooks do not use it.
Which headers should I watch?#
| Header | Meaning | Sent on |
|---|---|---|
X-RateLimit-Limit | Requests allowed per minute on your plan. | Every authenticated response |
X-RateLimit-Remaining | Requests left in the current minute. | Every authenticated response |
X-RateLimit-Reset | Unix time (seconds) when the current window ends. | Every authenticated response |
X-Quota-Limit | Requests allowed this calendar month. | Plans with a monthly quota |
X-Quota-Remaining | Requests left this month, after this one. | Plans with a monthly quota |
X-Data-Records-Remaining-Today | Records left in today's budget, after this response. | Record-returning endpoints, on plans with a daily budget |
Retry-After | Seconds to wait before the next request. | 429 rate_limited |
X-Limit-Reason | rate or quota: which limit refused the request. | 429 rate_limited and 429 quota_exceeded |
A response from GET /v1/signals on the Starter plan:
HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: no-store
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 57
X-RateLimit-Reset: 1795046460
X-Quota-Limit: 50000
X-Quota-Remaining: 48211
X-Data-Records-Remaining-Today: 49850How should I back off?#
- On
429 rate_limited, wait the number of seconds inRetry-After, then retry. - On
5xxor a timeout, retry with exponential backoff and jitter, a few times at most. - On
quota_exceededordaily_data_limit, stop and alert someone. Retrying does not help. - Spread work out: if
X-RateLimit-Remainingis low, slow down before you hit zero.
// Retries 429 rate_limited and 5xx with backoff. Does not retry quota or daily budget errors.
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
export async function disruptFetch(path, init = {}, maxAttempts = 5) {
for (let attempt = 1; ; attempt++) {
const res = await fetch(`https://app.disruptapi.com${path}`, {
...init,
headers: { Authorization: `Bearer ${process.env.DISRUPT_KEY}`, ...init.headers },
signal: AbortSignal.timeout(30_000),
});
if (res.ok) return res.json();
const body = await res.json().catch(() => ({}));
const code = body.error?.code;
const retryable = res.status >= 500 || code === "rate_limited";
if (!retryable || attempt >= maxAttempts) {
throw new Error(`${res.status} ${code ?? res.statusText}: ${body.error?.message ?? ""}`);
}
const retryAfter = Number(res.headers.get("Retry-After"));
const backoff = Math.min(30_000, 500 * 2 ** (attempt - 1)) * (0.5 + Math.random() / 2);
await sleep(retryAfter > 0 ? retryAfter * 1000 : backoff);
}
}import os
import random
import time
import requests
RETRYABLE = {"rate_limited"}
def disrupt_get(path: str, params=None, max_attempts: int = 5):
for attempt in range(1, max_attempts + 1):
resp = requests.get(
f"https://app.disruptapi.com{path}",
headers={"Authorization": f"Bearer {os.environ['DISRUPT_KEY']}"},
params=params,
timeout=30,
)
if resp.ok:
return resp.json()
try:
code = resp.json().get("error", {}).get("code")
except ValueError:
code = None
retryable = resp.status_code >= 500 or code in RETRYABLE
if not retryable or attempt == max_attempts:
resp.raise_for_status()
retry_after = resp.headers.get("Retry-After")
delay = int(retry_after) if retry_after else min(30, 0.5 * 2 ** (attempt - 1)) * random.uniform(0.5, 1)
time.sleep(delay)
data =disrupt_get("/v1/signals", {"min_severity": "severe", "limit": 50})
print(len(data["data"]), "signals")How do I use fewer requests?#
- Use webhooks instead of polling for changes.
- Put many items in one exposure check (up to 500) instead of one call per item.
- Poll
GET /v1/signalswithsinceset to the latestupdated_atyou have, and with filters. - Check usage by day, route and key with
GET /v1/usage.
Last updated 2026-11-18. Questions or a mistake on this page? Contact us.