> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enrow.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Rate Limits

> Enrow API rate limits per API key, the 429 response, and how to handle throttling with backoff and bulk endpoints

The Enrow API applies rate limits to ensure fair usage and maintain service quality. The limit is the same across all endpoints and all plans, it is enforced **per API key**, and it is measured in **requests per second (RPS)**. This page explains the default limits, what happens when you exceed them, and how to stay within quota when scaling up.

## What are the default rate limits?

Every POST endpoint allows **10 requests per second** per API key. The limit is identical across all endpoints and all plans:

| Endpoint                    | Rate Limit |
| --------------------------- | ---------- |
| `POST /email/find/single`   | 10 req/s   |
| `POST /email/find/bulk`     | 10 req/s   |
| `POST /email/verify/single` | 10 req/s   |
| `POST /email/verify/bulk`   | 10 req/s   |
| `POST /phone/single`        | 10 req/s   |
| `POST /phone/bulk`          | 10 req/s   |

GET endpoints are not rate limited, so retrieving results — for example the [single email result](/api-reference/email-finder/get-single-result) or [bulk results](/api-reference/email-finder/get-bulk-results) — does not count against your quota.

<Note>
  Rate limits are **per API key** and measured in **requests per second** (RPS). Each [API key](/authentication) has its own independent quota.
</Note>

## What happens when I exceed the rate limit?

When you exceed the rate limit, the API returns a `429 Too Many Requests` response:

```json theme={null}
{
  "message": "Too Many Requests"
}
```

The recommended way to handle a `429` is to implement exponential backoff — wait a progressively longer delay before each retry so the API key has time to fall back under the limit:

```javascript theme={null}
async function requestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);

    if (response.status === 429) {
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
      continue;
    }

    return response;
  }

  throw new Error('Max retries exceeded');
}
```

For the full list of response codes and how to handle them, see [Status codes](/status-codes) and [Error handling](/error-handling).

## How can I avoid hitting the rate limit?

The most effective way to stay within quota is to send fewer, larger requests and to receive results through webhooks instead of polling.

<AccordionGroup>
  <Accordion title="Use bulk endpoints">
    Instead of making 100 single requests, make 1 bulk request (up to 5,000 items for email, 3,000 for phone). A single bulk POST counts as 1 request against your rate limit.

    ```javascript theme={null}
    // ❌ 100 requests = 10 seconds at 10 RPS
    for (const contact of contacts) {
      await findEmail(contact);
    }

    // ✅ 1 request
    await findEmailsBulk(contacts);
    ```

    See [Find Bulk Emails](/api-reference/email-finder/find-bulk) and [Verify Bulk Emails](/api-reference/email-verifier/verify-bulk) to get started.
  </Accordion>

  <Accordion title="Use webhooks instead of polling">
    Polling the GET endpoint wastes your rate limit quota. Use [webhooks](/how-webhooks-work) to receive results automatically as soon as a search or verification completes.
  </Accordion>

  <Accordion title="Cache results">
    Store results to avoid redundant API calls for the same contact, which also saves [credits](/credits-billing).
  </Accordion>
</AccordionGroup>

## Can I get higher rate limits?

Yes. Enrow can increase your RPS on a case-by-case basis. Contact us at [api@enrow.io](mailto:api@enrow.io) with your use case and expected volume.

## FAQ

<AccordionGroup>
  <Accordion title="Are rate limits shared across endpoints?">
    No. The 10 req/s limit applies independently to each POST endpoint, and the quota is tracked **per API key** rather than per account.
  </Accordion>

  <Accordion title="Do GET requests count against the rate limit?">
    No. GET endpoints are not rate limited, so polling for results does not consume your RPS quota. That said, webhooks are still preferable to frequent polling.
  </Accordion>

  <Accordion title="Does a bulk request count as one request?">
    Yes. A single bulk POST counts as 1 request against your rate limit, even though it can contain up to 5,000 items for email or 3,000 for phone.
  </Accordion>

  <Accordion title="What status code signals a rate limit error?">
    A `429 Too Many Requests` response with the body `{ "message": "Too Many Requests" }`. Retry with exponential backoff. See [Error handling](/error-handling) for details.
  </Accordion>
</AccordionGroup>

## Next steps

<CardGroup cols={2}>
  <Card title="Find emails in bulk" icon="layer-group" href="/api-reference/email-finder/find-bulk">
    Run up to 5,000 email searches in a single request to save rate limit quota.
  </Card>

  <Card title="Webhooks" icon="bell" href="/how-webhooks-work">
    Receive results automatically instead of polling the GET endpoints.
  </Card>

  <Card title="Error handling" icon="triangle-exclamation" href="/error-handling">
    Handle 429 and other responses gracefully in your integration.
  </Card>

  <Card title="Credits & billing" icon="coins" href="/credits-billing">
    See how credits are consumed for each endpoint.
  </Card>
</CardGroup>