bullmq vs bull vs agenda vs bee-queue vs kue vs node-resque
Node.js Job Queue Libraries
Search packages..
bullmqbullagendabee-queuekuenode-resqueSimilar Packages:
Node.js Job Queue Libraries

agenda, bee-queue, bull, bullmq, kue, and node-resque are all Node.js libraries for managing background job queues — essential for offloading time-consuming tasks like sending emails, processing files, or syncing data. They enable reliable, asynchronous task execution with features like retries, delays, and failure handling. While they share the same goal, they differ significantly in architecture (MongoDB vs Redis), API design, maintenance status, and advanced capabilities like job prioritization or TypeScript support.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
bullmq2,465,9698,2422.27 MB3223 days agoMIT
bull1,116,64716,215309 kB147a year agoMIT
agenda138,6389,595353 kB355-MIT
bee-queue34,6854,006107 kB38a month agoMIT
kue16,6069,455-2889 years agoMIT
node-resque12,0381,408705 kB112 days agoApache-2.0

Choosing a Job Queue for Node.js: Agenda, Bee-Queue, Bull, BullMQ, Kue, and node-resque Compared

When you need to run background tasks in a Node.js application — like sending emails, processing images, or syncing data — you’ll likely reach for a job queue. The six packages compared here (agenda, bee-queue, bull, bullmq, kue, and node-resque) all solve this problem but with different trade-offs in architecture, features, and maintenance status. Let’s dive into how they differ and which one fits your needs.

⚠️ Deprecation Status: Don’t Start With These

Before comparing features, it’s critical to know that kue is officially deprecated. Its GitHub repository states: “Kue is no longer maintained.” You should not use kue in new projects. Similarly, while agenda and node-resque are still installable, their development has slowed significantly, and they lack modern features like TypeScript support or active issue triage.

That leaves bee-queue, bull, and bullmq as the actively maintained options worth serious consideration today.

🗄️ Data Store: Redis vs MongoDB

The biggest architectural split among these libraries is the underlying data store they require.

agenda and node-resque use MongoDB:

  • If your app already uses MongoDB and you want to avoid adding Redis, this might seem convenient.
  • But job queues benefit from Redis’s speed, atomic operations, and pub/sub model — MongoDB wasn’t built for this.
// agenda: Requires MongoDB connection
const agenda = new Agenda({ db: { address: 'mongodb://127.0.0.1/agendaDb' } });
agenda.define('send email', async (job) => {
  await sendEmail(job.attrs.data.to);
});

// node-resque: Also MongoDB-based
const worker = new NR.Worker({
  connection: { host: '127.0.0.1', port: 27017 },
  queues: ['email'],
  timeout: 5000
});

bee-queue, bull, and bullmq use Redis:

  • Redis is purpose-built for queues: fast, in-memory, with reliable persistence options.
  • All three assume you’re running Redis (locally or via a service like Upstash or AWS ElastiCache).
// bee-queue: Redis-backed
const Queue = require('bee-queue');
const emailQueue = new Queue('emails', { redis: { host: '127.0.0.1' } });
emailQueue.process(async (job) => {
  return await sendEmail(job.data.to);
});

// bull: Redis-backed
const Queue = require('bull');
const emailQueue = new Queue('emails'); // Uses default Redis connection
emailQueue.process(async (job) => {
  await sendEmail(job.data.to);
});

// bullmq: Redis-backed, TypeScript-native
import { Worker } from 'bullmq';
const worker = new Worker('emails', async (job) => {
  await sendEmail(job.data.to);
});

💡 Recommendation: Unless you have strong constraints against Redis, choose a Redis-based queue. It’s the industry standard for job queues.

🔁 Job Processing Model: Callbacks vs Async/Await

How you define and handle jobs varies significantly.

agenda and kue use callback-style APIs (though agenda supports async):

  • Feels dated compared to modern async/await patterns.
  • Error handling is more manual.
// kue (deprecated)
const q = require('kue').createQueue();
q.process('email', (job, done) => {
  sendEmail(job.data.to, (err) => {
    if (err) return done(err);
    done();
  });
});

bee-queue, bull, and bullmq fully embrace Promises and async/await:

  • Cleaner, more readable code.
  • Errors automatically fail the job unless caught.
// bull
queue.process('email', async (job) => {
  await sendEmail(job.data.to); // throws → job fails
});

// bullmq
new Worker('email', async (job) => {
  await sendEmail(job.data.to);
});

🧪 Advanced Features: Retries, Delays, Priorities

All modern queues support retries and delays, but implementation differs.

Retry strategies:

  • bull and bullmq let you configure backoff strategies (exponential, fixed).
  • bee-queue supports simple retry counts.
  • agenda supports retries but with less flexibility.
// bull: Exponential backoff
queue.add('work', { foo: 'bar' }, {
  attempts: 3,
  backoff: {
    type: 'exponential',
    delay: 1000
  }
});

// bullmq: Same concept, cleaner syntax
await queue.add('work', { foo: 'bar' }, {
  attempts: 3,
  backoff: {
    type: 'exponential',
    delay: 1000
  }
});

// bee-queue: Basic retries
queue.createJob({ foo: 'bar' })
  .retries(3)
  .save();

Job priorities:

  • Only bull and bullmq support job priorities out of the box.
  • Others require manual queue segregation (e.g., “high-priority” vs “low-priority” queues).
// bullmq: Priority support
await queue.add('work', { foo: 'bar' }, { priority: 1 }); // 1 = highest

📊 Monitoring and UI

Visibility into your queue health matters in production.

  • bull and bullmq integrate with Bull Board, a dashboard showing active, completed, and failed jobs.
  • agenda has third-party UIs like agenda-ui, but they’re less polished.
  • bee-queue has no official UI — you’d need to build your own monitoring.
  • kue had a built-in UI, but it’s obsolete now.
// bull board setup (for bull or bullmq)
import { createBullBoard } from '@bull-board/api';
import { BullAdapter } from '@bull-board/bull';

createBullBoard({
  queues: [new BullAdapter(myQueue)]
});

🧩 TypeScript Support

  • bullmq is written in TypeScript — full type safety out of the box.
  • bull has community-maintained types via @types/bull.
  • bee-queue, agenda, kue, and node-resque lack official TypeScript definitions.

If your project uses TypeScript, bullmq gives you the smoothest experience.

🔄 Migration Path: Bull to BullMQ

bullmq is the official successor to bull, built on the same core ideas but rewritten with TypeScript and improved internals. Key differences:

  • bull uses a single Queue class for both producing and consuming.
  • bullmq separates concerns: Queue (producer), Worker (consumer), QueueScheduler (optional for delayed jobs).
// bull: Single class
const queue = new Queue('work');
queue.process(async (job) => { /*...*/ });
queue.add('work', { data: 1 });

// bullmq: Separated roles
const queue = new Queue('work');
const worker = new Worker('work', async (job) => { /*...*/ });
await queue.add('work', { data: 1 });

This separation makes testing and scaling easier but adds slight verbosity.

🛑 Why Avoid the Deprecated Options?

kue

  • Officially deprecated — no security patches, bug fixes, or compatibility updates.
  • Callback-based API feels archaic.
  • No TypeScript support.
  • Built-in UI is unmaintained.

agenda

  • Still works but development has stalled (last significant commit was years ago).
  • MongoDB dependency limits performance and complicates ops.
  • Lacks modern features like priority queues or advanced backoff.

node-resque

  • Inspired by Ruby’s Resque, but not actively developed.
  • Minimal documentation and community support.
  • No TypeScript definitions.

✅ Real-World Recommendations

For New Projects

  • Choose bullmq if you want the most modern, well-maintained, TypeScript-friendly option with full feature parity (retries, priorities, delays, UI).
  • Choose bull if you’re migrating an existing codebase or prefer its simpler API and don’t need TypeScript.
  • Consider bee-queue only if you need a minimal, lightweight queue without priorities or complex UI — but know you’ll miss out on ecosystem tooling.

For Existing Projects

  • If you’re on bull, plan a migration to bullmq for long-term maintainability.
  • If you’re on agenda or kue, migrate to bullmq — the Redis switch is worth it for reliability and performance.

📌 Summary Table

PackageData StoreActively Maintained?TypeScriptPriority JobsBackoff StrategiesUI Available
agendaMongoDB❌ (Stale)❌❌LimitedThird-party
bee-queueRedis✅❌❌Basic❌
bullRedis✅✅ (via DT)✅✅✅ (Bull Board)
bullmqRedis✅✅ (Native)✅✅✅ (Bull Board)
kueRedis❌ (Deprecated)❌✅❌✅ (Obsolete)
node-resqueRedis❌ (Stale)❌❌❌❌

💡 Final Thought

Job queues are infrastructure — once you pick one, switching is painful. Go with bullmq for new work. It’s the future-proof choice that balances power, simplicity, and active maintenance. Avoid deprecated packages unless you’re maintaining legacy code with no upgrade path.

How to Choose: bullmq vs bull vs agenda vs bee-queue vs kue vs node-resque
  • bullmq:

    Choose bullmq for all new projects requiring a job queue. It's the actively maintained, TypeScript-native successor to bull, offering the same powerful features (priorities, advanced backoff, UI integration) with better architecture, type safety, and long-term support. It's the best balance of modern tooling and production readiness.

  • bull:

    Choose bull if you want a mature, Redis-based queue with a rich feature set (retries with backoff, priorities, delays) and good ecosystem support like Bull Board for monitoring. It's ideal for teams not yet using TypeScript or those migrating from older queue systems who want a stable, proven solution.

  • agenda:

    Choose agenda only if you're already deeply invested in MongoDB and cannot introduce Redis, and you're maintaining a legacy system where migration isn't feasible. Avoid it for new projects due to stalled development and lack of modern features like native TypeScript support or priority queues.

  • bee-queue:

    Choose bee-queue if you need a lightweight, Redis-based queue with a simple API and don't require advanced features like job priorities or a monitoring UI. It's suitable for small-to-medium applications where minimal dependencies and straightforward retry logic are sufficient.

  • kue:

    Do not choose kue for any new project — it is officially deprecated and no longer maintained. If you encounter it in legacy code, plan a migration to bullmq. Its callback-based API, lack of TypeScript support, and obsolete UI make it unsuitable for modern development.

  • node-resque:

    Avoid node-resque for new work. While it offers Redis-backed queuing inspired by Ruby's Resque, it suffers from minimal maintenance, poor documentation, and no TypeScript support. Only consider it if you're extending an existing system that already uses it and migration isn't possible.

Similar Npm Packages to bullmq

bullmq is a powerful and feature-rich queue library for Node.js applications. It is designed to handle distributed job processing with a focus on performance and reliability. Built on top of Redis, bullmq allows developers to create and manage queues, process jobs concurrently, and handle retries and failures efficiently. While bullmq is an excellent choice for job and task management, there are several alternatives in the Node.js ecosystem that also provide similar functionalities. Here are a few notable options:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It allows developers to schedule jobs to run at specific times or intervals, making it suitable for applications that require cron-like job scheduling. Agenda is easy to set up and provides a simple API for defining and managing jobs, making it a great choice for applications that need basic job scheduling capabilities without the overhead of a full-fledged queue system.
  • bee-queue is a simple and fast Redis-based queue library for Node.js. It is designed for low-latency job processing and is particularly well-suited for applications that require quick job execution without the complexities of more feature-rich libraries. Bee-queue offers a straightforward API and focuses on performance, making it an ideal choice for applications that need a lightweight queuing solution.
  • bull is the predecessor to bullmq and is also a Redis-based queue library for Node.js. It provides a robust set of features for managing jobs, including retries, delayed jobs, and job prioritization. While bullmq is the more modern version with additional features and improvements, bull remains a popular choice for many applications due to its stability and established user base. Developers looking for a mature queuing solution may still find bull to be a suitable option.
  • kue is another job queue library for Node.js that uses Redis as its backend. It provides a rich set of features for job management, including job prioritization, delayed jobs, and job event handling. Kue offers a user-friendly UI for monitoring jobs, making it easy to visualize job statuses and manage job queues. However, it is worth noting that kue is no longer actively maintained, which may be a consideration for developers looking for long-term support.

For a comprehensive comparison of these libraries, check out the following link: Comparing agenda vs bee-queue vs bull vs bullmq vs kue.

Similar Npm Packages to bull

bull is a robust queue library for Node.js, designed to handle distributed jobs and messages in a scalable manner. It is built on top of Redis and provides a simple API for creating and managing job queues. Bull is particularly useful for applications that require background processing, such as sending emails, processing images, or handling other time-consuming tasks. With features like job retries, delayed jobs, and concurrency control, Bull makes it easy to manage complex workflows efficiently.

While Bull is a popular choice for job and queue management, there are several alternatives that cater to different needs and preferences:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It allows you to schedule jobs to run at specific times or intervals, making it suitable for applications that require cron-like functionality. Agenda is easy to set up and provides a simple API for defining and managing jobs, making it a good choice for applications that already use MongoDB and need a straightforward scheduling solution.

  • bee-queue is another lightweight queue library for Node.js that focuses on simplicity and performance. It is designed for handling jobs in a single Redis instance and provides a minimalistic API for creating and processing jobs. Bee-Queue is particularly well-suited for applications that require fast job processing with low overhead, making it a great alternative for developers looking for a straightforward queuing solution.

  • bullmq is the successor to Bull, offering a more modern and feature-rich approach to job and queue management. It introduces a new architecture and API, providing improved performance and additional features such as rate limiting, job prioritization, and more. If you are starting a new project or looking to upgrade from Bull, BullMQ is the recommended choice for its enhanced capabilities and flexibility.

  • kue is a priority job queue backed by Redis, designed for handling distributed jobs in Node.js applications. It provides a rich set of features, including job prioritization, delayed jobs, and a user interface for monitoring job progress. Kue is suitable for applications that require a more comprehensive job management solution with a focus on monitoring and visualization.

  • node-resque is a Redis-backed library for creating background jobs in Node.js. It supports multiple backends and provides a flexible API for defining and managing jobs. Node-resque is ideal for applications that need a customizable job processing solution and want to leverage the power of Redis for job management.

To explore how these libraries compare, check out the following link: Comparing agenda vs bee-queue vs bull vs bullmq vs kue vs node-resque.

Similar Npm Packages to agenda

agenda is a job scheduling library for Node.js that allows developers to manage and execute background jobs easily. It is built on top of MongoDB, enabling persistent job storage and providing a flexible API for scheduling tasks. With agenda, you can define recurring jobs, manage job priorities, and handle job failures gracefully. This makes it a great choice for applications that require reliable job scheduling and processing.

While agenda is a powerful tool, there are several alternatives available in the Node.js ecosystem that also provide job scheduling capabilities. Here are a couple of notable alternatives:

  • bull is a robust queue and job scheduling library for Node.js that is built on Redis. It offers a rich set of features, including delayed jobs, job retries, and concurrency control. Bull is particularly well-suited for applications that need to handle a high volume of jobs or require advanced job management capabilities. Its performance and reliability make it a popular choice for developers looking to implement job queues in their applications.

  • node-schedule is a flexible job scheduling library for Node.js that allows you to schedule jobs using cron-like syntax. It is lightweight and easy to use, making it ideal for applications that require simple scheduling without the overhead of a persistent job store. Node-schedule is perfect for scenarios where you need to run tasks at specific intervals or times without the need for complex job management features.

To see how agenda compares with bull and node-schedule, check out the comparison: Comparing agenda vs bull vs node-schedule.

Similar Npm Packages to bee-queue

bee-queue is a simple and efficient queue library for Node.js, designed for handling background jobs and tasks. It is built on top of Redis and provides a straightforward API for creating and managing job queues. With its focus on performance and simplicity, bee-queue is particularly well-suited for applications that require a lightweight solution for processing jobs asynchronously.

While bee-queue is a great option, there are several alternatives available in the Node.js ecosystem that offer different features and capabilities:

  • agenda is a job scheduling library for Node.js that uses MongoDB as its backend. It allows you to define jobs and schedule them to run at specific times or intervals. agenda is particularly useful for applications that require recurring tasks or scheduled jobs, making it a good choice for cron-like functionality.
  • bull is a robust queue library for Node.js that also utilizes Redis. It offers advanced features such as job prioritization, delayed jobs, and rate limiting. bull is designed for high-performance applications and is suitable for handling large volumes of jobs efficiently. If your application requires more complex queue management capabilities, bull is an excellent alternative.
  • kue is another Redis-based job queue library for Node.js. It provides a rich set of features, including job retries, event listeners, and a user-friendly UI for managing jobs. While kue is powerful, it is worth noting that it is no longer actively maintained, so developers should consider this when choosing a queue library for new projects.
  • p-queue is a promise-based queue library that allows you to manage asynchronous tasks with ease. It provides features such as concurrency control and priority support, making it suitable for scenarios where you need to limit the number of concurrent operations. p-queue is a good choice for applications that require fine-grained control over task execution.

For a comprehensive comparison of these libraries, check out the following link: Comparing agenda vs bee-queue vs bull vs kue vs p-queue.

Similar Npm Packages to kue

kue is a priority job queue library for Node.js that allows developers to manage and process jobs in a reliable and efficient manner. It provides a simple API for creating, processing, and managing jobs, making it a popular choice for applications that require background processing or task scheduling. While kue is a robust solution for job management, there are several alternatives that developers might consider based on their specific needs:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It allows you to define jobs with a simple API and provides features like recurring jobs, job prioritization, and job cancellation. If your application already uses MongoDB and you need a straightforward way to schedule jobs, agenda is a great option that integrates seamlessly with your existing database.
  • bee-queue is a simple and fast job queue library for Node.js that is designed for performance and ease of use. It is built on Redis and focuses on providing a minimalistic API for job processing. bee-queue is ideal for applications that require a lightweight solution for managing background jobs without the overhead of more complex libraries.
  • bree is a job scheduler for Node.js that is designed to be simple and efficient. It allows you to run jobs in the background using worker threads, which can improve performance for CPU-intensive tasks. If you need a scheduler that can handle both background jobs and recurring tasks while leveraging the power of worker threads, bree is an excellent choice.
  • bull is a robust job and message queue library for Node.js that is built on Redis. It offers advanced features such as job retries, delayed jobs, and rate limiting, making it suitable for applications that require more complex job processing capabilities. If you need a powerful and feature-rich solution for managing jobs, bull is a strong contender.
  • node-resque is a job processing library for Node.js that is designed to work with Redis. It provides a flexible API for defining and processing jobs, as well as support for scheduled jobs and job prioritization. If you are looking for a library that offers a balance between simplicity and functionality, node-resque is worth considering.

For a detailed comparison of these job queue libraries, check out the link: Comparing agenda vs bee-queue vs bree vs bull vs kue vs node-resque.

Similar Npm Packages to node-resque

node-resque is a robust job queue library for Node.js applications. It allows developers to manage background jobs and scheduled tasks efficiently, providing a flexible and reliable way to handle asynchronous processing. With support for Redis, node-resque enables distributed job processing, making it suitable for applications that require scalability and resilience. While node-resque is a powerful option for job management, there are several alternatives in the Node.js ecosystem that offer similar functionalities. Here are a few noteworthy alternatives:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It provides a simple API for defining jobs and scheduling them to run at specific intervals or times. Agenda is particularly well-suited for applications that already utilize MongoDB and require a straightforward way to manage recurring tasks or delayed jobs. Its ease of use and integration with MongoDB make it a popular choice for developers looking for a minimalistic job scheduler.

  • bee-queue is a simple and fast job queue library for Node.js that is designed for handling jobs in a Redis-backed queue. It focuses on simplicity and performance, making it a great choice for applications that require quick job processing without the overhead of more complex job management systems. Bee-queue is ideal for applications that need to process jobs in real-time and want a straightforward API for managing job queues.

  • bull is a powerful Redis-based job and message queue for Node.js. It offers advanced features such as job prioritization, delayed jobs, and rate-limited processing, making it suitable for applications with complex job processing needs. Bull's robust architecture allows for efficient job management and monitoring, making it a popular choice among developers who require a feature-rich job queue solution.

  • bullmq is the successor to Bull, designed to provide a more modern and flexible API for job management. It builds on the strengths of Bull while introducing new features and improvements, such as support for TypeScript and better performance. Bullmq is ideal for developers looking for a cutting-edge job queue solution that leverages the latest advancements in Node.js and Redis.

  • kue is another job queue library for Node.js that uses Redis as its backend. It offers a rich set of features, including job priority, delayed jobs, and job event listeners. Kue provides a user-friendly dashboard for monitoring job progress and status, making it a suitable choice for applications that require visibility into job processing.

For a comprehensive comparison of these job queue libraries, check out the following link: Comparing agenda vs bee-queue vs bull vs bullmq vs kue vs node-resque.

README for bullmq



The fastest, most reliable, Redis-based distributed queue for Node.
Carefully written for rock solid stability and atomicity.

Read the documentation

Follow @manast for *important* Bull/BullMQ/BullMQ-Pro news and updates!

🛠 Tutorials

You can find tutorials and news in this blog: https://blog.taskforce.sh/

News 🚀

🌐 Language agnostic BullMQ

Do you need to work with BullMQ on platforms other than Node.js? If so, check out the BullMQ Proxy

Official FrontEnd

Taskforce.sh, Inc

Supercharge your queues with a professional front end:

  • Get a complete overview of all your queues.
  • Inspect jobs, search, retry, or promote delayed jobs.
  • Metrics and statistics.
  • and many more features.

Sign up at Taskforce.sh

🚀 Sponsors 🚀

Dragonfly Dragonfly is a new Redis™ drop-in replacement that is fully compatible with BullMQ and brings some important advantages over Redis™ such as massive better performance by utilizing all CPU cores available and faster and more memory efficient data structures. Read more here on how to use it with BullMQ.

Used by

Some notable organizations using BullMQ:

Microsoft Vendure Datawrapper Nest Langfuse
Curri Novu NoCodeDB Infisical

The gist

Install:

$ yarn add bullmq

Add jobs to the queue:

import { Queue } from 'bullmq';

const queue = new Queue('Paint');

queue.add('cars', { color: 'blue' });

Process the jobs in your workers:

import { Worker } from 'bullmq';

const worker = new Worker('Paint', async job => {
  if (job.name === 'cars') {
    await paintCar(job.data.color);
  }
});

Listen to jobs for completion:

import { QueueEvents } from 'bullmq';

const queueEvents = new QueueEvents('Paint');

queueEvents.on('completed', ({ jobId }) => {
  console.log('done painting');
});

queueEvents.on(
  'failed',
  ({ jobId, failedReason }: { jobId: string; failedReason: string }) => {
    console.error('error painting', failedReason);
  },
);

Adds jobs with parent-child relationship:

import { FlowProducer } from 'bullmq';

const flow = new FlowProducer();

const originalTree = await flow.add({
  name: 'root-job',
  queueName: 'topQueueName',
  data: {},
  children: [
    {
      name: 'child-job',
      data: { idx: 0, foo: 'bar' },
      queueName: 'childrenQueueName',
      children: [
        {
          name: 'grandchild-job',
          data: { idx: 1, foo: 'bah' },
          queueName: 'grandChildrenQueueName',
        },
        {
          name: 'grandchild-job',
          data: { idx: 2, foo: 'baz' },
          queueName: 'grandChildrenQueueName',
        },
      ],
    },
    {
      name: 'child-job',
      data: { idx: 3, foo: 'foo' },
      queueName: 'childrenQueueName',
    },
  ],
});

This is just scratching the surface, check all the features and more in the official documentation

Feature Comparison

Since there are a few job queue solutions, here is a table comparing them:

FeatureBullMQ-ProBullMQBullKueBeeAgenda
Backendredisredisredisredisredismongo
Observables✓
Group Rate Limit✓
Group Support✓
Batches Support✓
Parent/Child Dependencies✓✓
Deduplication (Debouncing)✓✓✓
Deduplication (Throttling)✓✓✓
Priorities✓✓✓✓✓
Concurrency✓✓✓✓✓✓
Delayed jobs✓✓✓✓✓
Global events✓✓✓✓
Rate Limiter✓✓✓
Pause/Resume✓✓✓✓
Sandboxed worker✓✓✓
Repeatable jobs✓✓✓✓
Atomic ops✓✓✓✓
Persistence✓✓✓✓✓✓
UI✓✓✓✓✓
Optimized forJobs / MessagesJobs / MessagesJobs / MessagesJobsMessagesJobs

Contributing

Fork the repo, make some changes, submit a pull-request! Here is the contributing doc that has more details.

Thanks

Thanks for all the contributors that made this library possible, also a special mention to Leon van Kammen that kindly donated his npm bullmq repo.

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.