Guides
Rate Limits

Rate Limits

Rate limits help ensure fair usage and system stability. All API endpoints are subject to rate limiting.

Rate Limit Headers

Every API response includes rate limit information in the headers:

  • X-RateLimit-Limit: Maximum number of requests allowed per time window
  • X-RateLimit-Remaining: Number of requests remaining in the current window
  • X-RateLimit-Reset: Unix timestamp when the rate limit resets

Default Limits

  • Per minute: 100,000 requests
  • Per hour: 100,000,000 requests
  • Per consumer: Limits are applied per API key

Rate Limit Exceeded

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

{
  "detail": "Rate limit exceeded. Please try again later."
}

Handling Rate Limits

1. Check Rate Limit Headers

const response = await fetch('https://api.translateplus.io/v2/translate', {
  method: 'POST',
  headers: {
    'X-API-KEY': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    text: 'Hello',
    source: 'en',
    target: 'fr'
  })
});
 
const remaining = response.headers.get('X-RateLimit-Remaining');
const resetTime = response.headers.get('X-RateLimit-Reset');
 
console.log(`Remaining requests: ${remaining}`);
console.log(`Rate limit resets at: ${new Date(resetTime * 1000)}`);

2. Implement Exponential Backoff

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);
    
    if (response.status === 429) {
      const resetTime = parseInt(response.headers.get('X-RateLimit-Reset'));
      const waitTime = (resetTime * 1000) - Date.now();
      await new Promise(resolve => setTimeout(resolve, waitTime));
      continue;
    }
    
    return response;
  }
  
  throw new Error('Max retries exceeded');
}

Best Practices

  1. Monitor rate limit headers to avoid hitting limits
  2. Implement exponential backoff for 429 responses
  3. Use batch endpoints when possible to reduce request count
  4. Cache responses when appropriate to minimize API calls