async-retry vs backoff vs promise-retry vs retry vs retry-axios vs retry-request
Strategic Retry Logic and Resilience Patterns in JavaScript
Search packages..
async-retrybackoffpromise-retryretryretry-axiosretry-requestSimilar Packages:

Strategic Retry Logic and Resilience Patterns in JavaScript

This comparison evaluates six prominent npm packages designed to handle transient failures in JavaScript applications through retry mechanisms. While they share the common goal of improving system resilience against network flakiness or temporary service unavailability, they differ significantly in their execution models (callbacks vs. promises), integration scope (generic utilities vs. HTTP client wrappers), and maintenance status. Some packages like retry and backoff represent older, callback-era patterns, while others like async-retry and promise-retry modernize these concepts for async/await workflows. Specialized wrappers like retry-axios and retry-request offer drop-in solutions for specific HTTP libraries but introduce tighter coupling. Understanding these distinctions is critical for architects deciding between building custom resilience logic versus adopting specialized, potentially fragile, third-party wrappers.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
async-retry01,918-305 years agoMIT
backoff0335-1111 years agoMIT
promise-retry0319-116 years agoMIT
retry01,258-235 years agoMIT
retry-axios051164.9 kB15 months agoApache-2.0
retry-request03,19616.3 kB605a month agoMIT

Strategic Retry Logic and Resilience Patterns in JavaScript

Building resilient frontend and Node.js applications means accepting that networks fail, APIs timeout, and services glitch. The difference between a crashing app and a seamless user experience often comes down to how you handle these transient errors. The JavaScript ecosystem offers several tools for this, ranging from low-level primitives to high-level HTTP wrappers. Let's dive into six specific packages—async-retry, backoff, promise-retry, retry, retry-axios, and retry-request—to understand when each belongs in your architecture.

🔄 Core Execution Models: Callbacks vs. Promises

The most fundamental split in this group is between older callback-based designs and modern promise-driven workflows. This dictates how the code reads and how it fits into your existing async/await structures.

retry is the grandfather of this list. It uses a callback pattern where you pass a function to attempt, and a separate callback to handle the result or error. It forces you into a nested structure that feels out of place in modern codebases.

// retry: Callback-based
const operation = new RetryOperation(retries);

operation.attempt(function(currentAttempt) {
  fetchData(function(err, result) {
    if (operation.retry(err)) {
      return;
    }
    console.log(result);
  });
});

backoff follows a similar legacy approach, focusing specifically on the timing strategy rather than the whole operation flow. You create a backoff instance and wire up events for when to try again.

// backoff: Event-driven callback
const backoff = require('backoff');
const fibBackoff = backoff.fibonacci();

fibBackoff.on('ready', function() {
  fetchData(function(err, result) {
    if (err) {
      fibBackoff.backoff(); // Trigger next attempt after delay
    } else {
      fibBackoff.reset();
      console.log(result);
    }
  });
});

fibBackoff.start();

promise-retry bridges the gap. It takes the logic of retry but wraps it so you can return promises. It still expects a function that returns a promise, but it handles the chaining internally.

// promise-retry: Promise wrapper
const promiseRetry = require('promise-retry');

promiseRetry(function(retry, number) {
  return fetchData()
    .catch(function(err) {
      if (number <= 3) {
        return retry(err); // Pass error to retry logic
      }
      throw err;
    });
}, { retries: 3 });

async-retry is the modern standard. It is built entirely around async/await. You pass an async function, and it handles the looping internally. The code looks synchronous and clean, which reduces cognitive load.

// async-retry: Native async/await
const retry = require('async-retry');

try {
  const result = await retry(
    async (bail) => {
      const res = await fetchData();
      if (res.status === 404) {
        bail(new Error('Not found')); // Stop retrying immediately
        return;
      }
      return res;
    },
    { retries: 3 }
  );
  console.log(result);
} catch (err) {
  console.error('Failed after all retries', err);
}

🌐 HTTP Specific Wrappers vs. Generic Utilities

A critical architectural decision is whether to use a generic tool that works for databases, file systems, and APIs, or a specialized tool tied to a specific HTTP library.

retry-axios is a specialized interceptor for Axios. It attaches directly to the Axios instance. This is convenient but creates a hard dependency on Axios. If you ever switch to fetch or ky, this logic becomes useless.

// retry-axios: Axios Interceptor
const axios = require('axios');
const setupRetry = require('retry-axios');

const client = axios.create();
setupRetry({ axios: client });

// Automatically retries failed requests on this instance
client.get('/api/data').then(res => console.log(res.data));

retry-request is similarly tied to the request library (and by extension, many Google Cloud Node.js clients). Since the request library itself is deprecated and unmaintained, relying on this wrapper introduces significant technical debt.

// retry-request: Tied to 'request' library
const request = require('retry-request');

request({ uri: 'https://api.example.com/data' }, function(err, res, body) {
  if (err) return console.error(err);
  console.log(body);
});

async-retry, promise-retry, retry, and backoff are generic. They don't care if you are fetching data, reading a file, or querying a database. This makes them more future-proof.

// async-retry: Generic usage (Database example)
await retry(async () => {
  return await db.query('SELECT * FROM users');
});

// async-retry: Generic usage (File system example)
await retry(async () => {
  return await fs.promises.readFile('config.json');
});

⚠️ Maintenance Status and Deprecation Risks

In architectural decisions, the lifespan of a library is as important as its features. Several packages in this list carry heavy warnings.

retry-request depends on request, which has been officially deprecated since 2020. Using this in a new project is strongly discouraged. The ecosystem has moved to node-fetch, axios, or native fetch. If you see this in a codebase, plan to migrate away from it.

backoff and retry show signs of stagnation. While they still work, they lack the ergonomic improvements of modern JavaScript. They are "safe" in legacy apps but poor choices for greenfield development because they force callback hell.

async-retry is actively maintained and widely adopted in the modern Node.js ecosystem (including by Vercel and other major platforms). It receives updates to match current JavaScript standards.

retry-axios is useful but risky. Its life cycle is tied to Axios's internal interceptor API. If Axios makes a breaking change to how interceptors handle errors, this package could break unexpectedly.

🎯 Controlling the Retry Flow

How do you decide when to stop retrying? Different packages offer different levels of control.

async-retry gives you a bail function. This is powerful because it lets you distinguish between "try again" errors (like a 503 Service Unavailable) and "stop now" errors (like a 404 Not Found or a validation error).

// async-retry: Precise control with bail
await retry(async (bail) => {
  const response = await fetch('/api/resource');
  
  if (response.status === 404) {
    // Don't retry for 404s
    bail(new Error('Resource missing'));
    return;
  }
  
  if (!response.ok) {
    // Throw to trigger a retry
    throw new Error('Server error, retrying...');
  }
  
  return response.json();
});

promise-retry relies on you calling the retry function passed into your callback. It is slightly more verbose to implement conditional logic compared to bail.

// promise-retry: Manual retry trigger
await promiseRetry((retry, number) => {
  return fetchData().catch(err => {
    if (err.status === 404) {
      throw err; // Stops retrying
    }
    if (number < 3) {
      return retry(err); // Continues retrying
    }
    throw err;
  });
});

retry-axios handles this via configuration objects where you define which status codes should trigger a retry. It is less flexible for complex logic but sufficient for standard HTTP patterns.

// retry-axios: Config-based control
setupRetry({
  axios: client,
  retryDelay: 1000,
  retryAttempts: 3,
  shouldRetry: (error) => {
    // Custom logic to decide retry
    return error.response && error.response.status === 503;
  }
});

📊 Summary of Trade-offs

Featureasync-retrypromise-retryretry / backoffretry-axiosretry-request
StyleAsync/AwaitPromisesCallbacksInterceptorCallback/Stream
ScopeGenericGenericGenericAxios OnlyRequest Only
MaintenanceActiveStableLegacy/StaleModerateDeprecated Risk
Controlbail() functionretry() callEvent/CallbackConfig ObjectConfig Object
Best ForModern AppsLegacy PromisesVery Old CodeAxios ProjectsGoogle Cloud Legacy

💡 The Architect's Recommendation

For nearly all modern frontend and Node.js projects, async-retry is the superior choice. It is framework-agnostic, meaning you can use it with fetch, axios, graphql, or database clients without locking yourself into a specific HTTP library. Its support for the bail pattern provides the clarity needed to handle complex error scenarios without nesting callbacks.

Reserve retry-axios only for quick prototypes where you are 100% certain Axios will remain your HTTP client forever. In large-scale enterprise applications, the coupling it introduces is often not worth the minor convenience.

Finally, treat retry-request, retry, and backoff as legacy artifacts. If you encounter them during maintenance, schedule time to refactor them into async-retry or native async/await loops. Building new features on top of deprecated or callback-heavy foundations slows down development and increases the risk of future breakage.

Resilience is essential, but it shouldn't come at the cost of code clarity or future flexibility. Choose tools that grow with your stack, not ones that anchor you to the past.

How to Choose: async-retry vs backoff vs promise-retry vs retry vs retry-axios vs retry-request

  • async-retry:

    Choose async-retry for modern, promise-based applications where you need a lightweight, generic utility to wrap any async operation (not just HTTP). It is the most robust choice for new projects requiring custom retry logic with clean async/await syntax and active maintenance.

  • backoff:

    Avoid choosing backoff for new projects as it relies on legacy callback patterns and appears largely unmaintained. Only consider it if you are refactoring a very old codebase that already depends on its specific exponential backoff strategy and cannot be easily migrated to promise-based alternatives.

  • promise-retry:

    Select promise-retry if your project already uses the retry package logic but requires a Promise interface, or if you need specific compatibility with npm-style retry behaviors. It is a solid middle-ground for generic promise retries but lacks the modern DX of async-retry.

  • retry:

    Do not use retry in new frontend or modern Node.js architectures. It is a foundational but outdated callback-based library. Use it only if you are maintaining legacy systems where changing the control flow from callbacks to promises is too risky or costly.

  • retry-axios:

    Use retry-axios only if you are strictly bound to the Axios ecosystem and need a quick, zero-config way to add retries to existing interceptors. Be aware that this adds a dependency on Axios internals, which may break if Axios updates its interceptor API significantly.

  • retry-request:

    Choose retry-request exclusively if your infrastructure relies heavily on the request library (which is itself deprecated) or Google Cloud libraries that depend on it. For any other HTTP client, this package is obsolete and should be avoided.

Similar Npm Packages to async-retry

async-retry is a utility library for retrying asynchronous functions in JavaScript. It provides a simple and flexible way to handle retries for operations that may fail intermittently, such as network requests or database operations. With async-retry, developers can easily specify the number of retries, delay between attempts, and conditions under which to retry, making it a powerful tool for improving the resilience of applications. However, there are several alternatives available that offer similar functionality. Here are a few noteworthy options:

  • p-retry is a promise-based retry utility that allows you to retry asynchronous functions with customizable options. It is designed to work seamlessly with promises, making it a great choice for modern JavaScript applications. p-retry provides a straightforward API for defining retry logic, including the number of retries, delay between attempts, and error handling. If you are looking for a lightweight and promise-centric solution for retrying asynchronous operations, p-retry is an excellent option.

  • promise-retry is another library that focuses on retrying promise-returning functions. It offers a simple API for defining retry logic, including options for maximum retries, delay, and exponential backoff. promise-retry is particularly useful for scenarios where you need to handle transient errors in asynchronous operations, such as API calls or database queries. If you prefer a library that emphasizes simplicity and ease of use, promise-retry is worth considering.

  • retry is a more general-purpose retry utility that can be used with both synchronous and asynchronous functions. It provides a flexible API for configuring retries, including options for maximum attempts, delay, and backoff strategies. retry is suitable for a wide range of use cases, making it a versatile choice for developers who need a robust retry mechanism. If you require a library that can handle both sync and async operations with customizable retry logic, retry is a solid option.

  • retry-axios is a specialized library designed to work with Axios, the popular HTTP client for JavaScript. It provides automatic retry functionality for failed HTTP requests, making it easy to handle transient errors in network communication. With retry-axios, you can configure retry options such as the number of attempts and delay between retries, all while leveraging the familiar Axios API. If you are using Axios for your HTTP requests and want to add retry capabilities, retry-axios is a great choice.

For a comprehensive comparison of these libraries, check out the link: Comparing async-retry vs p-retry vs promise-retry vs retry vs retry-axios.

Similar Npm Packages to backoff

backoff is a JavaScript library designed to implement exponential backoff strategies for retrying failed asynchronous operations. This is particularly useful in scenarios where you need to handle transient errors, such as network requests or API calls, that may succeed if retried after a certain delay. The backoff library provides a simple and flexible API to configure the retry strategy, including options for maximum retries, delay intervals, and jitter to avoid thundering herd problems.

While backoff is a solid choice for implementing retry logic, there are several alternatives available in the ecosystem that offer similar functionalities. Here are a few noteworthy options:

  • async-retry is a lightweight library that provides a simple way to retry asynchronous functions with customizable retry strategies. It allows you to specify the number of retries, delay intervals, and even a custom retry condition. async-retry is particularly useful for handling promises and can be easily integrated into existing asynchronous workflows, making it a great choice for developers looking for a straightforward retry mechanism.

  • exponential-backoff is a library that focuses specifically on implementing the exponential backoff algorithm. It provides a simple API to configure the backoff strategy, including options for maximum delay and jitter. This library is ideal for developers who want a dedicated solution for exponential backoff without additional features that may come with more comprehensive libraries.

  • promise-retry is another library that allows you to retry promise-returning functions with a customizable retry strategy. It supports both linear and exponential backoff strategies and provides options for maximum retries and delay intervals. promise-retry is a good choice for developers who want a straightforward way to handle retries for promises while maintaining control over the retry logic.

  • retry is a versatile library that provides a simple way to retry any function, including synchronous and asynchronous ones. It offers a variety of options for configuring the retry strategy, including exponential backoff, maximum retries, and delay intervals. retry is suitable for developers looking for a general-purpose retry mechanism that can handle both promise-based and callback-based functions.

To see how backoff compares with async-retry, exponential-backoff, promise-retry, and retry, check out the comparison: Comparing async-retry vs backoff vs exponential-backoff vs promise-retry vs retry.

Similar Npm Packages to promise-retry

promise-retry is a utility library that allows developers to retry asynchronous operations that return promises. This can be particularly useful for handling transient errors in network requests or other operations that may fail intermittently. By providing a simple API to specify the number of retries and the delay between attempts, promise-retry helps ensure that applications can gracefully handle failures and improve their resilience.

While promise-retry is a solid choice for retrying promises, there are several alternatives in the JavaScript ecosystem that offer similar functionality. Here are a few noteworthy options:

  • async-retry is a library designed for retrying asynchronous functions with a simple and flexible API. It allows developers to specify the number of retries, delay between attempts, and even customize the retry logic based on the type of error encountered. async-retry is particularly useful for scenarios where you need more control over the retry behavior and want to handle different types of errors differently.

  • p-retry is another lightweight library that focuses on retrying promises. It provides a straightforward API that allows you to specify the number of retries, delay, and a predicate function to determine if the operation should be retried based on the error. p-retry is a great choice for developers looking for a simple and effective way to implement retry logic in their applications without additional overhead.

  • promise-poller is a utility for polling asynchronous operations until they succeed or a specified timeout is reached. While it is not strictly a retry library, it can be used to repeatedly check the status of an operation at specified intervals. This is especially useful for scenarios where you need to wait for a resource to become available or for a condition to be met.

  • retry is a more general-purpose library for retrying functions, not limited to promises. It provides a flexible way to specify retry strategies, including exponential backoff and custom error handling. This library is suitable for developers who want a more comprehensive solution for retrying both synchronous and asynchronous operations.

  • retry-axios is an Axios interceptor that automatically retries failed HTTP requests. It integrates seamlessly with Axios, allowing developers to specify retry logic directly in their HTTP client configuration. If you are using Axios for making HTTP requests and want built-in retry functionality, retry-axios is an excellent choice.

To see how promise-retry compares with async-retry, p-retry, promise-poller, retry, and retry-axios, check out the comparison: Comparing async-retry vs p-retry vs promise-poller vs promise-retry vs retry vs retry-axios.

Similar Npm Packages to retry

retry is a versatile npm package designed to provide a simple way to retry asynchronous operations in JavaScript. This can be particularly useful in scenarios where network requests or other operations may fail intermittently and need to be retried. The retry package allows developers to specify the number of attempts, delay between attempts, and other customizable options, making it a flexible solution for handling transient errors.

While retry is a solid choice, there are several alternatives in the ecosystem that offer similar functionality with different features and approaches. Here are a few noteworthy alternatives:

  • async-retry is a lightweight library that provides a simple way to retry asynchronous functions with customizable options. It supports exponential backoff and allows you to define the number of attempts and the delay between retries. async-retry is particularly useful for handling promises and works seamlessly with async/await syntax, making it a great choice for modern JavaScript applications.

  • backoff is a library that implements exponential backoff algorithms for retrying operations. It provides a more sophisticated approach to retries, allowing developers to define custom backoff strategies. This can be particularly useful in scenarios where you want to avoid overwhelming a server with repeated requests in a short period. backoff is suitable for applications that require fine-tuned control over retry behavior.

  • promise-retry is another library focused on retrying promise-based functions. It offers a straightforward API for retrying failed promises with customizable options for the number of retries and delay. promise-retry is a good choice for developers who want a simple and effective way to handle retries in promise-based workflows.

  • retry-axios is a specialized library that integrates the retry functionality directly with the Axios HTTP client. It allows you to automatically retry failed HTTP requests made with Axios, providing a seamless experience for handling transient network errors. If you are already using Axios in your application, retry-axios can be a great addition to enhance its resilience.

  • retry-request is a library that extends the functionality of the popular request library by adding retry capabilities. It allows you to specify retry options for HTTP requests, making it easier to handle transient errors when making network calls. If you are using the request library, retry-request can provide a straightforward way to add retry logic to your requests.

To compare these packages and see how they stack up against each other, check out the following link: Comparing async-retry vs backoff vs promise-retry vs retry vs retry-axios vs retry-request.

Similar Npm Packages to retry-axios

retry-axios is a library that enhances the functionality of Axios, a popular HTTP client for JavaScript. It provides a mechanism to automatically retry failed HTTP requests, making it easier to handle transient errors such as network issues or server unavailability. By integrating retry logic directly into Axios, retry-axios allows developers to configure how many times a request should be retried, the delay between retries, and which types of errors should trigger a retry. This can significantly improve the resilience of applications that rely on external APIs.

While retry-axios offers a robust solution for retrying requests, there are several alternatives in the ecosystem that provide similar functionalities:

  • axios-retry is another popular library that adds retry functionality to Axios. It allows developers to specify the number of retries, the delay between retries, and conditions under which a retry should occur. axios-retry is straightforward to use and integrates seamlessly with Axios, making it a solid choice for those looking to add retry logic to their HTTP requests without much overhead.

  • fetch-retry is designed for the Fetch API, providing a similar retry mechanism for requests made using the Fetch API. This library allows developers to specify retry options, such as the number of attempts and the delay between retries. If your application uses the Fetch API instead of Axios, fetch-retry is an excellent alternative for implementing retry logic.

  • retry-request is a library that provides retry functionality for HTTP requests made with various libraries, including Axios and the native HTTP module in Node.js. It offers a flexible API for configuring retries and can be used in both browser and server environments. If you need a more generalized solution that works across different HTTP clients, retry-request might be the right choice.

  • superagent-retry is an extension for Superagent, another popular HTTP client. This library adds retry capabilities to Superagent requests, allowing developers to specify retry conditions and delays. If your project is already using Superagent, superagent-retry can easily integrate retry logic into your existing setup.

To see how retry-axios compares with axios-retry, fetch-retry, retry-request, and superagent-retry, check out the comparison: Comparing axios-retry vs fetch-retry vs retry-axios vs retry-request vs superagent-retry.

Similar Npm Packages to retry-request

retry-request is a utility library designed to enhance HTTP request capabilities by automatically retrying failed requests. It is particularly useful in scenarios where network reliability is a concern, such as in mobile applications or when interacting with unstable APIs. By implementing a retry mechanism, retry-request helps improve the resilience of applications, ensuring that transient errors do not disrupt user experience.

While retry-request provides a solid solution for retrying HTTP requests, there are several alternatives in the ecosystem that offer similar functionalities:

  • axios-retry is a popular library that integrates seamlessly with Axios, a widely-used HTTP client for JavaScript. It allows developers to automatically retry failed requests based on customizable conditions, such as specific HTTP status codes or network errors. If you are already using Axios in your application, axios-retry is a straightforward choice to add retry capabilities without significant overhead.

  • fetch-retry is a library that extends the native Fetch API to include retry functionality. It allows developers to specify retry conditions and delay intervals when making HTTP requests. If your application relies on the Fetch API and you want to add retry logic without switching to another HTTP client, fetch-retry is an excellent option.

  • requestretry is a library built on top of the popular request library for Node.js. It provides a simple way to retry HTTP requests with customizable options, including the number of retries and delay intervals. If you are working in a Node.js environment and prefer the request library, requestretry can easily enhance your request handling.

  • retry-axios is another library that adds retry functionality specifically for Axios. It is designed to be simple to use and provides options for customizing retry behavior, such as exponential backoff and retry limits. If you are looking for a robust solution for retrying requests with Axios, retry-axios is a strong contender.

  • superagent-retry is an extension for Superagent, a popular HTTP request library. It adds retry capabilities to Superagent requests, allowing developers to specify retry conditions and intervals. If you are using Superagent in your project, this library can easily integrate retry logic into your existing request handling.

To explore how these libraries compare, visit: Comparing axios-retry vs fetch-retry vs requestretry vs retry-axios vs retry-request vs superagent-retry.

README for async-retry

async-retry

Retrying made simple, easy, and async.

Usage

// Packages
const retry = require('async-retry');
const fetch = require('node-fetch');

await retry(
  async (bail) => {
    // if anything throws, we retry
    const res = await fetch('https://google.com');

    if (403 === res.status) {
      // don't retry upon 403
      bail(new Error('Unauthorized'));
      return;
    }

    const data = await res.text();
    return data.substr(0, 500);
  },
  {
    retries: 5,
  }
);

API

retry(retrier : Function, opts : Object) => Promise
  • The supplied function can be async or not. In other words, it can be a function that returns a Promise or a value.
  • The supplied function receives two parameters
    1. A Function you can invoke to abort the retrying (bail)
    2. A Number identifying the attempt. The absolute first attempt (before any retries) is 1.
  • The opts are passed to node-retry. Read its docs
    • retries: The maximum amount of times to retry the operation. Default is 10.
    • factor: The exponential factor to use. Default is 2.
    • minTimeout: The number of milliseconds before starting the first retry. Default is 1000.
    • maxTimeout: The maximum number of milliseconds between two retries. Default is Infinity.
    • randomize: Randomizes the timeouts by multiplying with a factor between 1 to 2. Default is true.
    • onRetry: an optional Function that is invoked after a new retry is performed. It's passed the Error that triggered it as a parameter.

Authors

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.