Skip to main content
Rate limits help ensure fair usage and system stability. Limits are applied per API key based on your subscription plan.

​
Rate Limit Tiers

  • Starter/Standard: 500 requests/hour
  • Professional/Premium: 5,000 requests/hour
  • Enterprise: 50,000 requests/hour

​
Rate Limit Headers

Every API response includes rate limit information in the headers: 
X-RateLimit-Limit: 5000
X-RateLimit-Remaining: 4999
X-RateLimit-Reset: 1704067200
  • X-RateLimit-Limit: Your hourly limit
  • X-RateLimit-Remaining: Requests remaining in the current window
  • X-RateLimit-Reset: Unix timestamp when the limit resets

​
Rate Limit Errors

When you exceed your rate limit, you’ll receive a 429 Too Many Requests response: 
{
  "success": false,
  "error": "Rate limit exceeded",
  "code": "RATE_LIMIT_EXCEEDED",
  "retryAfter": 3600
}
The retryAfter field indicates how many seconds to wait before retrying.

​
Per-Key Rate Limits

You can set custom rate limits for individual API keys when creating them: 
{
  "name": "High Volume Key",
  "rateLimit": {
    "requests": 10000,
    "window": "1h"
  }
}
This allows you to have different rate limits for different use cases.

​
Best Practices

  1. Monitor your usage - Check the X-RateLimit-Remaining header
  2. Implement exponential backoff - When you hit rate limits, wait before retrying
  3. Use webhooks - Instead of polling, use webhooks for real-time updates
  4. Cache responses - Cache data that doesn’t change frequently
  5. Batch requests - Combine multiple operations when possible

​
Handling Rate Limits

​
Exponential Backoff

async function makeRequestWithRetry(url, options, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        continue;
      }
      
      return response;
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
    }
  }
}

​
Rate Limit Monitoring

function checkRateLimit(response) {
  const limit = parseInt(response.headers.get('X-RateLimit-Limit'));
  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
  const reset = parseInt(response.headers.get('X-RateLimit-Reset'));
  
  if (remaining < limit * 0.1) {
    console.warn('Rate limit warning: Only 10% remaining');
  }
  
  return { limit, remaining, reset };
}