async-retry vs p-retry vs promise-poller vs promise-retry vs retry vs retry-axios
Implementing Resilient Retry Logic in JavaScript Applications
Search packages..
async-retryp-retrypromise-pollerpromise-retryretryretry-axiosSimilar Packages:

Implementing Resilient Retry Logic in JavaScript Applications

This comparison evaluates six popular npm packages designed to handle retry logic for asynchronous operations in JavaScript and Node.js environments. These libraries provide mechanisms to automatically re-execute failed promises or functions, often with configurable delays, exponential backoff, and error filtering. While they share a common goal of improving system resilience against transient failures (like network timeouts or rate limits), they differ significantly in their API design, dependency requirements, and specific use cases—ranging from generic promise wrappers to Axios-specific interceptors.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
async-retry01,915-305 years agoMIT
p-retry01,00725.5 kB1a month agoMIT
promise-poller0119-87 years agoMIT
promise-retry0318-116 years agoMIT
retry01,259-205 years agoMIT
retry-axios050464.9 kB113 days agoApache-2.0

Implementing Resilient Retry Logic: A Deep Dive into JavaScript Retry Libraries

In distributed systems and web applications, transient failures are inevitable. Network timeouts, rate limits, and temporary service unavailability require robust retry mechanisms. The JavaScript ecosystem offers several packages to handle this, but they serve different architectural needs. This analysis compares async-retry, p-retry, promise-poller, promise-retry, retry, and retry-axios to help you select the right tool for your resilience strategy.

🔄 Core Execution Model: Wrappers vs. Pollers vs. Interceptors

The fundamental difference lies in how these libraries approach the problem. Most are wrappers around a function call, but some are designed for polling or specific HTTP clients.

async-retry wraps an async function and retries it if it throws. It is designed for Node.js and uses async/await.

import retry from 'async-retry';

await retry(
  async (bail) => {
    const res = await fetch('/api/data');
    if (!res.ok) throw new Error('Failed');
    return res;
  },
  { retries: 3 }
);

p-retry is similar but focuses on Promise compatibility and allows aborting via specific errors. It works in browsers and Node.

import pRetry from 'p-retry';

await pRetry(
  async () => {
    const res = await fetch('/api/data');
    if (!res.ok) throw new Error('Failed');
    return res;
  },
  { retries: 3 }
);

promise-poller is different; it polls until a success condition is met, not just on failure. It is for long-running tasks.

import promisePoller from 'promise-poller';

promisePoller({
  task: () => fetch('/api/status').then(r => r.json()),
  validate: (result) => result.status === 'complete',
  interval: 1000,
  retries: 10
});

promise-retry wraps the retry package to return a promise. It supports passing options to the underlying retry logic.

import promiseRetry from 'promise-retry';

await promiseRetry(
  (retry, number) => {
    return fetch('/api/data').catch(retry);
  },
  { retries: 3 }
);

retry is the low-level callback-based foundation. It requires manual promise wrapping for modern usage.

import retry from 'retry';

const operation = retry.operation({ retries: 3 });

operation.attempt(async (currentAttempt) => {
  try {
    await fetch('/api/data');
    operation.mainCallback();
  } catch (err) {
    if (operation.retry(err)) return;
    operation.mainCallback(err);
  }
});

retry-axios is an Axios interceptor. It automatically retries requests configured on the Axios instance.

import retry from 'retry-axios';

axios.defaults.retry = { retries: 3 };
axios.interceptors.request.use(retry.interceptor);

// Any axios request now has retry logic
await axios.get('/api/data');

⏱️ Delay Strategies: Exponential Backoff and Timing

Handling retry timing is critical to avoid overwhelming services. Most libraries support exponential backoff, but configuration varies.

async-retry supports minTimeout, maxTimeout, and factor for exponential backoff.

await retry(async () => { /* ... */ }, {
  minTimeout: 100,
  maxTimeout: 5000,
  factor: 2
});

p-retry supports similar options via the retry package underneath, allowing minTimeout and factor.

await pRetry(async () => { /* ... */ }, {
  minTimeout: 100,
  factor: 2
});

promise-poller uses a fixed interval by default, though custom strategies can be implemented via the progress callback.

promisePoller({
  task: () => { /* ... */ },
  interval: 2000 // Fixed delay between polls
});

promise-retry passes options directly to the retry module, supporting minTimeout, maxTimeout, and factor.

await promiseRetry((retry) => { /* ... */ }, {
  minTimeout: 100,
  factor: 2
});

retry provides the core logic for timeouts, allowing minTimeout, maxTimeout, factor, and randomize.

const op = retry.operation({
  minTimeout: 100,
  factor: 2
});

retry-axios allows configuring retryDelay which can be a number or a function to calculate delay based on attempt count.

axios.defaults.retry = {
  retries: 3,
  retryDelay: (attemptCount) => attemptCount * 1000
};

🛑 Error Handling and Abortion Logic

Knowing when to stop retrying is as important as retrying itself. Some libraries allow you to "bail" out immediately on specific errors.

async-retry provides a bail function. Calling it stops retries immediately for non-retryable errors.

await retry(async (bail) => {
  const err = new Error('Critical');
  err.doNotRetry = true;
  if (err.doNotRetry) bail(err);
  throw err;
});

p-retry allows throwing specific error types (like pRetry.AbortError) to stop retries immediately.

import pRetry from 'p-retry';

await pRetry(async () => {
  throw new pRetry.AbortError('Critical failure');
});

promise-poller stops when the validate function returns true or retries are exhausted. It does not have a specific "bail" for errors.

promisePoller({
  task: () => { /* ... */ },
  validate: (res) => res.success === true
});

promise-retry relies on the error passed to the retry callback. If you don't call retry(err), it stops.

await promiseRetry((retry, number) => {
  return fetch('/api').catch(err => {
    if (err.status === 400) throw err; // Stop retrying
    return retry(err);
  });
});

retry uses operation.retry(err) which returns false if retries are exhausted or the error is deemed non-retryable by custom logic.

operation.attempt((currentAttempt) => {
  if (err.code === 'CRITICAL') {
    operation.mainCallback(err); // Stop
    return;
  }
  if (operation.retry(err)) return;
});

retry-axios allows a retryCondition function to determine if a specific error should trigger a retry.

axios.defaults.retry = {
  retryCondition: (error) => {
    return error.response.status === 503;
  }
};

📦 Maintenance and Architecture Fit

Choosing a library also means choosing its maintenance status and architectural footprint.

async-retry is widely used in the Node.js ecosystem (e.g., by Vercel/Zeit). It is stable and focused on server-side async operations.

// Stable API, widely adopted in Node services
import retry from 'async-retry';

p-retry is actively maintained and works well in modern frontend build pipelines. It is a safe bet for isomorphic apps.

// Good for frontend + backend shared code
import pRetry from 'p-retry';

promise-poller is specialized. It is not a general retry library but a polling library. Use it only for state checking.

// Specialized for polling, not general retries
import promisePoller from 'promise-poller';

promise-retry has seen less activity recently. It is functional but p-retry is often preferred for new Promise-based work.

// Functional but consider p-retry for new projects
import promiseRetry from 'promise-retry';

retry is the underlying engine for many others. It is stable but callback-based, which adds boilerplate in async/await code.

// Core utility, often wrapped by other libs
import retry from 'retry';

retry-axios is specific to Axios. If you switch HTTP clients, this dependency becomes useless. It reduces boilerplate for Axios users.

// Tightly coupled to Axios
import retry from 'retry-axios';

📊 Summary: Key Differences

Featureasync-retryp-retrypromise-pollerpromise-retryretryretry-axios
Primary UseGeneral AsyncGeneral PromisePollingGeneral PromiseCore LogicAxios Interceptor
EnvironmentNode.jsUniversalUniversalUniversalUniversalNode/Browser (Axios)
API StyleAsync/AwaitAsync/AwaitConfig ObjectAsync/AwaitCallbacksInterceptor
Abort Logicbail()AbortErrorvalidate()Throw ErrorCustom LogicretryCondition
BackoffYesYesFixed IntervalYesYesCustom Function

💡 The Big Picture

For general-purpose retry logic in modern JavaScript, p-retry is often the best balance of features and environment compatibility. It handles async/await cleanly and allows easy abortion of retries.

For Node.js backend services, async-retry is a robust standard with a strong track record in production environments.

If you are already using Axios, retry-axios saves significant boilerplate by applying retry logic globally via interceptors rather than wrapping every call.

Avoid retry for new high-level code unless you need the callback control, and use promise-poller only when you are specifically polling for a state change, not retrying a failed action.

Final Thought: Resilience is not just about retrying; it is about retrying smartly. Choose the library that gives you the control you need to distinguish between a transient blip and a permanent failure.

How to Choose: async-retry vs p-retry vs promise-poller vs promise-retry vs retry vs retry-axios

  • async-retry:

    Choose async-retry if you are working in a Node.js environment and need a robust, battle-tested solution that supports async/await natively. It is ideal for backend services or Node-based tooling where you need fine-grained control over retry attempts and error handling without adding heavy dependencies.

  • p-retry:

    Choose p-retry if you want a lightweight, promise-centric library that works well in both browser and Node environments. It is best suited for frontend applications or isomorphic code where you need simple retry logic with exponential backoff and the ability to abort retries based on specific error conditions.

  • promise-poller:

    Choose promise-poller if your use case involves polling a resource until a specific condition is met, rather than simply retrying a failed operation. It is the right choice for scenarios like waiting for a build to complete or checking for a status change, where the operation itself isn't failing but needs repeated execution.

  • promise-retry:

    Choose promise-retry if you are maintaining legacy code or need compatibility with older callback-style patterns, though be aware it is less actively maintained. It is suitable for projects that already depend on the retry package and need a promise wrapper, but new projects should consider more modern alternatives.

  • retry:

    Choose retry if you need the foundational logic for retrying operations and are comfortable wrapping it yourself or using it in a callback-heavy codebase. It is the core dependency for many other retry libraries, but for most modern async/await projects, higher-level wrappers like p-retry or async-retry are recommended.

  • retry-axios:

    Choose retry-axios if your project heavily relies on the Axios HTTP client and you want to add retry logic globally via interceptors. It is the most efficient choice for handling HTTP-specific transient errors (like 503 or 429) without wrapping every individual request call manually.

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 p-retry

p-retry is a promise-based library that allows developers to retry asynchronous operations that may fail. It provides a simple and flexible way to handle retries with customizable options such as the number of attempts, delay between retries, and error handling. This can be particularly useful in scenarios where network requests or other asynchronous operations may be unreliable.

While p-retry is a great option for managing retries, there are several alternatives available in the ecosystem that offer similar functionality. Here are a few noteworthy alternatives:

  • async-retry is a library designed to retry asynchronous functions with a simple API. It allows you to specify the number of retries, the delay between attempts, and provides options for exponential backoff. async-retry is particularly useful when you need a straightforward way to handle retries in asynchronous workflows without much overhead. Its simplicity and effectiveness make it a popular choice among developers.
  • promise-retry is another library that focuses on retrying promise-based functions. It allows you to define the number of attempts and the delay between retries, and it supports customizable retry strategies. promise-retry is a good option if you want a lightweight solution specifically for promise-based operations, providing a clear and concise way to manage retries.
  • retry is a more general-purpose library that can be used to retry any function, not just promises. It provides a flexible API that allows you to specify the number of retries, delay, and custom error handling. While it can be used for asynchronous operations, its versatility makes it suitable for a wider range of use cases beyond just promises.
  • retry-axios is a specific implementation for retrying HTTP requests made with Axios. It integrates seamlessly with the Axios library, allowing you to automatically retry failed requests based on configurable options. If you are using Axios for your HTTP requests and want to add retry functionality, retry-axios is an excellent choice.

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

Similar Npm Packages to promise-poller

promise-poller is a utility library designed to simplify the process of polling asynchronous operations in JavaScript. It allows developers to repeatedly execute a promise-based function until a specified condition is met or a maximum number of attempts is reached. This can be particularly useful in scenarios where you need to wait for a resource to become available or for an operation to complete successfully. By providing a straightforward API for polling, promise-poller helps streamline the implementation of retry logic in applications.

While promise-poller is a great option for polling, there are several alternatives that offer similar functionality:

  • async-retry is a library that provides a simple way to retry asynchronous functions with customizable retry strategies. It allows developers to specify the number of retries, delay between attempts, and conditions for retrying. If you need a more flexible and configurable approach to retrying asynchronous operations, async-retry is an excellent choice.
  • promise-retry is another library focused on retrying promise-based functions. It offers a straightforward API for retrying promises with customizable options such as retries, delay, and error handling. If you are looking for a lightweight solution to handle retries for promise-based functions, promise-retry is a solid option.
  • retry is a general-purpose retry library that can be used for both synchronous and asynchronous operations. It provides a flexible API that allows developers to define retry strategies, including the number of attempts, delay between retries, and error handling. If you need a versatile solution that can handle retries for various types of functions, retry is a great choice.
  • wait-for-expect is a utility primarily designed for testing environments, allowing developers to wait for certain conditions to be met before proceeding. While it is not specifically a polling library, it can be used to wait for asynchronous operations to complete in a testing context. If your focus is on testing and you need to wait for specific conditions, wait-for-expect might be the right tool for you.

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

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.

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. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.