DEV Community: Arpit Savaj

⏰ Cron Jobs in NestJS Using @nestjs/schedule

Arpit Savaj — Mon, 19 May 2025 09:45:52 +0000

Ever wished your app could do things automatically — like publish a blog post at a specific time, send reminders every Monday, or clear cache every night?

That’s where cron jobs shine. If you're using NestJS, the @nestjs/schedule package makes it super simple to schedule tasks in your backend.

In this post, I’ll walk you through how to use static, dynamic, and timezone-aware cron jobs in NestJS — explained with fun real-life examples you’ll never forget!😄

What is a Cron Job?

A cron job is just a scheduled task that your server runs automatically — based on time or intervals.

Think of it like telling your app:

"Wake me up at 6:00 AM every day!"or"Publish this blog post tomorrow at 9:00 AM."

We’ll look at 3 useful types:

Static cron jobs – fixed schedule, defined in code
Dynamic cron jobs – scheduled at runtime
Timezone-aware cron jobs – respect user’s time zone

Let’s dive into them one-by-one. 👇

Install the Scheduler Package

Before using any cron jobs in NestJS, install the official scheduler package:

npm install --save @nestjs/schedule

And don’t forget to register the ScheduleModule in your root module:

import { Module } from '@nestjs/common';
import { ScheduleModule } from '@nestjs/schedule';
import { TaskService } from './task.service';

@Module({
    imports: [ScheduleModule.forRoot()],
    providers: [TaskService],
})
export class AppModule { }

Now you’re ready to schedule tasks like a pro! 🚀

1. Static Cron Jobs – “Like setting a daily alarm for gym”

Real-life example:

You wake up at 6:00 AM every single day to go to the gym. It’s a daily routine.

This is exactly like a static cron job — hardcoded and consistent.

import { Cron } from '@nestjs/schedule';
import { Injectable } from '@nestjs/common';

@Injectable()
export class TaskService {
    @Cron('0 6 * * *', { timeZone: 'Asia/Kolkata', })
    handleGymAlarm() {
        console.log('⏰ Time to hit the gym at 6:00 AM IST!');
    }
}

0 6 * * * = every day at 6:00 AM.

Refer to crontab.guru to test and understand Cron syntax.

2. Dynamic Cron Jobs – “Like setting an alarm for a special day”

Real-life example:

You’ve got a trip tomorrow, so you set a one-time alarm at 4:30 AM — just for tomorrow.

Or…

You schedule a blog post to go live tomorrow at 9:00 AM.

That’s a dynamic cron job — created at runtime, based on user input or events.

import { Injectable } from "@nestjs/common";
import { SchedulerRegistry } from "@nestjs/schedule";
import * as schedule from "node-schedule";
@Injectable()
export class TaskService {
  constructor(private schedulerRegistry: SchedulerRegistry) {}
  scheduleOneTimeAlarm(postId: string, date: Date) {
    const job = schedule.scheduleJob(date, () => {
      console.log(`Blog post ${postId} published at ${date}`);
    });
    this.schedulerRegistry.addCronJob(postId, job);
    console.log(`Job '${postId}' scheduled at ${date}`);
  }
}

You can now dynamically schedule blog posts, reminders, or any task based on runtime logic!

How to Cancel a Scheduled Post

Sometimes you may want to cancel a job after it's created — e.g., the user cancels a blog post.

cancelScheduledJob(name: string) {
    const job = this.schedulerRegistry.getCronJob(name);
    if (job) {
        job.stop();
        this.schedulerRegistry.deleteCronJob(name);
        console.log(`Job '${name}' stopped and removed.`);
    }
    else { console.log(`Job '${name}' not found.`); }
}

3. Timezone-Aware Cron Jobs – “Because your users don’t all live in the same city”

Real-life example:

You want a job to run every night at 2:00 AM IST, regardless of where the server is hosted (e.g., UTC).

This is why timezone support matters.

import { Cron } from '@nestjs/schedule';
import { Injectable } from '@nestjs/common';

@Injectable()
export class TaskService {
    @Cron('0 2 * * *', { timeZone: 'Asia/Kolkata', })
    handleCacheClear() {
        console.log('Cache cleared at 2:00 AM IST!');
    }
}

💡 By using the timeZone option, the job respects the correct local time for your users.

Tips for Cron in NestJS

Use @cron() for static tasks
Use SchedulerRegistry for dynamic job creation and management
Use timeZone to schedule accurately for different regions
Log job creation and execution for easier debugging
Clean up jobs after completion or when canceled

Final Thoughts

Cron jobs help bring automation and intelligence to your backend services. Whether you're building:

Blog scheduling systems
Auto-email reminders
Background cleanups
Periodic backups

NestJS makes all of this easy and maintainable with its @nestjs/schedule module.

So next time you hear "cron job", don’t just think about Linux terminals — think of digital alarms helping your app run smartly. ⏰💻

If you found this helpful and want more like this, drop a comment below or reach out to me!

Rate Limiting in NestJS Using @nestjs/throttler

Arpit Savaj — Mon, 14 Apr 2025 06:55:23 +0000

What is Rate Limiting?

Rate limiting is a technique used to control the number of requests a user or system can make to a server in a given time period.
Think of it like this:

You can’t drink an entire bottle of water in one gulp (at least you shouldn’t 😅). You sip it slowly. Similarly, APIs and servers also want users to “sip” data—request by request, not flood the server with 1000 requests per second.

It’s basically saying:

“Hey, you can only make 100 requests per 15 minutes. Chill.”

In this blog, I’ll walk you through how to implement rate limiting in a NestJS application using the official @nestjs/throttler package.

We’ll cover:

Why rate limiting is important
How to configure global and route-specific limits
How to override limits per route
How to skip limits entirely
How to apply rate limiting based on users (like email)

Let’s get started! 🚀

Why Do We Need Rate Limiting?

Without rate limiting, bots or even regular users can spam your API with a flood of requests. This can lead to:

Increased server load
Slower response times
Downtime or crashes

Rate limiting solves this by capping how many requests are allowed in a given time period.

Installing Throttler

First, install the throttler package:
npm install @nestjs/throttler

Setting Up Global Rate Limiting

In your AppModule, you can define multiple throttling rules using different names.

import { Module } from "@nestjs/common";
import { APP_GUARD } from "@nestjs/core";
import { ThrottlerGuard, ThrottlerModule } from "@nestjs/throttler";

@Module({
  imports: [
    ThrottlerModule.forRoot({
      throttlers: [
        {
          name: "short",
          ttl: 10000, // 10 seconds
          limit: 3, // 3 requests per 10 sec
        },
        {
          name: "long",
          ttl: 86400000, // 24 hours
          limit: 9, // 9 requests per day
        },
      ],
    }),
  ],
  providers: [
    {
      provide: APP_GUARD,
      useClass: ThrottlerGuard,
    },
  ],
})
export class AppModule {}

How It Works

If a user exceeds these limits, they get a 429 Too Many Requests error:

{
  "statusCode": 429,
  "message": "Too Many Requests"
}

Override Global Limits per Route

Use the @Throttle() decorator to set different limits for individual routes:

import { Controller, Get } from "@nestjs/common";
import { Throttle } from "@nestjs/throttler";

@Controller("products")
export class ProductController {
  @Throttle({ default: { limit: 5, ttl: 30000 } }) // 5 requests per 30 seconds
  @Get()
  getProducts() {
    return "products list";
  }
}

This overrides the global limit for this route only.

Skip Rate Limiting for Specific Controllers or Routes

You can exclude an entire controller or just a specific route from throttling using @SkipThrottle().
Skip for Entire Controller

import { Controller, Get } from "@nestjs/common";
import { SkipThrottle } from "@nestjs/throttler";

@SkipThrottle()
@Controller("users")
export class UsersController {
  @Get()
  findAll() {
    return "user list";
  }
}

//Apply Skip Inside the Same Controller

@Controller("products")
export class ProductController {
  @SkipThrottle({ default: false }) // Explicitly apply rate limit
  @Get("image")
  getImage() {
    return "product image";
  }

  @SkipThrottle() // Skip rate limit for this route
  @Get("title")
  getTitle() {
    return "product title";
  }
}

Custom Rate Limiting Based on Email Instead of IP

By default, throttler uses the IP address to track requests. You can customize this by creating a custom guard that tracks based on the user’s email (if authenticated):

Create a Custom Guard

import {Injectable,CanActivate,ExecutionContext} from '@nestjs/common';
import {ThrottlerGuard,ThrottlerStorage,ThrottlerModuleOptions,} from '@nestjs/throttler';
import { JwtService } from '@nestjs/jwt';
import { AuthJwtConfig } from 'src/configs/auth-jwt.config';
import { Reflector, ModuleRef } from '@nestjs/core';
import { UsersApiService } from 'src/users/users-api.service';
import { UserSelectTypeQuery } from 'src/users/filters/user.filter';

@Injectable()
export class EmailThrottlerGuard extends ThrottlerGuard implements CanActivate{
private jwtService: JwtService;
private authJwtConfig: AuthJwtConfig;
private userData:UsersApiService;

constructor(
options: ThrottlerModuleOptions,
storageService: ThrottlerStorage,
reflector: Reflector,
moduleRef: ModuleRef,
) {
super(options, storageService, reflector);

 this.jwtService = moduleRef.get(JwtService, { strict: false });
 this.authJwtConfig = moduleRef.get(AuthJwtConfig, { strict: false });
 this.userData=moduleRef.get(UsersApiService,{strict:false})

}

protected async getTracker(req: Record<string, any>): Promise<string> {

// Check if it is login req and the request body contains a `username`.
// If available, use it to generate a unique key for rate limiting.
// This ensures that rate limiting is applied per user rather than per IP.
// if not login req then take token from req headers and decrypt token and find user id from token after that
// find user email from database and set as a key for rate limiting


 let key = 'anonymous';
 if (req.url === '/auth/login') {
   const username = req.body?.username;
   if (username) {
     key = `rate-limit-${username}`;
   }
   return key;
 }
 try {
   const authHeader = req.headers?.authorization;
   const token = authHeader?.split(' ')[1];
   if (token) {
     const decoded = this.jwtService.verify(token, {
       secret: this.authJwtConfig.secret,
     });
     if (decoded?.sub) {
       const parmaData=req.params
       parmaData.selectType="detail"
       const user = await this.userData.findOne(decoded.sub,new UserSelectTypeQuery())
       const userEmail = user?.email
       key = `rate-limit-${userEmail}`;
     }
   }
   else{
     if (req.body?.username) {
       key = `rate-limit-${req.body.username}`;
     }
   }
 } catch (err) {
   console.warn('JWT verification failed:', err.message);
 }
 return key;

}
}

Use the Custom Guard in AppModule

providers: [
    {
    provide: APP_GUARD,
    useClass: EmailThrottlerGuard,
    },
    ],

This allows you to limit each logged-in user separately, instead of by IP address.

Multiple Throttle Profiles: When & Why?

You can define multiple throttle profiles like "short" for spam-sensitive routes and "long" for daily caps. This allows more fine-grained control across different routes and use cases.
For example:

/login → use short burst limits
/daily-report → use long-term limits

Conclusion

By using @nestjs/throttler, you can:

Easily apply global rate limits
Override them per route with @Throttle()
Skip rate limits for certain routes using @SkipThrottle()
Customize user tracking via email instead of IP
Define multiple rate limit strategies (short vs long windows)

Rate limiting helps you protect your API, scale responsibly, and ensure fair use. Whether you're building a small app or a large-scale platform, adding this layer is a smart move.