Rate limiting helps ensure fair usage and protects against abuse while maintaining optimal API performance for all users.

​
How Rate Limiting Works

IP-Based Limits

Limits are applied per source IP address to prevent abuse from specific locations.

Token-Based Limits

Each API access token has its own rate limit allocation for fair resource distribution.

Endpoint-Specific Limits

Critical endpoints like license validation have additional protective limits.

​
Rate Limiting Factors

Rate limits are calculated based on:

​
Rate Limit Exceeded Response

When you exceed the rate limit, the API responds with: 
HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 60
The message may vary depending on the endpoint.

​
Handling 429 Too Many Requests

  1. Do Not Retry Immediately: Avoid sending repeated requests immediately after receiving a 429.
  2. Implement Exponential Backoff:
    • Wait for a short period (e.g., 1 second) before retrying.
    • If the request fails again, double the wait time (e.g., 2 seconds, then 4 seconds, etc.).
    • Continue this pattern up to a reasonable maximum delay.
  3. Review Your Request Patterns: Persistent 429 errors may indicate overly frequent calls. Optimize your integration to reduce unnecessary requests.

​
Best Practices

1

Implement Exponential Backoff

When you receive a 429 response, wait progressively longer between retries (e.g., 1s, 2s, 4s, 8s).
async function retryWithBackoff(apiCall, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await apiCall();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}
2

Cache API Responses

Reduce API calls by caching responses when appropriate, especially for license validation results.
3

Use Batch Operations

Where available, use batch endpoints to reduce the total number of API calls required.
4

Monitor Rate Limit Headers

Check for rate limit headers in responses to proactively adjust your request frequency.
Avoid polling endpoints unnecessarily. Implement webhook handlers where possible to receive real-time updates instead of frequent polling.
By following these guidelines, you can ensure a smoother experience while using the Keymint API.