bullmq vs bull vs agenda vs kue vs bee-queue vs node-resque
Node.js Job Queues Comparison
1 Year
bullmqbullagendakuebee-queuenode-resqueSimilar Packages:
What's Node.js Job Queues?

Job queue libraries in Node.js are designed to handle asynchronous tasks efficiently, allowing developers to manage background jobs, schedule tasks, and process jobs in a reliable manner. These libraries enable the execution of tasks outside the main application thread, improving performance and responsiveness. They provide features like job scheduling, retries, and prioritization, making them essential for applications that require background processing or delayed execution of tasks.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
bullmq967,2576,5411.95 MB276a day agoMIT
bull840,83515,769309 kB1502 months agoMIT
agenda131,3839,467353 kB350-MIT
kue23,7659,460-2878 years agoMIT
bee-queue22,9973,881106 kB46a year agoMIT
node-resque12,9741,385705 kB172 months agoApache-2.0
Feature Comparison: bullmq vs bull vs agenda vs kue vs bee-queue vs node-resque

Backend Support

  • bullmq:

    BullMQ is the successor to Bull, offering improved performance and modularity while still using Redis. It is designed for modern applications that require scalability and advanced job processing features.

  • bull:

    Bull is also Redis-based and offers robust features for job management. It supports job prioritization, delayed jobs, and concurrency, making it suitable for complex applications.

  • agenda:

    Agenda uses MongoDB as its backend, making it a good choice for applications already utilizing MongoDB. It leverages MongoDB's capabilities for job persistence and scheduling.

  • kue:

    Kue utilizes Redis for job storage and processing, providing a simple API and built-in UI for monitoring jobs. It is suitable for applications that require quick setup and visual job management.

  • bee-queue:

    Bee-Queue is built on Redis, providing fast and efficient job processing with minimal overhead. It is designed for performance and simplicity, making it ideal for high-throughput applications.

  • node-resque:

    Node-Resque supports multiple backends, including Redis and MongoDB, allowing for greater flexibility in job processing and storage options.

Job Management Features

  • bullmq:

    BullMQ enhances job management with a more modular approach, allowing for better organization of job processing logic. It includes features like job events, retries, and advanced scheduling options.

  • bull:

    Bull offers extensive job management features, including job prioritization, delayed jobs, retries, and event listeners. It is designed for applications that require detailed control over job processing.

  • agenda:

    Agenda provides a simple API for scheduling jobs with options for recurring jobs and job prioritization. It allows for easy management of job states and supports job retries.

  • kue:

    Kue provides job management features with a built-in UI for monitoring job states, retries, and failure handling. It is suitable for applications that benefit from visual job management.

  • bee-queue:

    Bee-Queue focuses on simplicity and performance, offering basic job management features like job retries and event handling, but lacks advanced features like job prioritization.

  • node-resque:

    Node-Resque offers flexible job management features, including retries and event handling, with support for multiple backends, making it adaptable to various application needs.

Performance and Scalability

  • bullmq:

    BullMQ offers improved performance over Bull, with better handling of large job volumes and a more modular architecture that enhances scalability.

  • bull:

    Bull is designed for high performance and can handle a large number of jobs efficiently. It scales well with Redis, making it suitable for demanding applications.

  • agenda:

    Agenda is lightweight and suitable for applications with moderate job scheduling needs. However, its performance may be limited by MongoDB's capabilities under heavy load.

  • kue:

    Kue is suitable for moderate workloads but may face performance issues under heavy loads compared to Bull or BullMQ. It is best for applications with simpler job processing needs.

  • bee-queue:

    Bee-Queue is optimized for low-latency job processing, making it ideal for high-throughput applications. Its simplicity allows for quick scaling without much overhead.

  • node-resque:

    Node-Resque can scale with multiple backends, but performance may vary based on the chosen backend. It is flexible but may require more configuration for optimal performance.

Ease of Use

  • bullmq:

    BullMQ is designed with modern JavaScript practices in mind, offering a clean and modular API. It is suitable for developers looking for a contemporary approach to job queues.

  • bull:

    Bull has a more complex API due to its extensive feature set, but it provides comprehensive documentation that aids in learning. It is suitable for developers who need advanced job processing capabilities.

  • agenda:

    Agenda has a straightforward API that is easy to use, especially for developers familiar with MongoDB. It is suitable for quick implementations and simple job scheduling.

  • kue:

    Kue provides a simple API and built-in UI, making it easy to monitor jobs. It is suitable for developers who prefer a visual representation of job processing.

  • bee-queue:

    Bee-Queue is designed for simplicity, making it easy to set up and use for basic job processing needs. Its minimalistic approach is ideal for developers looking for a quick solution.

  • node-resque:

    Node-Resque has a flexible API that may require more initial setup but offers great customization options. It is suitable for developers who need a tailored job processing solution.

Community and Support

  • bullmq:

    BullMQ is newer but backed by the same community as Bull, ensuring good support and documentation as it grows in popularity.

  • bull:

    Bull has a large and active community, with extensive documentation and resources available. It is widely used and well-supported, making it a reliable choice.

  • agenda:

    Agenda has a smaller community compared to some other job queue libraries, which may affect the availability of resources and support. However, it is still actively maintained.

  • kue:

    Kue has a decent community but is not as actively maintained as some of the other options. Developers may find fewer resources available for troubleshooting.

  • bee-queue:

    Bee-Queue has a growing community and is actively maintained, providing good support and documentation for developers.

  • node-resque:

    Node-Resque has a moderate community presence and offers good documentation, but it may not have as many resources as the more popular libraries.

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

    Choose BullMQ for a modern, modular approach to job queues with a focus on TypeScript support and improved performance over Bull. It is ideal for new projects that require a scalable and flexible job queue solution with advanced features.

  • bull:

    Opt for Bull if you need a robust Redis-based job queue with advanced features like job prioritization, delayed jobs, and rate limiting. It is well-suited for applications that require complex job processing capabilities and high performance.

  • agenda:

    Choose Agenda if you need a simple, MongoDB-backed job scheduler that allows for easy scheduling of jobs with a straightforward API. It is ideal for applications that already use MongoDB and require a lightweight solution for scheduling tasks.

  • kue:

    Select Kue if you need a job queue with a built-in UI for monitoring jobs and a focus on simplicity. It is suitable for applications that require a quick setup and a visual representation of job processing.

  • bee-queue:

    Select Bee-Queue for its simplicity and performance, especially if you need a Redis-backed job queue that focuses on low-latency job processing. It is suitable for applications that require fast job processing with minimal overhead and a straightforward API.

  • node-resque:

    Choose Node-Resque if you require a more flexible job processing system that supports multiple backends (like Redis, MongoDB) and allows for worker management. It is ideal for applications that need a customizable job queue solution.

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
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);
  },
);

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:

| Feature | BullMQ-Pro | BullMQ | Bull | Kue | Bee | Agenda | | :------------------------ | :-----------------------------------------: | :-------------------------: | :-------------: | :---: | -------- | ------ | | Backend | redis | redis | redis | redis | redis | mongo | | Observables | ✓ | | | | | | | Group Rate Limit | ✓ | | | | | | | Group Support | ✓ | | | | | | | Batches Support | ✓ | | | | | | | Parent/Child Dependencies | ✓ | ✓ | | | | | | Debouncing | ✓ | ✓ | ✓ | | | | | Priorities | ✓ | ✓ | ✓ | ✓ | | ✓ | | Concurrency | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | Delayed jobs | ✓ | ✓ | ✓ | ✓ | | ✓ | | Global events | ✓ | ✓ | ✓ | ✓ | | | | Rate Limiter | ✓ | ✓ | ✓ | | | | | Pause/Resume | ✓ | ✓ | ✓ | ✓ | | | | Sandboxed worker | ✓ | ✓ | ✓ | | | | | Repeatable jobs | ✓ | ✓ | ✓ | | | ✓ | | Atomic ops | ✓ | ✓ | ✓ | | ✓ | | | Persistence | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | UI | ✓ | ✓ | ✓ | ✓ | | ✓ | | Optimized for | Jobs / Messages | Jobs / Messages | Jobs / Messages | Jobs | Messages | Jobs |

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.