Rate Limiting

{
  "message": "Too many requests",
  "request_id": "0e8400-e29b..."
}

async function makeRequestWithBackoff(url, options, maxRetries = 5) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      const response = await fetch(url, options);

      // Success
      if (response.ok) {
        return await response.json();
      }

        // Rate limited
        if (response.status === 429) {
          const retryAfter = response.headers.get('Retry-After');

          // Use retry-after header if available, otherwise exponential backoff
          const waitTime = retryAfter
            ? parseInt(retryAfter) * 1000
            : Math.min(1000 * Math.pow(2, retries), 60000);

          console.log(`Rate limited. Retrying after ${waitTime}ms...`);
          await sleep(waitTime);
          retries++;
          continue;
        }

      // Other errors
      const error = await response.json();
      throw new Error(error.message);

    } catch (error) {
      if (retries === maxRetries - 1) {
        throw new Error(`Max retries exceeded: ${error.message}`);
      }
      retries++;
    }
  }
}

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

// Usage
const result = await makeRequestWithBackoff(
  'https://api.gameboost.com/v2/orders',
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    }
  }
);

class RateLimitedAPIClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.gameboost.com/v2';
    this.remaining = null;
    this.resetTime = null;
  }

  async request(endpoint, options = {}) {
    // Proactively wait if we're close to the limit
    await this.checkRateLimit();

    const url = `${this.baseUrl}${endpoint}`;
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    };

    const response = await fetch(url, { ...options, headers });

    // Update rate limit info from headers
    this.updateRateLimitInfo(response.headers);

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      await this.sleep(parseInt(retryAfter) * 1000);
      return this.request(endpoint, options); // Retry
    }

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message);
    }

    return await response.json();
  }

  updateRateLimitInfo(headers) {
    this.remaining = parseInt(headers.get('X-RateLimit-Remaining'));
    this.resetTime = parseInt(headers.get('X-Ratelimit-Reset'));
  }

  async checkRateLimit() {
    // If we have less than 10% of requests remaining, wait
    if (this.remaining !== null && this.remaining < 10) {
      const now = Math.floor(Date.now() / 1000);
      const waitTime = Math.max(0, this.resetTime - now);

      if (waitTime > 0) {
        console.log(`Proactively waiting ${waitTime}s to avoid rate limit...`);
        await this.sleep(waitTime * 1000);
      }
    }
  }

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

// Usage
const client = new RateLimitedAPIClient(apiKey);
const orders = await client.request('/orders');