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

# Rate limits

> Rate limits by plan (60-1,000 requests/min), response headers, retry strategies with code examples, and best practices for caching and batch endpoints.

Rate limits are enforced per API key on a <Tooltip tip="A sliding time window that continuously moves forward. Your request count resets gradually rather than all at once, preventing burst traffic at window boundaries.">rolling 60-second window</Tooltip>.

## Limits by plan

| Plan  | Requests per minute |
| ----- | ------------------- |
| Free  | 60                  |
| Pro   | 300                 |
| Scale | 1,000               |

## Response headers

Every API response includes rate limit headers:

| Header                  | Description                                 |
| ----------------------- | ------------------------------------------- |
| `X-RateLimit-Limit`     | Maximum requests per window                 |
| `X-RateLimit-Remaining` | Remaining requests in current window        |
| `Retry-After`           | Seconds until reset (only on 429 responses) |

## How to handle rate limits

When you exceed the limit, the API returns HTTP `429` (see [error codes](/docs/api-reference/errors#error-codes) for the full list):

```json theme={null}
{
  "success": false,
  "error": {
    "code": "RATE_LIMIT",
    "message": "Rate limit exceeded. Retry after 12 seconds."
  }
}
```

### Retry strategy

<CodeGroup>
  ```python Python theme={null}
  import time
  import requests

  def api_request_with_retry(url, headers, max_retries=3):
      for attempt in range(max_retries):
          response = requests.get(url, headers=headers)
          if response.status_code == 429:
              retry_after = int(response.headers.get("Retry-After", 10))
              time.sleep(retry_after)
              continue
          return response
      raise Exception("Max retries exceeded")
  ```

  ```javascript JavaScript theme={null}
  async function apiRequestWithRetry(url, headers, maxRetries = 3) {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
      const response = await fetch(url, { headers });
      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("Retry-After") || "10");
        await new Promise((r) => setTimeout(r, retryAfter * 1000));
        continue;
      }
      return response;
    }
    throw new Error("Max retries exceeded");
  }
  ```
</CodeGroup>

<Tip>
  Use the `Retry-After` header to implement exponential backoff. Wait the specified number of seconds before retrying.
</Tip>

## Best practices

<CardGroup cols={3}>
  <Card title="Cache responses" icon="database">
    Tech stacks don't change every minute. Cache domain lookups for at least 24 hours.
  </Card>

  <Card title="Use batch endpoints" icon="layer-group">
    `/v1/technologies/lookup` and `/v1/companies/batch` let you look up multiple items in a single request.
  </Card>

  <Card title="Monitor usage" icon="chart-simple">
    Check `/v1/usage` to track request counts and credit consumption.
  </Card>
</CardGroup>

## Related pages

<CardGroup cols={2}>
  <Card title="Authentication" icon="lock" href="/docs/api-reference/authentication">
    Set up your API key for Bearer token authentication.
  </Card>

  <Card title="Credits" icon="coins" href="/docs/api-reference/credits">
    Credit costs per endpoint and plan details.
  </Card>

  <Card title="Errors" icon="triangle-exclamation" href="/docs/api-reference/errors">
    Error codes including 429 rate limit responses.
  </Card>

  <Card title="Account API" icon="key" href="/docs/api-reference/endpoints/account">
    Monitor usage statistics and credit balance.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What happens when I exceed the rate limit?">
    The API returns HTTP `429` with a `Retry-After` header indicating how many seconds to wait. Your request isn't charged credits. Wait the specified time and retry. See [errors](/docs/api-reference/errors) for the full error response format.
  </Accordion>

  <Accordion title="Are rate limits per key or per organization?">
    Rate limits are enforced per API key on a rolling 60-second window. Since each organization has a single API key, the limit applies to all requests from your organization combined.
  </Accordion>

  <Accordion title="How do I avoid hitting rate limits?">
    Cache domain lookups for at least 24 hours (tech stacks don't change that often). Use batch endpoints like `/v1/companies/batch` and `/v1/technologies/lookup` to process multiple items in one request. Monitor your usage with the free `/v1/usage` endpoint.
  </Accordion>

  <Accordion title="Do rate-limited requests consume credits?">
    No. When the API returns HTTP `429`, your request isn't charged any credits. You only pay credits for successful responses. Wait the number of seconds in the `Retry-After` header and resend your request.
  </Accordion>

  <Accordion title="Can I request a higher rate limit?">
    The Scale plan supports up to 1,000 requests per minute. If you need more throughput, contact TechnologyChecker for enterprise-level rate limits. Enterprise plans include custom request quotas alongside higher credit allocations. Visit [technologychecker.io](https://technologychecker.io) to discuss your requirements.
  </Accordion>

  <Accordion title="How does the rolling 60-second window work?">
    Instead of resetting your request count at fixed intervals, the API uses a sliding window. Each request's timestamp is tracked, and the count includes only requests from the last 60 seconds. This prevents burst traffic at window boundaries and gives you a steady, predictable request allowance.
  </Accordion>
</AccordionGroup>