How to fix Error: HTTP 429 Too Many Requests (rate limited) in Node.js

const axios = require('axios');

axios.get('https://api.example.com/data')
  .catch(error => {
    if (error.response?.status === 429) {
      const retryAfter = error.response.headers['retry-after'];
      console.log('Rate limited. Retry after:', retryAfter, 'seconds');

      // Also check other rate limit headers
      const remaining = error.response.headers['x-ratelimit-remaining'];
      const reset = error.response.headers['x-ratelimit-reset'];
      console.log('Remaining requests:', remaining);
      console.log('Limit resets at:', new Date(reset * 1000));
    }
  });

async function fetchWithRetry(url, maxRetries = 3) {
  let retries = 0;
  let delay = 1000; // Start with 1 second

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

      if (response.status === 429) {
        const retryAfter = response.headers.get('retry-after');
        const waitTime = retryAfter
          ? parseInt(retryAfter) * 1000
          : delay;

        console.log(`Rate limited. Waiting ${waitTime}ms before retry ${retries + 1}/${maxRetries}`);
        await new Promise(resolve => setTimeout(resolve, waitTime));

        retries++;
        delay *= 2; // Exponential backoff
        continue;
      }

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      if (retries === maxRetries - 1) throw error;
      retries++;
      await new Promise(resolve => setTimeout(resolve, delay));
      delay *= 2;
    }
  }

  throw new Error('Max retries exceeded');
}

npm install axios axios-retry

const axios = require('axios');
const axiosRetry = require('axios-retry');

// Configure axios with retry logic
axiosRetry(axios, {
  retries: 3,
  retryDelay: (retryCount, error) => {
    // Check for Retry-After header
    const retryAfter = error.response?.headers['retry-after'];
    if (retryAfter) {
      return parseInt(retryAfter) * 1000;
    }

    // Otherwise use exponential backoff
    return axiosRetry.exponentialDelay(retryCount);
  },
  retryCondition: (error) => {
    // Retry on network errors or 429 status
    return axiosRetry.isNetworkOrIdempotentRequestError(error)
      || error.response?.status === 429;
  },
});

// Make requests normally - retries happen automatically
axios.get('https://api.example.com/data')
  .then(response => console.log(response.data))
  .catch(error => console.error('Request failed after retries:', error.message));

class RequestQueue {
  constructor(requestsPerSecond = 10) {
    this.queue = [];
    this.processing = false;
    this.interval = 1000 / requestsPerSecond;
    this.lastRequestTime = 0;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;

    while (this.queue.length > 0) {
      const now = Date.now();
      const timeSinceLastRequest = now - this.lastRequestTime;

      if (timeSinceLastRequest < this.interval) {
        await new Promise(resolve =>
          setTimeout(resolve, this.interval - timeSinceLastRequest)
        );
      }

      const { requestFn, resolve, reject } = this.queue.shift();
      this.lastRequestTime = Date.now();

      try {
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      }
    }

    this.processing = false;
  }
}

// Usage
const queue = new RequestQueue(5); // 5 requests per second

async function makeApiCall(id) {
  return queue.add(() =>
    fetch(`https://api.example.com/items/${id}`)
      .then(res => res.json())
  );
}

// Process 100 items with automatic throttling
const results = await Promise.all(
  Array.from({ length: 100 }, (_, i) => makeApiCall(i))
);

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 300 }); // 5 minute default TTL

async function cachedFetch(url, ttl = 300) {
  const cached = cache.get(url);
  if (cached) {
    console.log('Returning cached response for:', url);
    return cached;
  }

  try {
    const response = await fetch(url);

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    const data = await response.json();

    // Check for cache-control headers
    const cacheControl = response.headers.get('cache-control');
    if (cacheControl?.includes('max-age=')) {
      const maxAge = parseInt(cacheControl.match(/max-age=(\d+)/)[1]);
      cache.set(url, data, maxAge);
    } else {
      cache.set(url, data, ttl);
    }

    return data;
  } catch (error) {
    console.error('Fetch error:', error.message);
    throw error;
  }
}

// Usage
const data = await cachedFetch('https://api.example.com/data');

class CircuitBreaker {
  constructor(threshold = 5, timeout = 60000) {
    this.failureCount = 0;
    this.threshold = threshold;
    this.timeout = timeout;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.nextAttempt = Date.now();
  }

  async execute(requestFn) {
    if (this.state === 'OPEN') {
      if (Date.now() < this.nextAttempt) {
        throw new Error('Circuit breaker is OPEN - too many rate limit failures');
      }
      this.state = 'HALF_OPEN';
    }

    try {
      const result = await requestFn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure(error);
      throw error;
    }
  }

  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }

  onFailure(error) {
    if (error.response?.status === 429) {
      this.failureCount++;

      if (this.failureCount >= this.threshold) {
        this.state = 'OPEN';
        this.nextAttempt = Date.now() + this.timeout;
        console.log(`Circuit breaker OPEN. Waiting ${this.timeout}ms`);
      }
    }
  }
}

// Usage
const breaker = new CircuitBreaker(3, 30000); // Open after 3 failures, wait 30s

async function makeRequest(id) {
  return breaker.execute(() =>
    axios.get(`https://api.example.com/items/${id}`)
  );
}