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

​
Current Limits

Free Plan

  • 100 requests per hour
  • 1,000 requests per day
  • No concurrent requests

Pro Plan

  • 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?

Get Support

Contact us if you’re consistently hitting rate limits or need higher quotas
⌘I