agenda vs cron vs later vs node-schedule vs scheduler
Task Scheduling in Node.js
Search packages..
agendacronlaternode-scheduleschedulerSimilar Packages:

Task Scheduling in Node.js

Task scheduling libraries in Node.js allow developers to run functions or tasks at specified intervals, times, or after a certain delay. These libraries are useful for automating repetitive tasks, sending scheduled emails, cleaning up databases, or performing any action that needs to occur at a specific time or on a regular basis. They provide APIs to define schedules using cron-like syntax, intervals, or specific dates, and handle the execution of these tasks in the background, often with support for persistence, error handling, and concurrency control. Examples include node-cron, agenda, and node-schedule, each with its own features and use cases.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
agenda164,3709,642295 kB221 days agoMIT
cron08,909161 kB223 months agoMIT
later02,419-9810 years agoMIT
node-schedule09,22535 kB1713 years agoMIT
scheduler0243,81282.7 kB1,1545 months agoMIT

Feature Comparison: agenda vs cron vs later vs node-schedule vs scheduler

Persistence

  • agenda:

    agenda stores job data in MongoDB, allowing for persistent scheduling across application restarts. This makes it suitable for long-running applications where job state needs to be maintained.

  • cron:

    cron does not provide any built-in persistence. It runs tasks in memory, which means scheduled jobs will be lost if the application crashes or restarts.

  • later:

    later is an in-memory scheduling library and does not provide persistence. Scheduled tasks are lost when the application stops. It is best for temporary or short-lived scheduling needs.

  • node-schedule:

    node-schedule does not have built-in persistence. Like cron, it runs tasks in memory, and scheduled jobs will be lost on application restart. It is suitable for non-critical tasks where persistence is not required.

  • scheduler:

    scheduler does not offer persistence features. It is designed for lightweight scheduling without the need to store job data between application restarts.

Complexity of Scheduling

  • agenda:

    agenda supports complex scheduling, including recurring jobs, delayed jobs, and job prioritization. It allows for detailed job configurations and error handling, making it suitable for enterprise-level applications.

  • cron:

    cron is best for simple to moderately complex scheduling using cron syntax. It is not designed for handling complex job workflows or dependencies.

  • later:

    later excels in complex scheduling, allowing for detailed recurrence patterns and multiple scheduling rules. It is highly flexible and can handle intricate scheduling scenarios with ease.

  • node-schedule:

    node-schedule supports both simple and complex scheduling, including cron-like expressions and JavaScript Date objects. It provides a good balance of simplicity and flexibility for most use cases.

  • scheduler:

    scheduler focuses on simplicity and supports both one-time and recurring tasks. It is not designed for highly complex scheduling but is flexible enough for most common scenarios.

Ease of Use: Code Examples

  • agenda:

    agenda provides a straightforward API for defining and managing jobs, but its MongoDB integration requires some setup. Example:

    const Agenda = require('agenda');
const agenda = new Agenda({ db: { address: 'mongodb://localhost/agenda' } });

agenda.define('send email', async job => {
  console.log('Sending email...');
});

agenda.schedule('in 1 hour', 'send email');
agenda.start();
  • cron:

    cron has a simple API for scheduling tasks using cron syntax. Example:

    const { CronJob } = require('cron');
const job = new CronJob('0 * * * *', () => {
  console.log('Running job every hour');
});
job.start();
  • later:

    later has a more complex API for defining schedules, especially for advanced users. Example:

    const later = require('later');
later.date.localTime();
const schedule = later.parse.text('every 1 hour');
later.setInterval(() => {
  console.log('Running task every hour');
}, schedule);
  • node-schedule:

    node-schedule offers a user-friendly API for scheduling tasks with both cron syntax and Date objects. Example:

    const schedule = require('node-schedule');
const job = schedule.scheduleJob('*/5 * * * *', () => {
  console.log('Job running every 5 minutes');
});
  • scheduler:

    scheduler provides a simple and intuitive API for scheduling tasks. Example:

    const { Scheduler } = require('scheduler');
const scheduler = new Scheduler();
scheduler.schedule(() => {
  console.log('Task running');
}, 1000);

How to Choose: agenda vs cron vs later vs node-schedule vs scheduler

  • agenda:

    Choose agenda if you need a job scheduler that supports persistent jobs, MongoDB integration, and complex scheduling with retries and failure handling. It is ideal for applications that require reliable job processing and need to store job states in a database.

  • cron:

    Choose cron if you need a simple and lightweight solution for running tasks at specific times or intervals using cron syntax. It is best for straightforward scheduling without the need for persistence or complex features.

  • later:

    Choose later if you need a flexible scheduling library that supports complex recurrence patterns and allows for in-memory scheduling without external dependencies. It is suitable for applications that require advanced scheduling capabilities without the overhead of a full job queue.

  • node-schedule:

    Choose node-schedule if you need a feature-rich scheduler that supports both cron-like syntax and JavaScript Date objects for scheduling tasks. It is great for applications that require a mix of simple and complex scheduling without the need for persistence.

  • scheduler:

    Choose scheduler if you are looking for a modern, lightweight scheduling library that focuses on simplicity and ease of use, with support for both one-time and recurring tasks. It is ideal for projects that need a straightforward API without additional complexity.

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 cron

cron is a popular Node.js package that allows developers to schedule and manage recurring tasks using cron syntax. It provides a straightforward API for defining job schedules and executing tasks at specified intervals, making it an excellent choice for applications that require timed operations, such as sending emails, cleaning up databases, or performing regular data synchronization. With its robust features and ease of use, cron has become a go-to solution for task scheduling in Node.js applications.

However, there are several alternatives to cron that offer different features and capabilities:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend for storing job data. It allows developers to define jobs with a flexible syntax and provides features such as job prioritization, delayed jobs, and recurring jobs. If your application already uses MongoDB and you need a more feature-rich scheduling solution, agenda is an excellent choice that integrates seamlessly with your existing database.
  • later is another scheduling library for Node.js that provides a more flexible and powerful way to define schedules. It allows developers to create complex schedules using a variety of formats, including cron-like syntax and more human-readable expressions. later is particularly useful for applications that require intricate scheduling logic, as it can handle a wide range of scheduling scenarios with ease.
  • node-cron is a simple and lightweight cron-like job scheduler for Node.js. It provides a straightforward API for scheduling tasks using cron syntax and is designed to be easy to use and integrate into existing applications. If you are looking for a minimalistic alternative to cron that still offers the core functionality of scheduling tasks, node-cron is a solid option.

To explore how these packages compare, check out the following link: Comparing agenda vs cron vs later vs node-cron.

Similar Npm Packages to later

later is a scheduling library for JavaScript that allows developers to schedule tasks with ease. It provides a flexible and powerful way to define recurring events and manage time-based operations. While later is a great option for scheduling tasks, there are several alternatives in the Node.js ecosystem that also offer scheduling capabilities. Here are a few notable alternatives:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as a 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 persistent job storage and management, making it an excellent choice for applications that need to handle background tasks or delayed jobs. With its simple API and built-in support for job retries and concurrency, agenda is a robust solution for task scheduling in Node.js applications.
  • cron is a popular library that allows you to schedule tasks using cron syntax. It provides a straightforward way to run tasks at specific times or intervals, similar to the Unix cron jobs. If you are familiar with cron syntax and need a simple way to schedule tasks in your Node.js application, the cron library is a great choice. Its lightweight nature and ease of use make it suitable for a variety of scheduling needs.
  • node-schedule is another flexible scheduling library for Node.js that allows you to schedule jobs using cron-like syntax or JavaScript Date objects. It provides a simple API for scheduling tasks and supports recurring jobs, making it a versatile option for various scheduling scenarios. If you need a library that combines the simplicity of cron syntax with the flexibility of JavaScript date handling, node-schedule is an excellent choice.

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

Similar Npm Packages to node-schedule

node-schedule is a flexible and easy-to-use job scheduling library for Node.js. It allows developers to schedule tasks to run at specific times or intervals, making it ideal for automating repetitive tasks, sending notifications, or performing maintenance operations. While node-schedule is a robust solution for scheduling jobs, there are several alternatives available in the Node.js ecosystem. Here are a few noteworthy options:

  • 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 times or intervals. Agenda is particularly useful for applications that require persistent job storage and management, as it allows you to keep track of job states and results in a MongoDB database. If your application already uses MongoDB and you need a reliable way to schedule jobs, Agenda is a strong choice.

  • cron is a popular library for scheduling tasks in Node.js using cron syntax. It allows developers to define jobs that run at specific times based on a cron expression, making it easy to schedule tasks with complex timing requirements. If you are familiar with cron jobs from Unix-like systems and want to leverage that knowledge in your Node.js applications, the cron library is an excellent option.

  • later is another scheduling library for Node.js that provides a more flexible scheduling syntax compared to traditional cron expressions. It allows you to define schedules using a variety of formats, including intervals, specific times, and even complex recurring patterns. Later is particularly useful if you need to create intricate scheduling logic without being constrained by the limitations of cron syntax.

  • node-cron is a simple and lightweight cron-like job scheduler for Node.js. It allows you to schedule tasks using cron syntax, similar to the cron library. Node-cron is easy to set up and use, making it a great choice for developers who want a straightforward solution for scheduling tasks without the need for additional complexity.

To explore how node-schedule compares with agenda, cron, later, and node-cron, check out the comparison: Comparing agenda vs cron vs later vs node-cron vs node-schedule.

Similar Npm Packages to scheduler

scheduler is a JavaScript library that provides a way to manage and schedule tasks in a Node.js environment. It allows developers to create, manage, and execute scheduled tasks with ease, making it ideal for applications that require timed operations or background jobs. While scheduler is a powerful tool for task management, there are several alternatives available that cater to different scheduling needs. Here are a few notable options:

  • agenda is a job scheduling library for Node.js that uses MongoDB as its backend. It is designed to handle recurring jobs and provides a simple API for defining and managing tasks. Agenda is particularly useful for applications that require persistent job storage, as it allows you to schedule jobs that can survive application restarts. If your application relies on MongoDB and you need a straightforward way to manage scheduled tasks, Agenda is a solid choice.

  • cron is a widely used library that allows developers to schedule tasks using cron syntax. It is perfect for executing jobs at specific intervals, such as daily, weekly, or monthly. The cron library is lightweight and easy to use, making it a popular choice for applications that need simple task scheduling without the overhead of a more complex solution. If you are familiar with cron jobs and need a straightforward way to implement them in your Node.js application, this library is an excellent option.

  • later is a flexible scheduling library that allows you to define complex schedules using a simple syntax. It provides a powerful API for scheduling tasks with various intervals, including specific days of the week, months, or even custom patterns. Later is particularly useful for applications that require advanced scheduling capabilities beyond what traditional cron syntax can offer. If you need a highly customizable scheduling solution, Later is worth considering.

  • node-schedule is another scheduling library for Node.js that allows you to schedule jobs using cron-like syntax or JavaScript Date objects. It provides a straightforward API for defining and managing scheduled tasks, making it easy to integrate into your application. Node-schedule is suitable for applications that require simple scheduling without the need for persistent job storage. If you want a lightweight solution for scheduling tasks in Node.js, node-schedule is a great choice.

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

README for agenda

Agenda

Agenda

A light-weight job scheduling library for Node.js

NPM Version NPM Downloads

Migrating from v5? See the Migration Guide for all breaking changes.

Agenda 6.x

Agenda 6.x is a complete TypeScript rewrite with a focus on modularity and flexibility:

  • Pluggable storage backends - Choose from MongoDB, PostgreSQL, Redis, or implement your own. Each backend is a separate package - install only what you need.

  • Pluggable notification channels - Move beyond polling with real-time job notifications via Redis, PostgreSQL LISTEN/NOTIFY, or other pub/sub systems. Jobs get processed immediately when saved, not on the next poll cycle.

  • Modern stack - ESM-only, Node.js 18+, full TypeScript with strict typing.

See the 6.x Roadmap for details and progress.

Features

  • Minimal overhead job scheduling
  • Pluggable storage backends (MongoDB, PostgreSQL, Redis)
  • TypeScript support with full typing
  • Scheduling via cron or human-readable syntax
  • Configurable concurrency and locking
  • Real-time job notifications (optional)
  • Sandboxed worker execution via fork mode
  • TypeScript decorators for class-based job definitions

Installation

Install the core package and your preferred backend:

# For MongoDB
npm install agenda @agendajs/mongo-backend

# For PostgreSQL
npm install agenda @agendajs/postgres-backend

# For Redis
npm install agenda @agendajs/redis-backend

Requirements:

  • Node.js 18+
  • Database of your choice (MongoDB 4+, PostgreSQL, or Redis)

Quick Start

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

const agenda = new Agenda({
  backend: new MongoBackend({ address: 'mongodb://localhost/agenda' })
});

// Define a job
agenda.define('send email', async (job) => {
  const { to, subject } = job.attrs.data;
  await sendEmail(to, subject);
});

// Start processing
await agenda.start();

// Schedule jobs
await agenda.every('1 hour', 'send email', { to: 'user@example.com', subject: 'Hello' });
await agenda.schedule('in 5 minutes', 'send email', { to: 'admin@example.com', subject: 'Report' });
await agenda.now('send email', { to: 'support@example.com', subject: 'Urgent' });

Official Backend Packages

PackageBackendNotificationsInstall
@agendajs/mongo-backendMongoDBPolling onlynpm install @agendajs/mongo-backend
@agendajs/postgres-backendPostgreSQLLISTEN/NOTIFYnpm install @agendajs/postgres-backend
@agendajs/redis-backendRedisPub/Subnpm install @agendajs/redis-backend

Backend Capabilities

BackendStorageNotificationsNotes
MongoDB (MongoBackend)āœ…āŒStorage only. Combine with external notification channel for real-time.
PostgreSQL (PostgresBackend)āœ…āœ…Full backend. Uses LISTEN/NOTIFY for notifications.
Redis (RedisBackend)āœ…āœ…Full backend. Uses Pub/Sub for notifications.
InMemoryNotificationChannelāŒāœ…Notifications only. For single-process/testing.

Backend Configuration

MongoDB

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

// Via connection string
const agenda = new Agenda({
  backend: new MongoBackend({ address: 'mongodb://localhost/agenda' })
});

// Via existing MongoDB connection
const agenda = new Agenda({
  backend: new MongoBackend({ mongo: existingDb })
});

// With options
const agenda = new Agenda({
  backend: new MongoBackend({
    mongo: db,
    collection: 'jobs'        // Collection name (default: 'agendaJobs')
  }),
  processEvery: '30 seconds', // Job polling interval
  maxConcurrency: 20,         // Max concurrent jobs
  defaultConcurrency: 5       // Default per job type
});

PostgreSQL

import { Agenda } from 'agenda';
import { PostgresBackend } from '@agendajs/postgres-backend';

const agenda = new Agenda({
  backend: new PostgresBackend({
    connectionString: 'postgresql://user:pass@localhost:5432/mydb'
  })
});

Redis

import { Agenda } from 'agenda';
import { RedisBackend } from '@agendajs/redis-backend';

const agenda = new Agenda({
  backend: new RedisBackend({
    connectionString: 'redis://localhost:6379'
  })
});

Real-Time Notifications

For faster job processing across distributed systems:

import { Agenda, InMemoryNotificationChannel } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

const agenda = new Agenda({
  backend: new MongoBackend({ mongo: db }),
  notificationChannel: new InMemoryNotificationChannel()
});

Mixing Storage and Notification Backends

You can use MongoDB for storage while using a different system for real-time notifications:

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';
import { RedisBackend } from '@agendajs/redis-backend';

// MongoDB for storage + Redis for real-time notifications
const redisBackend = new RedisBackend({ connectionString: 'redis://localhost:6379' });
const agenda = new Agenda({
  backend: new MongoBackend({ mongo: db }),
  notificationChannel: redisBackend.notificationChannel
});

This is useful when you want MongoDB's proven durability and flexible queries for job storage, but need faster real-time notifications across multiple processes.

API Overview

Defining Jobs

// Simple async handler
agenda.define('my-job', async (job) => {
  console.log('Processing:', job.attrs.data);
});

// With options
agenda.define('my-job', async (job) => { /* ... */ }, {
  concurrency: 10,
  lockLimit: 5,
  lockLifetime: 10 * 60 * 1000, // 10 minutes
  priority: 'high'
});

Defining Jobs with Decorators

For a class-based approach, use TypeScript decorators:

import { JobsController, Define, Every, registerJobs, Job } from 'agenda';

@JobsController({ namespace: 'email' })
class EmailJobs {
  @Define({ concurrency: 5 })
  async sendWelcome(job: Job<{ userId: string }>) {
    console.log('Sending welcome to:', job.attrs.data.userId);
  }

  @Every('1 hour')
  async cleanupBounced(job: Job) {
    console.log('Cleaning up bounced emails');
  }
}

registerJobs(agenda, [new EmailJobs()]);
await agenda.start();

// Schedule using namespaced name
await agenda.now('email.sendWelcome', { userId: '123' });

See Decorators Documentation for full details.

Scheduling Jobs

// Run immediately
await agenda.now('my-job', { userId: '123' });

// Run at specific time
await agenda.schedule('tomorrow at noon', 'my-job', data);
await agenda.schedule(new Date('2024-12-25'), 'my-job', data);

// Run repeatedly
await agenda.every('5 minutes', 'my-job');
await agenda.every('0 * * * *', 'my-job'); // Cron syntax

Job Control

// Cancel jobs (removes from database)
await agenda.cancel({ name: 'my-job' });

// Disable/enable jobs globally (by query)
await agenda.disable({ name: 'my-job' });  // Disable all jobs matching query
await agenda.enable({ name: 'my-job' });   // Enable all jobs matching query

// Disable/enable individual jobs
const job = await agenda.create('my-job', data);
job.disable();
await job.save();

// Progress tracking
agenda.define('long-job', async (job) => {
  for (let i = 0; i <= 100; i += 10) {
    await doWork();
    await job.touch(i); // Report progress 0-100
  }
});

Stopping / Draining

// Stop immediately - unlocks running jobs so other workers can pick them up
await agenda.stop();

// Drain - waits for running jobs to complete before stopping
await agenda.drain();

// Drain with timeout (30 seconds) - for cloud platforms with shutdown deadlines
const result = await agenda.drain(30000);
if (result.timedOut) {
    console.log(`${result.running} jobs still running after timeout`);
}

// Drain with AbortSignal - for external control
const controller = new AbortController();
setTimeout(() => controller.abort(), 30000);
await agenda.drain({ signal: controller.signal });

Use drain() for graceful shutdowns where you want in-progress jobs to finish their work.

Events

agenda.on('start', (job) => console.log('Job started:', job.attrs.name));
agenda.on('complete', (job) => console.log('Job completed:', job.attrs.name));
agenda.on('success', (job) => console.log('Job succeeded:', job.attrs.name));
agenda.on('fail', (err, job) => console.log('Job failed:', job.attrs.name, err));

// Job-specific events
agenda.on('start:send email', (job) => { /* ... */ });
agenda.on('fail:send email', (err, job) => { /* ... */ });

Custom Backend

For databases other than MongoDB, PostgreSQL, or Redis, implement AgendaBackend:

import { AgendaBackend, JobRepository } from 'agenda';

class SQLiteBackend implements AgendaBackend {
  readonly repository: JobRepository;
  readonly notificationChannel = undefined; // Or implement NotificationChannel

  async connect() { /* ... */ }
  async disconnect() { /* ... */ }
}

const agenda = new Agenda({
  backend: new SQLiteBackend({ path: './jobs.db' })
});

See Custom Backend Driver for details.

Documentation

Related Packages

Official Backend Packages:

Tools:

License

MIT

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.