Handling HTTP 429 Rate Limit Errors with Retry Strategy in NestJS

I’m currently integrating a third-party API in my NestJS application and facing challenges with HTTP 429 (Too Many Requests) rate limit errors. My requirement involves making parallel calls to the same API with different data. For larger batches, I’m hitting the rate limit, leading to 429 errors.

Here’s a simplified version of my approach:

async fetchData() {
  try {
    const response = await firstValueFrom(
      this.httpService.post('API_ENDPOINT', {}, { headers: {'Content-Type': 'application/json'} }),
    );
    return response.data;
  } catch (error) {
    console.log('error', error);
    return handleError(error);
  }
}

async fetchDataPromises() {
  const promises = [];
  for (let i = 0; i < 25; i++) {
    promises.push(() => this.fetchData());
  }
  return this.waitForAll(promises);
}

handleRejection(promise) {
  return promise().catch((error) => {
    console.error(error);
    return { error };
  });
}

async waitForAll(promises) {
  return Promise.all(promises.map(this.handleRejection));
}

I want to implement a strategy to wait and retry the failed requests until the rate limit is reset, ensuring all requests eventually complete successfully. I’m looking for advice on how to best handle this scenario in a NestJS application.

What are the best practices for managing and retrying requests after encountering a 429 error?
Is there a recommended way to implement a delay between retries in NestJS?
How can I efficiently manage the retry mechanism for a batch of requests to minimize the overall execution time while respecting the rate limit?
Any insights or examples on handling rate limits with retries in NestJS would be greatly appreciated. Thank you!

i was try axios-retry package and nestjs-axios-retry package . its works but i need best way to do it in large dataset

Handling HTTP 429 errors in a NestJS application, especially when dealing with large datasets and making parallel API requests, requires a sophisticated approach to rate limiting and retry logic.

Some considerations:

• Implement a Retry Mechanism with Exponential Backoff: Instead of
  retrying immediately after a failure, implement an exponential
  backoff strategy. This method involves waiting for progressively
  longer periods between each retry attempt, which can help to avoid
  hitting the rate limit repeatedly.
• Use Axios Interceptors for Retry Logic: Since you mentioned using
  Axios, you can leverage Axios interceptors to implement your retry
  mechanism. This allows you to intercept requests before they are sent
  and responses (including errors) when they are received, enabling a
  centralized way to handle retries.
• Centralize Rate Limit Handling: Create a service that manages API
  calls and incorporates logic to handle rate limits and retries. This
  service can track the number of requests made and adjust the
  frequency of outgoing requests to stay within the API’s rate limits.

import { Injectable } from ‘@nestjs/common’;

import { HttpService } from '@nestjs/axios';
import { AxiosResponse, AxiosError } from 'axios';
import { firstValueFrom } from 'rxjs';

@Injectable()
export class ApiService {
  constructor(private httpService: HttpService) {
    this.setupAxiosInterceptors();
  }

  setupAxiosInterceptors(): void {
    this.httpService.axiosRef.interceptors.response.use(undefined, async (error: AxiosError) => {
      const { config, response } = error;
      if (response && response.status === 429) {
        // Implement exponential backoff based on the retry attempt count
        const retryCount = config['axios-retry'] || 0;
        if (retryCount < this.maxRetries) {
          const delayTime = Math.pow(2, retryCount) * 1000; // Exponential backoff formula
          return new Promise((resolve) => {
            setTimeout(() => {
              resolve(this.httpService.axiosRef(config));
            }, delayTime);
          });
        }
      }
      return Promise.reject(error);
    });
  }

  async fetchData(): Promise<any> {
    try {
      const response: AxiosResponse = await firstValueFrom(
        this.httpService.post('API_ENDPOINT', {}, { headers: { 'Content-Type': 'application/json' } }),
      );
      return response.data;
    } catch (error) {
      console.error('error', error);
      throw error; // Rethrow to handle it outside or to let the interceptor catch it
    }
  }

  // Your existing logic for making parallel requests
  async fetchDataPromises() {
    // Your implementation
  }
}