Skip to content
Arcjet Docs

Next.js sensitive info reference

Arcjet Sensitive Information Detection protects against clients sending you sensitive information such as PII that you do not wish to handle.

Configuration

Sensitive Info is configured by specifying which mode you want it to run in.

The configuration definition is:

type SensitiveInfoOptions = {
  mode?: "LIVE" | "DRY_RUN";
  allow?: Array<SensitiveInfoType>; // Cannot be specified if `deny` is present
  deny?: Array<SensitiveInfoType>;// Cannot be specified if `allow` is present
  contextWindowSize?: number;
  detect?: (tokens: string[]) -> Array<SensitiveInfoType | undefined>;
};

The arcjet client is configured with one or more sensitiveInfo rules which take one or many SensitiveInfoOptions.

Per route

This configures sensitive info on a single route.

/app/api/arcjet/route.ts
import arcjet, { sensitiveInfo } from "@arcjet/next";
import { NextResponse } from "next/server";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  rules: [
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
  ],
});


export async function GET(req: Request) {
  const decision = await aj.protect(req);


  if (decision.isDenied() && decision.reason.isSensitiveInfo()) {
    return NextResponse.json(
      {
        error: "Unexpected sensitive info received",
        // Useful for debugging, but don't return it to the client in
        // production
        //reason: decision.reason,
      },
      { status: 400 },
    );
  }


  return NextResponse.json({
    message: "Hello world",
  });
}

Middleware

This will run on every request to your Next.js app, except for static assets (configured in the matcher - see the Next.js docs for details).

Create a file called middleware.ts in your project root (at the same level as pages or app or inside src):

/middleware.ts
import arcjet, { createMiddleware, sensitiveInfo } from "@arcjet/next";
export const config = {
  // matcher tells Next.js which routes to run the middleware on.
  // This runs the middleware on all routes except for static assets.
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};
const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  rules: [
    // Prevent your app receiving unexpected sensitive info
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
  ],
});
// Pass any existing middleware with the optional existingMiddleware prop
export default createMiddleware(aj);

Avoiding double protection with middleware

If you use Arcjet in middleware and individual routes, you need to be careful that Arcjet is not running multiple times per request. This can be avoided by excluding the API route from the middleware matcher.

For example, if you already have a sensitive info rule defined in the API route at /api/hello, you can exclude it from the middleware by specifying a matcher in /middleware.ts:

/middleware.ts
import arcjet, { createMiddleware, sensitiveInfo } from "@arcjet/next";
export const config = {
  // The matcher prevents the middleware executing on static assets and the
  // /api/hello API route because you already installed Arcjet directly
  matcher: ["/((?!_next/static|_next/image|favicon.ico|api/hello).*)"],
};
const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  rules: [
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
  ],
});
// Pass any existing middleware with the optional existingMiddleware prop
export default createMiddleware(aj);

Decision

The quick start example will deny requests that are determined to be suspicious, immediately returning a response to the client using Next.js middleware.

Arcjet also provides a single protect function that is used to execute your protection rules. This requires a request argument which is the request context as passed to the request handler.

This function returns a Promise that resolves to an ArcjetDecision object. This contains the following properties:

  • id (string) - The unique ID for the request. This can be used to look up the request in the Arcjet dashboard. It is prefixed with req_ for decisions involving the Arcjet cloud API. For decisions taken locally, the prefix is lreq_.
  • conclusion (ArcjetConclusion) - The final conclusion based on evaluating each of the configured rules. If you wish to accept Arcjet’s recommended action based on the configured rules then you can use this property.
  • reason (ArcjetReason) - An object containing more detailed information about the conclusion.
  • results (ArcjetRuleResult[]) - An array of ArcjetRuleResult objects containing the results of each rule that was executed.
  • ip (ArcjetIpDetails) - An object containing Arcjet’s analysis of the client IP address. See IP analysis in the SDK reference for more information.

See the SDK reference for more details about the rule results.

You check if a deny conclusion has been returned by a sensitive info rule by using decision.isDenied() and decision.reason.isSensitiveInfo() respectively.

You can iterate through the results and check whether a sensitive info rule was applied:

for (const result of decision.results) {
  console.log("Rule Result", result);
}

This example will log the full result as well as the sensitive info rule:

Create a new API route at /app/api/route/hello.ts:

/app/api/route/hello.ts
import arcjet, { sensitiveInfo } from "@arcjet/next";
import { NextResponse } from "next/server";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  // Tracking by ip.src is the default if not specified
  //characteristics: ["ip.src"],
  rules: [
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
  ],
});


export async function POST(req: Request) {
  const decision = await aj.protect(req);


  for (const result of decision.results) {
    console.log("Rule Result", result);


    if (result.reason.isSensitiveInfo()) {
      console.log("Sensitive info rule", result);
    }
  }


  if (decision.isDenied()) {
    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
  }


  return NextResponse.json({
    message: "Hello world",
  });
}

Custom entity detection

When configuring Arcjet Sensitive Info you can provide a custom detect function, this enables you to detect entities that we don’t support out of the box using custom logic.

The function will take a list of tokens and must return a list of either undefined, if the corresponding token in the input list is not sensitive, or the name of the entity if it does match. The number of tokens that are provided to the function is controlled by the contextWindowSize option, which defaults to 1. If you need additional context to perform detections then you can increase this value.

/app/api/arcjet/route.ts
import arcjet, { sensitiveInfo } from "@arcjet/next";
import { NextResponse } from "next/server";


// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.
function detectDash(tokens: string[]): Array<"CONTAINS_DASH" | undefined> {
  return tokens.map((token) => {
    if (token.includes("-")) {
      return "CONTAINS_DASH";
    }
  });
}


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  rules: [
    sensitiveInfo({
      deny: ["EMAIL", "CONTAINS_DASH"],
      mode: "LIVE",
      detect: detectDash,
      contextWindowSize: 2,
    }),
  ],
});


export async function POST(req: Request) {
  const decision = await aj.protect(req);


  for (const result of decision.results) {
    console.log("Rule Result", result);


    if (result.reason.isSensitiveInfo()) {
      console.log("Sensitive info rule", result);
    }
  }


  if (decision.isDenied()) {
    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
  }


  return NextResponse.json({
    message: "Hello world",
  });
}

Error handling

Arcjet is designed to fail open so that a service issue or misconfiguration does not block all requests. The SDK will also time out and fail open after 500ms when NODE_ENV is production and 1000ms otherwise. However, in most cases, the response time will be less than 20-30ms.

If there is an error condition, Arcjet will return an ERROR type and you can check the reason property for more information, like accessing decision.reason.message.

/app/api/hello/route.ts
import arcjet, { sensitiveInfo } from "@arcjet/next";
import { NextResponse } from "next/server";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  rules: [
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
  ],
});


export async function GET(req: Request) {
  const decision = await aj.protect(req);


  if (decision.isErrored()) {
    // Fail open by logging the error and continuing
    console.warn("Arcjet error", decision.reason.message);
    // You could also fail closed here for very sensitive routes
    //return NextResponse.json({ error: "Service unavailable" }, { status: 503 });
  }


  if (decision.isDenied()) {
    return NextResponse.json(
      {
        error: "Unexpected sensitive info received",
        // Useful for debugging, but don't return it to the client in
        // production
        //reason: decision.reason,
      },
      {
        status: 400,
      },
    );
  }


  return NextResponse.json({
    message: "Hello world",
  });
}

Testing

Arcjet runs the same in any environment, including locally and in CI. You can use the mode set to DRY_RUN to log the results of rule execution without blocking any requests.

We have an example test framework you can use to automatically test your rules. Arcjet can also be triggered based using a sample of your traffic.

See the Testing section of the docs for details.

Edge Functions

Arcjet works in Edge Functions and with the Edge Runtime.

/app/api/hello/route.ts
import arcjet, { shield, sensitiveInfo } from "@arcjet/next";
import { NextRequest, NextResponse } from "next/server";


export const config = {
  runtime: "edge",
};


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  rules: [
    sensitiveInfo({
      deny: ["EMAIL"],
      mode: "LIVE",
    }),
    shield({
      mode: "LIVE",
    }),
  ],
});


export default async function handler(req: NextRequest, res: NextResponse) {
  const decision = await aj.protect(req);


  if (decision.isDenied()) {
    return NextResponse.json(
      {
        error: "Unexpected sensitive info received",
        // Useful for debugging, but don't return it to the client in production
        //reason: decision.reason,
      },
      {
        status: 400,
      },
    );
  }


  return NextResponse.json({
    message: "Hello world",
  });
}

Discussion