Rate limits

Prefetch limits how many requests your API key can have running at the same time. Paid plans have no per-minute cap: as soon as one request finishes, the next one can start.

Plan	Price	Credits a month	Concurrent requests	Requests a minute
Free	$0	1,000	1	30
Starter	$11 a month, or $108 a year	10,000	10	No limit
Pro	$49 a month, or $490 a year	75,000	50	No limit
Growth	$149 a month, or $1,490 a year	300,000	150	No limit
Scale	$399 a month, or $3,990 a year	1,000,000	500	No limit
Enterprise	Custom	From 2,000,000	Custom	No limit

Going over a limit returns 429 Too Many Requests. A refused request costs no credits.

Concurrency limit

Each key can have a fixed number of requests in flight. A request that would go over it is refused straight away with 429. It isn’t queued.

{
  "error": "Concurrency limit exceeded — too many requests in flight",
  "limit": 50,
  "error_code": "CONCURRENCY_LIMITED",
  "retryable": true
}

Every response that counts toward the limit carries two headers, so you can pace yourself:

Header	Meaning
`X-Concurrency-Limit`	How many requests this key can run at once
`X-Concurrency-Running`	How many are running now, including this one

The simplest way to stay under the limit is a worker pool the size of your plan’s limit. Each worker sends its next request when its last one finishes. For hundreds of URLs, a batch is easier: one request, and Prefetch manages the concurrency for you.

Per-minute limit

The Free plan allows 30 requests a minute, counted over a sliding 60-second window. Paid plans have a high safety ceiling that stops runaway loops, which ordinary traffic never reaches. Going over either one returns:

{
  "error": "Rate limit exceeded",
  "retryAfterSeconds": 12,
  "error_code": "RATE_LIMITED",
  "retryable": true
}

The response has a Retry-After header in seconds, plus X-RateLimit-Limit and X-RateLimit-Remaining.

Requests without an API key

Requests with no API key or token are limited to 300 a minute per IP address. If one IP address sends 60 unknown API keys or invalid tokens in a minute, it’s refused with 429 and a Retry-After header for the rest of that minute. Requests with a valid key never count toward either limit.

Handling 429 responses

Wait for Retry-After when it’s there, and back off exponentially when it isn’t:

async function fetchWithRetry(url, options, maxRetries = 4) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const res = await fetch(url, options);
    if (res.status !== 429 || attempt === maxRetries) return res;

    const retryAfter = Number(res.headers.get("Retry-After"));
    const waitMs = retryAfter > 0 ? retryAfter * 1000 : 2 ** attempt * 1000; // 1s, 2s, 4s, 8s
    await new Promise((resolve) => setTimeout(resolve, waitMs));
  }
}

import time
import requests

def fetch_with_retry(url, params, headers, max_retries=4):
    for attempt in range(max_retries + 1):
        r = requests.get(url, params=params, headers=headers)
        if r.status_code != 429 or attempt == max_retries:
            return r

        retry_after = r.headers.get("Retry-After")
        time.sleep(int(retry_after) if retry_after else 2 ** attempt)  # 1s, 2s, 4s, 8s

Staying within limits

Use /enrich instead of separate /brand, /company and /classify calls. It’s one request instead of three.
Cache what doesn’t change. Brand and company data is stable for days. See Caching.
Don’t fetch the same domain twice in a short window.
Match your plan’s concurrency. Run as many requests in parallel as your plan allows, and no more. Extra requests are refused, not queued.

Get started

Agents and MCP

Company data

Web data

Jobs and monitoring

Platform

Going to production

Concurrency limit

Per-minute limit

Requests without an API key

Handling 429 responses

Staying within limits