NestJS Interceptors – A Developer's Perspective

Let’s talk about one of the most underrated yet powerful features in NestJS – Interceptors. If you’ve been building APIs with Nest, you’re probably familiar with pipes, guards, and filters. But interceptors? They deserve way more attention.

What Are Interceptors?

At a high level, interceptors are similar to middleware—but with more flexibility. They sit in the request-response lifecycle and can modify the incoming request, transform the outgoing response, or even wrap method execution with extra behavior. Perfect for logging, caching, or formatting responses consistently.

When to Use Interceptors

A common use case is wrapping every response in a consistent structure. Instead of repeating the same formatting logic in every controller, an interceptor can take care of it globally. They’re also ideal for logging request durations, transforming errors, or even adding custom headers.

Example: Response Wrapper Interceptor

Here’s a basic interceptor that wraps all outgoing responses in a consistent format:

```
import { CallHandler,  ExecutionContext,  Injectable,  NestInterceptor } from ’@nestjs/common’;

import { Observable } from ’rxjs’;

import { map } from ’rxjs/operators’;

@Injectable()

export class ResponseInterceptor<T> implements NestInterceptor<T, any> {

  intercept(context: ExecutionContext, next: CallHandler<T>): Observable<any> {

    return next.handle().pipe(

      map((data) => ({

        success: true,

        data,

      })),

    );

  }

}```

Apply it globally or per-controller, and boom—your responses are now clean and uniform.

Things to Keep in Mind

Interceptors should focus on cross-cutting concerns only. Avoid using them for business logic—that’s what services are for. Also, keep them modular and easy to read. Chaining multiple interceptors? Make sure each one has a single, clear responsibility.

They’re especially useful when combined with other features like dependency injection and request-scoped providers.

 Interceptors are one of those tools that, once you start using them properly, you won’t want to go back. Clean, powerful, and incredibly flexible.