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?#

PlanRequests per minuteRequests per monthRecords per dayMax page size
Sandbox1010050050
Starter6050,00050,000200
Pro300500,000500,000500
Enterprise1,200UnlimitedUnlimited500

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, 404 or 422 still count. Requests refused with 429 do not.
  • When it is used up, every request gets 429 quota_exceeded until the month ends or you upgrade. There is no Retry-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.

EndpointRecords counted
GET /v1/signalsSignals in data
GET /v1/eventsEvents 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_eventsRows 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?#

HeaderMeaningSent on
X-RateLimit-LimitRequests allowed per minute on your plan.Every authenticated response
X-RateLimit-RemainingRequests left in the current minute.Every authenticated response
X-RateLimit-ResetUnix time (seconds) when the current window ends.Every authenticated response
X-Quota-LimitRequests allowed this calendar month.Plans with a monthly quota
X-Quota-RemainingRequests left this month, after this one.Plans with a monthly quota
X-Data-Records-Remaining-TodayRecords left in today's budget, after this response.Record-returning endpoints, on plans with a daily budget
Retry-AfterSeconds to wait before the next request.429 rate_limited
X-Limit-Reasonrate or quota: which limit refused the request.429 rate_limited and 429 quota_exceeded

A response from GET /v1/signals on the Starter plan:

Response headersHTTP
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: 49850

How should I back off?#

  1. On 429 rate_limited, wait the number of seconds in Retry-After, then retry.
  2. On 5xx or a timeout, retry with exponential backoff and jitter, a few times at most.
  3. On quota_exceeded or daily_data_limit, stop and alert someone. Retrying does not help.
  4. Spread work out: if X-RateLimit-Remaining is low, slow down before you hit zero.
Retry with backoff
// 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);
  }
}

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/signals with since set to the latest updated_at you 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.