NestJS set HttpStatus in interceptor

I’m using an interceptor to transform my response. I want to set the HttpStatus inside but the code I’m using now doesn’t work.

import { CallHandler, ExecutionContext, NestInterceptor, SetMetadata } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
import { classToPlain } from 'class-transformer';
import { ApiResponse } from '../models/apiResponse';

export class TransformInterceptor implements NestInterceptor {
    context: ExecutionContext,
    next: CallHandler<ApiResponse | any>,
  ): Observable<ApiResponse | any> {
    return next.handle().pipe(
      map(data => {
        const http = context.switchToHttp();
        const res = http.getResponse();

        if(data instanceof ApiResponse) {
          if(data.status !== undefined) {

        return classToPlain(data);

Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

Solution 1

Updated Answer

Since nest version 6.1.0, it is possible to set the status code in an interceptor; it will not be overwritten anymore (see this PR):


Outdated Answer

Setting the status code from an Interceptor is impossible (see this issue) because:

  • sometimes response status codes are dependent on exceptions and exception filters are executed after interceptors,
  • global response controller’s logic is the last step performed just before sending a final result through the network (that’s the place
    where default status codes come in).

So your status code will be overridden by the default code 200/201 or an exception filter.

As a (hacky) workaround, you can use exception filters to set the status code in interceptors:

1) Create your own exception as a wrapper around HttpException:

export class StatusException extends HttpException {
  constructor(data, status: HttpStatus) {
    super(data, status);

2) Create an exception filter that sets the response code and returns the data:

export class StatusFilter implements ExceptionFilter {
  catch(exception: StatusException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const status = exception.getStatus();
    console.log(`Setting status to ${status}`);

3) Instead of setting the response throw the according exception in your interceptor:

export class StatusInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next): Observable<any> {
    return next.handle().pipe(
      map((data: any) => {
        if (data.text === 'created') {
          throw new StatusException(data, HttpStatus.CREATED);
        } else {
          throw new StatusException(data, HttpStatus.ACCEPTED);

4) Use it in your controller:

export class AppController {
  async get(@Param('param') param) {
    return { text: param };

Alternatively, you can inject @Res() in your controller and directly control the response code (but also losing interceptors, exception filters, etc.)

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Reply