Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.g-tateth.com/llms.txt

Use this file to discover all available pages before exploring further.

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 };
}