rate-limits.mdx

title	Rate Limits
description	Understanding and handling API rate limits

WebLinq implements rate limiting to ensure fair usage across all users. Rate limits are enforced per API key.

Current Limits

- 100 requests per hour - 1,000 requests per day - No concurrent requests - 1,000 requests per hour - 10,000 requests per day - 5 concurrent requests

Need higher limits? Contact us about enterprise plans.

Rate Limit Headers

All responses include rate limit information:

X-RateLimit-Limit: 100           # Total requests allowed per hour
X-RateLimit-Remaining: 85        # Remaining requests in current window
X-RateLimit-Reset: 1625097600    # Timestamp when limit resets

Handling Rate Limits

When you exceed your rate limit, you'll receive a 429 Too Many Requests response:

{
  "success": false,
  "error": {
    "message": "Rate limit exceeded. Please retry after 60 seconds.",
    "code": "rate_limit_exceeded"
  }
}

Best Practices

Implement Retry Logic

Use exponential backoff when handling rate limits:

async function makeRequest(url, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, {
        headers: { Authorization: 'Bearer YOUR_API_KEY' },
      });

      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After') || 60;
        await sleep(retryAfter * 1000);
        continue;
      }

      return await response.json();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await sleep(Math.pow(2, i) * 1000);
    }
  }
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

Monitor Usage

Track your API usage to stay within limits:

function trackRateLimit(response) {
  const limit = response.headers.get('X-RateLimit-Limit');
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');

  console.log(`Rate limit: ${remaining}/${limit} remaining. Resets at ${new Date(reset * 1000)}`);
}

Space Out Requests

For bulk operations, add delays between requests:

async function processBulkUrls(urls) {
  const results = [];

  for (const url of urls) {
    const result = await makeRequest(url);
    results.push(result);

    // Wait 1 second between requests for free plan (100/hour = ~36 seconds per request safe rate)
    await sleep(1000);
  }

  return results;
}

Need Help?

Contact us if you're consistently hitting rate limits or need higher quotas