Sensitive information reference
Arcjet Sensitive Information Detection protects against clients sending you sensitive information such as PII that you do not wish to handle. All detection runs locally in your own environment through a pluggable detection backend: a built-in WebAssembly engine (the default) or the on-device Rampart NER model, which detects names, addresses, and government / financial identifiers in addition to the structured types.
Configuration
Section titled “Configuration”Sensitive information detection is configured by allowing or denying a subset of
sensitive information. The allow and deny lists are mutually-exclusive, such
that using allow will result in a DENY decision for any detected sensitive
information that is not specified in the allow list and using deny will
result in an ALLOW decision for any detected sensitive information that is not
specified in the deny list.
The arcjet client can be configured with one or more Sensitive information
rules. In JavaScript / TypeScript these are constructed with
sensitiveInfo(options: SensitiveInfoOptionsAllow | SensitiveInfoOptionsDeny).
In Python they are constructed with the detect_sensitive_info(...) factory.
allow and deny are mutually exclusive in both languages.
The optional backend selects which detection backend
runs — omit it to use the built-in engine, or pass rampart() for on-device NER
detection.
type SensitiveInfoOptionsAllow = { mode?: "LIVE" | "DRY_RUN"; allow?: Array<ArcjetSensitiveInfoType>; contextWindowSize?: number; // You can also provide a custom detection function to detect other types // of sensitive information (see below). detect?: (tokens: string[]) -> Array<SensitiveInfoType | undefined>; // Optionally swap the default WebAssembly detection engine for a custom // backend, such as the on-device Rampart NER model (see below). backend?: SensitiveInfoBackend;};type SensitiveInfoOptionsDeny = { mode?: "LIVE" | "DRY_RUN"; deny?: Array<ArcjetSensitiveInfoType>; contextWindowSize?: number; // You can also provide a custom detection function to detect other types // of sensitive information (see below). detect?: (tokens: string[]) -> Array<SensitiveInfoType | undefined>; // Optionally swap the default WebAssembly detection engine for a custom // backend, such as the on-device Rampart NER model (see below). backend?: SensitiveInfoBackend;};# Signature for arcjet.detect_sensitive_infodef detect_sensitive_info( *, # Mode.LIVE blocks requests; Mode.DRY_RUN logs only. Defaults to Mode.LIVE. mode: Mode = Mode.LIVE, # Entity types to allow (report only). Mutually exclusive with `deny`. allow: Sequence[str | SensitiveInfoEntityType] = (), # Entity types to deny. Mutually exclusive with `allow`. deny: Sequence[str | SensitiveInfoEntityType] = (), # Optional context window size for detection context_window_size: int | None = None, # You can also provide a custom detection function to detect other types # of sensitive information (see below). detect: Callable[[list[str]], Sequence[str | None]] | None = None, # Rate-limit characteristics (see https://docs.arcjet.com/fingerprints) characteristics: Sequence[str] = (),) -> SensitiveInfoDetection: ...
# Built-in entity types (SensitiveInfoEntityType enum members):# - SensitiveInfoEntityType.EMAIL# - SensitiveInfoEntityType.PHONE_NUMBER# - SensitiveInfoEntityType.IP_ADDRESS# - SensitiveInfoEntityType.CREDIT_CARD_NUMBERtype ArcjetSensitiveInfoType = | "EMAIL" | "PHONE_NUMBER" | "IP_ADDRESS" | "CREDIT_CARD_NUMBER" | "GIVEN_NAME" | "SURNAME" | "SSN" | "URL" | "TAX_ID" | "BANK_ACCOUNT" | "ROUTING_NUMBER" | "GOVERNMENT_ID" | "PASSPORT" | "DRIVERS_LICENSE" | "BUILDING_NUMBER" | "STREET_NAME" | "SECONDARY_ADDRESS" | "CITY" | "STATE" | "ZIP_CODE";Guards and routes
Arcjet can be integrated into NestJS in several places using NestJS guards or directly within the route controller:
- Global guard: Applies Arcjet rules on every request, but does not allow you to configure rules per route.
- Per route guard: Allows you to configure rules per route, but requires you to add the guard to every route and has limited flexibility.
- Within route: Requires some code duplication, but allows maximum flexibility because you can customize the rules and response.
Global guard
A global guard can be configured in src/app.module.ts.
import { ArcjetModule, sensitiveInfo } from "@arcjet/nest";import { Module } from "@nestjs/common";import { ConfigModule } from "@nestjs/config";
@Module({ imports: [ ConfigModule.forRoot({ isGlobal: true, envFilePath: ".env.local", }), ArcjetModule.forRoot({ isGlobal: true, key: process.env.ARCJET_KEY!, rules: [ // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ], }), // ... other modules ],})export class AppModule {}This can then be added to the controller for all the routes you wish to protect with Arcjet.
import { ArcjetGuard } from "@arcjet/nest";import { Body, Controller, Injectable, Post, Req, UseGuards,} from "@nestjs/common";
// This would normally go in your controller file e.g.// src/page/page.controller.ts@Controller("page")// Uses the ArcjetGuard to protect the controller with the default rules defined// in app.module.ts. Using a guard makes it easy to apply Arcjet rules, but you// don't get access to the decision.@UseGuards(ArcjetGuard)export class PageController { constructor(private readonly pageService: PageService) {}
@Post() async index(@Req() req: Request, @Body() body: string) { return this.pageService.message(body); }}
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}Per route guard
A per route guard can be configured in the controller for each route you wish to
protect with specific Arcjet rules. The client created in src/app.module.ts
is automatically passed to the guard.
The rules will be applied and a generic error returned if the result is DENY.
import { WithArcjetRules, sensitiveInfo } from "@arcjet/nest";import { Body, Injectable, Post, Req } from "@nestjs/common";
// This would normally go in your controller file e.g.// src/page/page.controller.ts// Attaches the ArcjetGuard to the controller to protect it with the specified// rules extended from the global rules defined in app.module.ts.@WithArcjetRules([ // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }),])export class PageController { constructor(private readonly pageService: PageService) {}
@Post() async index(@Req() req: Request, @Body() body: string) { return this.pageService.message(body); }}
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}Within route
Call Arcjet from within the route controller to have maximum flexibility.
import { ARCJET, type ArcjetNest, sensitiveInfo } from "@arcjet/nest";import { isSpoofedBot } from "@arcjet/inspect";import { Body, Controller, HttpException, HttpStatus, Inject, Injectable, Post, Req,} from "@nestjs/common";import type { Request } from "express";
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}
// This would normally go in your controller file e.g.// src/page/page.controller.ts@Controller("page")// Sets up the Arcjet protection without using a guard so we can access the// decision and use it in the controller.export class PageController { constructor( private readonly pageService: PageService, @Inject(ARCJET) private readonly arcjet: ArcjetNest, ) {}
@Post() async index(@Req() req: Request, @Body() body: string) { const decision = await this.arcjet .withRule( // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ) .protect(req);
if (decision.isDenied()) { if (decision.reason.isBot()) { throw new HttpException("No bots allowed", HttpStatus.FORBIDDEN); } else { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); } }
// Paid Arcjet accounts include additional verification checks using IP data. // Verification isn't always possible, so we recommend checking the results // separately. // https://docs.arcjet.com/bot-protection/reference#bot-verification if (decision.results.some(isSpoofedBot)) { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); }
return this.pageService.message(body); }}Per route vs hooks
Bot protection rules can be configured in two ways:
- Per route: The rule is defined in the route handler itself. This allows you to configure the rule alongside the code it is protecting which is useful if you want to use the decision to add context to your own code. However, it means rules are not located in a single place.
- Hooks: The rule is defined as a hook. This allows you to configure rules in a single place or apply them globally to all routes, but it means the rules are not located alongside the code they are protecting.
Per route
This configures bot protection on a single route.
import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function load(event: RequestEvent) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
if (decision.isDenied()) { return error(403, "You are suspicious!"); }
return {};}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function load(event) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
if (decision.isDenied()) { return error(403, "You are suspicious!"); }
return {};}Hooks
This will run on every request to your SvelteKit app - see the SvelteKit Hooks docs for details.
import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ // This allows all sensitive entities other than email addresses and those containing a dash character. sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ],});
export async function handle({ event, resolve }) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
if (decision.isDenied()) { return error(400, "Bad request - sensitive information detected"); }
return resolve(event);}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ // This allows all sensitive entities other than email addresses and those containing a dash character. sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ],});
export async function handle({ event, resolve,}: { event: RequestEvent; resolve: (event: RequestEvent) => Response | Promise<Response>;}): Promise<Response> { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
if (decision.isDenied()) { return error(400, "Bad request - sensitive information detected"); }
return resolve(event);}Avoiding double protection with hooks
If you use Arcjet in hooks and individual routes, you need to be careful that Arcjet is not running multiple times per request. This can be avoided by excluding the individual routes before running Arcjet in the hook.
For example, if you already have a sensitive info rule defined in the API route
at /api/arcjet, you can exclude it from the hook like this:
import { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";import { error, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, rules: [ detectBot({ mode: "LIVE", allow: [], // "allow none" will block all detected bots }), ],});
export async function handle({ event, resolve,}: { event: RequestEvent; resolve: (event: RequestEvent) => Response | Promise<Response>;}): Promise<Response> { // Ignore routes that extend the Arcjet rules // - they will call `.protect` themselves const filteredRoutes = ["/api/arcjet"]; if (filteredRoutes.includes(event.url.pathname)) { // return - route will handle protecttion return resolve(event); }
const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, "Forbidden"); }
return resolve(event);}Per route vs middleware
Bot protection rules can be configured in two ways:
- Per API route: The rule is defined in the API route itself. This allows you to configure the rule alongside the code it is protecting which is useful if you want to use the decision to add context to your own code. However, it means rules are not located in a single place.
- Middleware: The rule is defined in the middleware. This allows you to configure rules in a single place or apply them globally to all routes, but it means the rules are not located alongside the code they are protecting.
Per route
This configures bot protection on a single route.
import arcjet, { sensitiveInfo } from "@arcjet/next";
const aj = arcjet({ key: process.env.ARCJET_KEY, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
if (decision.isDenied() && decision.reason.isSensitiveInfo()) { return res .status(400) .json({ error: "Unexpected sensitive info received" }); // Returning the reason is useful for debugging, but don't return it to the // client in production // .json({ error: "You are suspicious!", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import type { NextApiRequest, NextApiResponse } from "next";
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
if (decision.isDenied() && decision.reason.isSensitiveInfo()) { return res .status(400) .json({ error: "Unexpected sensitive info received" }); // Returning the reason is useful for debugging, but don't return it to the // client in production // .json({ error: "You are suspicious!", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}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 POST(req: Request) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}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 POST(req) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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
Create a file called proxy.ts in your project root (at the same level as
pages or app or inside src):
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 propexport default createMiddleware(aj);Create a file called proxy.js in your project root (at the same level as
pages or app or inside src):
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 propexport 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 /proxy.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 propexport default createMiddleware(aj);Pages & Server Actions
Arcjet can be used inside Next.js middleware, API routes, pages, server components, and server actions. Client components cannot be protected because they run on the client only.
See the Next.js SDK reference for examples of pages / page components and server actions.
Detection backends
Section titled “Detection backends”Sensitive information detection runs through a detection backend — the
engine that scans the request body and identifies entities. The rest of the rule
(mode, allow/deny, and the result shape) is the same whichever backend you
choose. See Entity detection for exactly what each backend
detects.
Built-in engine
Section titled “Built-in engine”By default — when you don’t set a backend — the rule runs a WebAssembly engine
that detects four structured types: email addresses, phone numbers, IP
addresses, and credit card numbers. It runs anywhere the SDK runs, including edge
runtimes, needs no extra dependencies, and adds negligible latency, so it’s the
right choice for most applications. Extend it with a
custom detect function when you need to match your
own patterns.
On-device detection with Rampart
Section titled “On-device detection with Rampart”For broader coverage, the @arcjet/sensitive-info-rampart package provides a
backend powered by the on-device
Rampart
named-entity-recognition (NER) model. It runs a ~15 MB quantized ONNX model
locally so the rule can detect names, addresses, and government / financial
identifiers in addition to the built-in structured types. Everything runs in
your own environment — the model weights are bundled with the package, so
nothing is fetched at runtime and no data leaves your infrastructure.
Install the package alongside your Arcjet SDK:
npm install @arcjet/sensitive-info-rampartThen import rampart and pass it as the rule’s backend. Every entity the
model detects is a built-in ArcjetSensitiveInfoType, so you can list the types
directly in allow or deny:
import arcjet, { sensitiveInfo } from "@arcjet/bun";import { rampart } from "@arcjet/sensitive-info-rampart";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/bun";import { rampart } from "@arcjet/sensitive-info-rampart";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/remix";import { rampart } from "@arcjet/sensitive-info-rampart";import type { ActionFunctionArgs } from "@remix-run/node";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function action(args: ActionFunctionArgs) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { sensitiveInfo } from "@arcjet/remix";import { rampart } from "@arcjet/sensitive-info-rampart";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function action(args) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { sensitiveInfo } from "@arcjet/next";import { rampart } from "@arcjet/sensitive-info-rampart";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import { rampart } from "@arcjet/sensitive-info-rampart";import { NextResponse } from "next/server";
// The Rampart backend loads a native ONNX runtime, so this route must run on// the Node.js runtime, not the Edge runtime.export const runtime = "nodejs";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function POST(req: Request) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}import arcjet, { sensitiveInfo } from "@arcjet/next";import { rampart } from "@arcjet/sensitive-info-rampart";import type { NextApiRequest, NextApiResponse } from "next";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import { rampart } from "@arcjet/sensitive-info-rampart";import { NextResponse } from "next/server";
// The Rampart backend loads a native ONNX runtime, so this route must run on// the Node.js runtime, not the Edge runtime.export const runtime = "nodejs";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function POST(req) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { rampart } from "@arcjet/sensitive-info-rampart";import { error, json, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function POST(event: RequestEvent) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { rampart } from "@arcjet/sensitive-info-rampart";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
export async function POST(event) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/node";import { rampart } from "@arcjet/sensitive-info-rampart";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
const server = http.createServer(async function (req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(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()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import arcjet, { sensitiveInfo } from "@arcjet/node";import { rampart } from "@arcjet/sensitive-info-rampart";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and government/financial // identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ],});
const server = http.createServer(async function ( req: http.IncomingMessage, res: http.ServerResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(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()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import { ARCJET, type ArcjetNest, sensitiveInfo } from "@arcjet/nest";import { rampart } from "@arcjet/sensitive-info-rampart";import { Body, Controller, HttpException, HttpStatus, Inject, Injectable, Logger, Post, Req,} from "@nestjs/common";import type { Request } from "express";
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}
// This would normally go in your controller file e.g.// src/page/page.controller.ts@Controller("page")// Sets up the Arcjet protection without using a guard so we can access the// decision and use it in the controller.export class PageController { // Make use of the NestJS logger: https://docs.nestjs.com/techniques/logger private readonly logger = new Logger(PageController.name);
constructor( private readonly pageService: PageService, @Inject(ARCJET) private readonly arcjet: ArcjetNest, ) {}
@Post() async index(@Req() req: Request, @Body() body: string) { const decision = await this.arcjet .withRule( sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // The Rampart model detects names, addresses, and // government/financial identifiers in addition to the built-in types. deny: ["EMAIL", "GIVEN_NAME", "SURNAME", "STREET_NAME", "SSN"], // Run detection on-device with the Rampart NER model instead of the // default WebAssembly engine. backend: rampart(), }), ) .protect(req);
this.logger.log(`Arcjet: id = ${decision.id}`); this.logger.log(`Arcjet: decision = ${decision.conclusion}`);
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { throw new HttpException( "Unexpected sensitive info detected", HttpStatus.BAD_REQUEST, ); } else { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); } }
return this.pageService.message(body); }}Without a backend, the rule continues to use the built-in engine — this
package is entirely opt-in.
The full set of types the backend supports is exported as rampartEntities,
which is convenient when you want to deny everything it can detect:
import { rampart, rampartEntities } from "@arcjet/sensitive-info-rampart";
sensitiveInfo({ mode: "LIVE", deny: rampartEntities, backend: rampart() });Model accuracy and performance
Section titled “Model accuracy and performance”Rampart is a compact model — a ~14.7 MB artifact (~18.5M parameters, quantized to 4-bit weights) with a 512-token context window — so it is fast enough to run inline on each request:
- ~6.6 ms median (p50) inference on the Node.js CPU runtime.
- ~3.9 ms p50 on WebGPU (set
device: "webgpu").
On the model author’s held-out benchmark it recalls ~98% of private terms across the seven Latin-script languages it supports (English, Spanish, French, German, Italian, Portuguese, and Dutch).
Accuracy varies by input, so it’s worth knowing the trade-offs:
- Non-Latin scripts (for example Chinese, Japanese, Korean, Arabic, Hindi, or Cyrillic) have much lower recall — the model is trained on Latin-script text.
- Government / financial identifiers without a checksum (passports, licences, case numbers) are recognised less reliably than the structured types the deterministic recognizers validate, such as emails and card numbers.
- Inference runs synchronously in the request path, so this latency is added to each request the rule scans.
These figures come from the Rampart model card, which has the full per-language breakdown, calibration data, and limitations.
Rampart options
Section titled “Rampart options”The rampart() factory accepts an optional configuration object:
import { defaultRecognizers, rampart } from "@arcjet/sensitive-info-rampart";
rampart({ // Execution device (default: "cpu"). Set to "webgpu" to use a GPU when the // runtime supports it. device: "webgpu", // Minimum confidence score for a model token to count (default: 0.5). threshold: 0.6, // Deterministic recognizers to run alongside the model (default: // `defaultRecognizers`). This is the extension point for custom detection // with this backend — add a recognizer that returns matched spans. Pass `[]` // to rely on the model alone. recognizers: [ ...defaultRecognizers, (value) => { // Return an array of `{ start, end, type }` spans. return []; }, ],});The model loads once on first use and is reused for every subsequent request.
Bundlers and runtimes
Section titled “Bundlers and runtimes”The Rampart backend loads a native ONNX runtime
(@huggingface/transformers / onnxruntime-node) and reads its bundled model
weights from disk at runtime. As a result:
- It requires a server runtime with filesystem and native-addon access — Node.js, Bun, or Deno. It does not run on edge runtimes.
- It must not be bundled by a server build, or the runtime will fail to locate the model weights.
For Next.js, mark the package and its native dependencies as
server external packages
so they are loaded from node_modules at runtime instead of bundled, and make
sure any route handler that uses the backend runs on the Node.js runtime (the
default) rather than the Edge runtime:
/** @type {import('next').NextConfig} */const nextConfig = { serverExternalPackages: [ "@arcjet/sensitive-info-rampart", "@huggingface/transformers", "onnxruntime-node", ],};
module.exports = nextConfig;export const runtime = "nodejs";Decision
Section titled “Decision”Arcjet provides a single protect function that is used to execute your
protection rules.
If you are using a global guard or per route
guard then protect is called for you behind the scenes. If you add Arcjet
within a route then you call it directly.
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 withreq_for decisions involving the Arcjet cloud API. For decisions taken locally, the prefix islreq_.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 ofArcjetRuleResultobjects containing the results of each rule that was executed.ip(ArcjetIpDetails) - An object containing Arcjet’s analysis of the client IP address. See the SDK reference for more information.
You check if a deny conclusion has been returned by a sensitive info rule by using
decision.isDenied() and decision.reason.isSensitiveInfo() (JS) /
decision.is_denied() and decision.reason_v2.type == "SENSITIVE_INFO" (Python).
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);}for result in decision.results: print("Rule Result", result)This example will log the full result as well as the sensitive info rule:
import loggingimport os
from arcjet import Mode, SensitiveInfoEntityType, arcjet_sync, detect_sensitive_infofrom flask import Flask, jsonify, request
app = Flask(__name__)
logger = logging.getLogger(__name__)
aj = arcjet_sync( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=[SensitiveInfoEntityType.EMAIL], ), ],)
@app.post("/")def index(): message = request.get_data(as_text=True) decision = aj.protect(request, sensitive_info_value=message)
for result in decision.results: logger.info("Rule Result %s", result)
if result.reason_v2.type == "SENSITIVE_INFO": logger.info( "Sensitive info rule: allowed=%s denied=%s", result.reason_v2.allowed, result.reason_v2.denied, )
if decision.is_denied(): if decision.reason_v2.type == "SENSITIVE_INFO": return jsonify(error="Unexpected sensitive info detected"), 400 return jsonify(error="Forbidden"), 403
return jsonify(message="Hello world")import loggingimport os
from arcjet import Mode, SensitiveInfoEntityType, arcjet, detect_sensitive_infofrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponsefrom pydantic import BaseModel
app = FastAPI()
logger = logging.getLogger(__name__)
aj = arcjet( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=[SensitiveInfoEntityType.EMAIL], ), ],)
class Message(BaseModel): message: str
@app.post("/")async def index(request: Request, body: Message): decision = await aj.protect(request, sensitive_info_value=body.message)
for result in decision.results: logger.info("Rule Result %s", result)
if result.reason_v2.type == "SENSITIVE_INFO": logger.info( "Sensitive info rule: allowed=%s denied=%s", result.reason_v2.allowed, result.reason_v2.denied, )
if decision.is_denied(): if decision.reason_v2.type == "SENSITIVE_INFO": return JSONResponse( {"error": "Unexpected sensitive info detected"}, status_code=400, ) return JSONResponse({"error": "Forbidden"}, status_code=403)
return {"message": "Hello world"}import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};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 POST(req: Request) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}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 POST(req) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}import arcjet, { sensitiveInfo } from "@arcjet/next";
const aj = arcjet({ key: process.env.ARCJET_KEY, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, }); console.log("Decision", decision);
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import type { NextApiRequest, NextApiResponse } from "next";
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, }); console.log("Decision", decision);
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function GET(event: RequestEvent) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function GET(event) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import arcjet, { shield, sensitiveInfo } from "@arcjet/remix";import type { ActionFunctionArgs } from "@remix-run/node";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), shield({ mode: "LIVE", }), ],});
export async function action(args: ActionFunctionArgs) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { console.log("Sensitive info rule", result); }
if (result.reason.isShield()) { console.log("Shield protection rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { shield, sensitiveInfo } from "@arcjet/remix";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), shield({ mode: "LIVE", }), ],});
export async function action(args) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { console.log("Sensitive info rule", result); }
if (result.reason.isShield()) { console.log("Shield protection rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
const server = http.createServer(async function (req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isRateLimit()) { console.log("Rate limit rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import arcjet, { sensitiveInfo, shield } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), shield({ mode: "LIVE", }), ],});
const server = http.createServer(async function ( req: http.IncomingMessage, res: http.ServerResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { console.log("Sensitive info rule", result); }
if (result.reason.isShield()) { console.log("Shield protection rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import { ARCJET, type ArcjetNest, detectBot, sensitiveInfo,} from "@arcjet/nest";import { isSpoofedBot } from "@arcjet/inspect";import { Body, Controller, HttpException, HttpStatus, Inject, Injectable, Logger, Post, Req,} from "@nestjs/common";import type { Request } from "express";
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}
// This would normally go in your controller file e.g.// src/page/page.controller.ts@Controller("page")// Sets up the Arcjet protection without using a guard so we can access the// decision and use it in the controller.export class PageController { // Make use of the NestJS logger: https://docs.nestjs.com/techniques/logger // See // https://github.com/arcjet/example-nestjs/blob/ec742e58c8da52d0a399327182c79e3f4edc8f3b/src/app.module.ts#L29 // and https://github.com/arcjet/example-nestjs/blob/main/src/arcjet-logger.ts // for an example of how to connect Arcjet to the NestJS logger private readonly logger = new Logger(PageController.name);
constructor( private readonly pageService: PageService, @Inject(ARCJET) private readonly arcjet: ArcjetNest, ) {}
@Post() async index(@Req() req: Request, @Body() body: string) { const decision = await this.arcjet .withRule( detectBot({ mode: "LIVE", // will block requests. Use "DRY_RUN" to log only // configured with a list of bots to allow from // https://arcjet.com/bot-list allow: [], // blocks all automated clients }), ) .withRule( // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ) .protect(req);
this.logger.log(`Arcjet: id = ${decision.id}`); this.logger.log(`Arcjet: decision = ${decision.conclusion}`);
for (const result of decision.results) { this.logger.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { this.logger.log("Sensitive info rule", result); }
if (result.reason.isBot()) { this.logger.log("Bot protection rule", result); } }
if (decision.isDenied()) { if (decision.reason.isBot()) { throw new HttpException("No bots allowed", HttpStatus.FORBIDDEN); } else if (decision.reason.isSensitiveInfo()) { throw new HttpException( "Unexpected sensitive info detected", HttpStatus.BAD_REQUEST, ); } else { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); } }
// Paid Arcjet accounts include additional verification checks using IP data. // Verification isn't always possible, so we recommend checking the decision // separately. // https://docs.arcjet.com/bot-protection/reference#bot-verification if (decision.results.some(isSpoofedBot)) { return new HttpException("Forbidden", HttpStatus.FORBIDDEN); }
return this.pageService.message(body); }}Entity detection
Section titled “Entity detection”The entity types available to allow/deny depend on the active
detection backend. Every type below is a built-in
ArcjetSensitiveInfoType, so you can list any of them regardless of backend — a
type the active backend doesn’t detect simply never matches. You can also detect
your own types with custom entity detection.
| Entity type | Built-in engine (default) | Rampart backend |
|---|---|---|
EMAIL | ✅ | ✅ Model + recognizer |
PHONE_NUMBER | ✅ | ✅ Model + recognizer |
IP_ADDRESS | ✅ | ✅ Recognizer |
CREDIT_CARD_NUMBER | ✅ | ✅ Recognizer |
URL | — | ✅ Model + recognizer |
SSN | — | ✅ Recognizer |
GIVEN_NAME | — | ✅ Model |
SURNAME | — | ✅ Model |
TAX_ID | — | ✅ Model |
BANK_ACCOUNT | — | ✅ Model |
ROUTING_NUMBER | — | ✅ Model |
GOVERNMENT_ID | — | ✅ Model |
PASSPORT | — | ✅ Model |
DRIVERS_LICENSE | — | ✅ Model |
BUILDING_NUMBER | — | ✅ Model |
STREET_NAME | — | ✅ Model |
SECONDARY_ADDRESS | — | ✅ Model |
CITY | — | ✅ Model |
STATE | — | ✅ Model |
ZIP_CODE | — | ✅ Model |
| Custom | ✅ detect callback | ✅ recognizers option |
For the Rampart backend, Model means the type is detected by the on-device NER model, and Recognizer means it is detected by a deterministic, validated pattern (mirroring Rampart’s deterministic redaction layer). Where the model and a recognizer overlap on the same text, the recognizer wins.
Structured type matching
Section titled “Structured type matching”The structured types are matched the same way by the built-in engine and by the Rampart recognizers.
Card numbers
Section titled “Card numbers”Card numbers can be detected.
The values 4242424242424242, 4000 0566 5566 5556, and 3782-8224-6310005
match but 4242424242424241 does not.
Whether something looks like a card number is based on its initial and final
digits.
The initial digits determine the expected length (min, max) of the total
number.
The final digit is a Luhn
check digit.
Spaces and dashes are ignored because users often group digits.
Email addresses
Section titled “Email addresses”Email addresses can be detected.
The values alice@example.com and bob.smith@subdomain.example.com match but
alice.example.com does not.
A dotless domain (user@localhost) and a domain literal (user@[127.0.0.1],
if it contains a valid IP) also match.
IP addresses
Section titled “IP addresses”IP addresses can be detected.
The values 127.0.0.1 and ::1 match but 012.004.002.000 does not.
IP v4 and v6 addresses are supported.
Whether something looks like an IP address is based on whether it parses
as IpAddr from std::net.
Phone numbers
Section titled “Phone numbers”Phone numbers can be detected.
The values +1 (555) 555-5555 and (020) 334 4522 match but 555-1234 does not.
As phone numbers have a wide variety of sizes and formats,
special short numbers such as 911 or 14 020 are not detected.
Several characters such as dots (.), dashes (-), and spaces are allowed
to separate digit groups.
The country code can be prefixed with plus (+) or omitted,
the next region group can be in parentheses.
Custom entity detection
Section titled “Custom entity detection”When using the built-in engine you can provide a custom
detect function, which enables you to detect entities that Arcjet doesn’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.
import osfrom typing import Optional
from arcjet import Mode, arcjet_sync, detect_sensitive_infofrom flask import Flask, jsonify, request
# This function is called by the `detect_sensitive_info` rule to perform custom# detection on strings. It receives a list of tokens and must return a same-# length list of either an entity type name (string) or None.def detect_secret(tokens: list[str]) -> list[Optional[str]]: return ["CUSTOM_PII" if "secret" in token.lower() else None for token in tokens]
aj = arcjet_sync( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=["EMAIL", "CUSTOM_PII"], detect=detect_secret, context_window_size=2, ), ],)
app = Flask(__name__)
@app.post("/")def index(): message = request.get_data(as_text=True) decision = aj.protect(request, sensitive_info_value=message)
for result in decision.results: print("Rule Result", result)
if decision.is_denied(): if decision.reason_v2.type == "SENSITIVE_INFO": return jsonify(error="Unexpected sensitive info detected"), 400 return jsonify(error="Forbidden"), 403
return jsonify(message="Hello world")import osfrom typing import Optional
from arcjet import Mode, arcjet, detect_sensitive_infofrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponsefrom pydantic import BaseModel
# This function is called by the `detect_sensitive_info` rule to perform custom# detection on strings. It receives a list of tokens and must return a same-# length list of either an entity type name (string) or None.def detect_secret(tokens: list[str]) -> list[Optional[str]]: return ["CUSTOM_PII" if "secret" in token.lower() else None for token in tokens]
aj = arcjet( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=["EMAIL", "CUSTOM_PII"], detect=detect_secret, context_window_size=2, ), ],)
app = FastAPI()
class Message(BaseModel): message: str
@app.post("/")async def index(request: Request, body: Message): decision = await aj.protect(request, sensitive_info_value=body.message)
for result in decision.results: print("Rule Result", result)
if decision.is_denied(): if decision.reason_v2.type == "SENSITIVE_INFO": return JSONResponse( {"error": "Unexpected sensitive info detected"}, status_code=400, ) return JSONResponse({"error": "Forbidden"}, status_code=403)
return {"message": "Hello world"}import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
// 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: 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 default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { return tokens.map((token) => { if (token.includes("-")) { return "CONTAINS_DASH"; } });}
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", detect: detectDash, contextWindowSize: 2, }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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 new Response("Forbidden", { status: 403 }); }
return new Response("Hello world"); }),};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, { sensitiveInfoValue: await req.text(), });
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", });}import arcjet, { sensitiveInfo } from "@arcjet/next";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { 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"], mode: "LIVE", detect: detectDash, contextWindowSize: 2, }), ],});
export async function POST(req) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
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", });}import arcjet, { sensitiveInfo } from "@arcjet/next";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { 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"], mode: "LIVE", detect: detectDash, contextWindowSize: 2, }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, }); console.log("Decision", decision);
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import type { NextApiRequest, NextApiResponse } from "next";
// 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 default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, }); console.log("Decision", decision);
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 res .status(403) .json({ error: "Forbidden", reason: decision.reason }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/remix";import type { ActionFunctionArgs } from "@remix-run/node";
// 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 action(args: ActionFunctionArgs) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { sensitiveInfo } from "@arcjet/remix";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { 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 action(args) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json, type RequestEvent } from "@sveltejs/kit";
// 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: 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 GET(event: RequestEvent) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { 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"], mode: "LIVE", detect: detectDash, contextWindowSize: 2, }), ],});
export async function GET(event) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
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 error(403, "Forbidden"); }
return json({ message: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
// This function is called by the `sensitiveInfo` rule to perform custom detection on strings.function detectDash(tokens) { 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"], mode: "LIVE", detect: detectDash, contextWindowSize: 2, }), ],});
const server = http.createServer(async function (req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isRateLimit()) { console.log("Rate limit rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
// 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, }), ],});
const server = http.createServer(async function ( req: http.IncomingMessage, res: http.ServerResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), });
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isRateLimit()) { console.log("Rate limit rule", result); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Unexpected sensitive info detected", reason: decision.reason, }), ); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);Accessing the body
The Arcjet Sensitive Info rule accesses the request body, so if you also need to
access the body in your application code, you should parse it before calling
protect. Otherwise, you may see an error Body already read.
For example, using Express:
import arcjet, { sensitiveInfo } from "@arcjet/node";import express from "express";
const app = express();const port = 3000;
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ sensitiveInfo({ mode: "LIVE", deny: ["EMAIL"], }), ],});
// Body is accessed here first so it can be used in the protect method and// referenced later.app.use(express.text());
app.post("/", async (req, res) => { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
if (decision.isDenied() && decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Sensitive Information Detected", denied: decision.reason.denied, }), ); } else { res.writeHead(200, { "Content-Type": "application/json" }); // We can safely access the body here because it has already been referenced res.end(JSON.stringify({ message: `You said: ${req.body}` })); }});
app.listen(port, () => { console.log(`Example app listening on port ${port}`);});import arcjet, { sensitiveInfo } from "@arcjet/node";import express from "express";
const app = express();const port = 3000;
const aj = arcjet({ key: process.env.ARCJET_KEY, rules: [ sensitiveInfo({ mode: "LIVE", deny: ["EMAIL"], }), ],});
// Body is accessed here first so it can be used in the protect method and// referenced later.app.use(express.text());
app.post("/", async (req, res) => { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
if (decision.isDenied() && decision.reason.isSensitiveInfo()) { res.writeHead(400, { "Content-Type": "application/json" }); res.end( JSON.stringify({ error: "Sensitive Information Detected", denied: decision.reason.denied, }), ); } else { res.writeHead(200, { "Content-Type": "application/json" }); // We can safely access the body here because it has already been referenced res.end(JSON.stringify({ message: `You said: ${req.body}` })); }});
app.listen(port, () => { console.log(`Example app listening on port ${port}`);});import { ARCJET, type ArcjetNest, sensitiveInfo } from "@arcjet/nest";import { Body, Controller, HttpException, HttpStatus, Inject, Injectable, Logger, Post, Req,} from "@nestjs/common";import type { Request } from "express";
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}
// This would normally go in your controller file e.g.// src/page/page.controller.ts// 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"; } });}
@Controller("page")// Sets up the Arcjet protection without using a guard so we can access the// decision and use it in the controller.export class PageController { // Make use of the NestJS logger: https://docs.nestjs.com/techniques/logger // See // https://github.com/arcjet/example-nestjs/blob/ec742e58c8da52d0a399327182c79e3f4edc8f3b/src/app.module.ts#L29 // and https://github.com/arcjet/example-nestjs/blob/main/src/arcjet-logger.ts // for an example of how to connect Arcjet to the NestJS logger private readonly logger = new Logger(PageController.name);
constructor( private readonly pageService: PageService, @Inject(ARCJET) private readonly arcjet: ArcjetNest, ) {}
@Post() async index(@Req() req: Request, @Body() body: string) { const decision = await this.arcjet .withRule( // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL", "CONTAINS_DASH"], // Will block email addresses and strings containing a dash detect: detectDash, contextWindowSize: 2, }), ) .protect(req);
this.logger.log(`Arcjet: id = ${decision.id}`); this.logger.log(`Arcjet: decision = ${decision.conclusion}`);
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { throw new HttpException( "Unexpected sensitive info detected", HttpStatus.BAD_REQUEST, ); } else { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); } }
return this.pageService.message(body); }}Error handling
Section titled “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 1000ms in
development (see
ARCJET_ENV)
and 500ms otherwise. However, in most cases, the response time will be less than
20-30ms.
If there is an error condition when processing the rule, Arcjet will return an
ERROR result for that rule and you can check the message property on the rule’s
error result for more information.
If all other rules that were run returned an ALLOW result, then the final Arcjet
conclusion will be ERROR.
import loggingimport os
from arcjet import Mode, SensitiveInfoEntityType, arcjet_sync, detect_sensitive_infofrom flask import Flask, jsonify, request
app = Flask(__name__)
logger = logging.getLogger(__name__)
aj = arcjet_sync( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=[SensitiveInfoEntityType.EMAIL], ), ],)
@app.post("/")def index(): message = request.get_data(as_text=True) decision = aj.protect(request, sensitive_info_value=message) print("Arcjet decision", decision)
for result in decision.results: if result.reason_v2.type == "ERROR": # Fail open by logging the error and continuing logger.warning("Arcjet error: %s", result.reason_v2.message) # You could also fail closed here for very sensitive routes: # return jsonify(error="Service unavailable"), 503
if decision.is_denied(): return jsonify(error="Forbidden"), 403
return jsonify(message="Hello world")import loggingimport os
from arcjet import Mode, SensitiveInfoEntityType, arcjet, detect_sensitive_infofrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponsefrom pydantic import BaseModel
app = FastAPI()
logger = logging.getLogger(__name__)
aj = arcjet( key=os.environ["ARCJET_KEY"], # Get your site key from https://app.arcjet.com rules=[ detect_sensitive_info( mode=Mode.LIVE, deny=[SensitiveInfoEntityType.EMAIL], ), ],)
class Message(BaseModel): message: str
@app.post("/")async def index(request: Request, body: Message): decision = await aj.protect(request, sensitive_info_value=body.message) print("Arcjet decision", decision)
for result in decision.results: if result.reason_v2.type == "ERROR": # Fail open by logging the error and continuing logger.warning("Arcjet error: %s", result.reason_v2.message) # You could also fail closed here for very sensitive routes: # return JSONResponse({"error": "Service unavailable"}, status_code=503)
if decision.is_denied(): return JSONResponse({"error": "Forbidden"}, status_code=403)
return {"message": "Hello world"}import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return new Response("Service unavailable", { status: 503 }); } }
if (decision.isDenied()) { return new Response( "Your request contained unexpected sensitive information!", { status: 400 }, ); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/bun";import { env } from "bun";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default { port: 3000, fetch: aj.handler(async (req) => { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return new Response("Service unavailable", { status: 503 }); } }
if (decision.isDenied()) { return new Response( "Your request contained unexpected sensitive information!", { status: 400 }, ); }
return new Response("Hello world"); }),};import arcjet, { sensitiveInfo } from "@arcjet/next";
const aj = arcjet({ key: process.env.ARCJET_KEY, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return res.status(503).json({ error: "Service unavailable" }); } }
if (decision.isDenied()) { return res.status(400).json({ error: "Unexpected sensitive info received", }); }
res.status(200).json({ name: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/next";import type { NextApiRequest, NextApiResponse } from "next";
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: req.body, });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return res.status(503).json({ error: "Service unavailable" }); } }
if (decision.isDenied()) { return res.status(400).json({ error: "Unexpected sensitive info received", }); }
res.status(200).json({ name: "Hello world" });}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 POST(req: Request) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", 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", });}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 POST(req) { const decision = await aj.protect(req, { sensitiveInfoValue: await req.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", 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", });}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function GET(event: RequestEvent) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return error(503, { message: "Service unavailable" }); } }
if (decision.isDenied()) { return error(403, { message: "You are suspicious!" }); }
return json({ message: "Hello world" });}import { env } from "$env/dynamic/private";import arcjet, { sensitiveInfo } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function GET(event) { const decision = await aj.protect(event, { sensitiveInfoValue: await event.request.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //return error(503, { message: "Service unavailable" }); } }
if (decision.isDenied()) { return error(403, { message: "You are suspicious!" }); }
return json({ message: "Hello world" });}import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
const server = http.createServer(async function (req, res) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), }); console.log("Arcjet decision", decision);
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //res.writeHead(503, { "Content-Type": "application/json" }); //res.end(JSON.stringify({ error: "Service unavailable" })); } }
if (decision.isDenied()) { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";import { text } from "node:stream/consumers";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
const server = http.createServer(async function ( req: http.IncomingMessage, res: http.ServerResponse,) { const decision = await aj.protect(req, { sensitiveInfoValue: await text(req), }); console.log("Arcjet decision", decision);
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes //res.writeHead(503, { "Content-Type": "application/json" }); //res.end(JSON.stringify({ error: "Service unavailable" })); } }
if (decision.isDenied()) { res.writeHead(403, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Forbidden" })); } else { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ message: "Hello world" })); }});
server.listen(8000);import arcjet, { sensitiveInfo } from "@arcjet/remix";import type { ActionFunctionArgs } from "@remix-run/node";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function action(args: ActionFunctionArgs) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes // throw new Response("Service unavailable", { status: 503, statusText: "Service unavailable" }); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import arcjet, { sensitiveInfo } from "@arcjet/remix";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function action(args) { const decision = await aj.protect(args, { sensitiveInfoValue: await args.request.text(), });
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open by logging the error and continuing console.warn("Arcjet error", reason.message); // You could also fail closed here for very sensitive routes // throw new Response("Service unavailable", { status: 503, statusText: "Service unavailable" }); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { return Response.json( { error: "Please don't send personal data." }, { status: 400 }, ); } else { return Response.json({ error: "Forbidden" }, { status: 403 }); } }
// We don't need to use the decision elsewhere, but you could return it to // the component return null;}import { ARCJET, type ArcjetNest, sensitiveInfo } from "@arcjet/nest";import { Body, Controller, HttpException, HttpStatus, Inject, Injectable, Logger, Post, Req,} from "@nestjs/common";import type { Request } from "express";
// This would normally go in your service file e.g.// src/page/page.service.ts@Injectable()export class PageService { message(content: string): { message: string; submittedContent: string } { return { message: "Hello world", submittedContent: content, }; }}
// This would normally go in your controller file e.g.// src/page/page.controller.ts@Controller("page")// Sets up the Arcjet protection without using a guard so we can access the// decision and use it in the controller.export class PageController { // Make use of the NestJS logger: https://docs.nestjs.com/techniques/logger // See // https://github.com/arcjet/example-nestjs/blob/ec742e58c8da52d0a399327182c79e3f4edc8f3b/src/app.module.ts#L29 // and https://github.com/arcjet/example-nestjs/blob/main/src/arcjet-logger.ts // for an example of how to connect Arcjet to the NestJS logger private readonly logger = new Logger(PageController.name);
constructor( private readonly pageService: PageService, @Inject(ARCJET) private readonly arcjet: ArcjetNest, ) {}
@Post() async index(@Req() req: Request, @Body() body: string) { const decision = await this.arcjet .withRule( // This allows all sensitive entities other than email addresses sensitiveInfo({ mode: "LIVE", // Will block requests, use "DRY_RUN" to log only // allow: ["EMAIL"], Will block all sensitive information types other than email. deny: ["EMAIL"], // Will block email addresses }), ) .protect(req);
this.logger.log(`Arcjet: id = ${decision.id}`); this.logger.log(`Arcjet: decision = ${decision.conclusion}`);
for (const { reason } of decision.results) { if (reason.isError()) { // Fail open to prevent an Arcjet error from blocking all requests. You // may want to fail closed if this controller is very sensitive this.logger.error(`Arcjet error: ${reason.message}`); } }
if (decision.isDenied()) { if (decision.reason.isSensitiveInfo()) { throw new HttpException( "Unexpected sensitive info detected", HttpStatus.BAD_REQUEST, ); } else { throw new HttpException("Forbidden", HttpStatus.FORBIDDEN); } }
return this.pageService.message(body); }}Testing
Section titled “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.