Sensitive information reference
Arcjet Sensitive Information Detection protects against clients sending you sensitive information such as PII that you do not wish to handle.
Configuration
Sensitive Info is configured by specifying which mode you want it to run in.
The configuration definition is:
type SensitiveInfoOptions = { mode?: "LIVE" | "DRY_RUN"; allow?: Array<SensitiveInfoType>; // Cannot be specified if `deny` is present deny?: Array<SensitiveInfoType>;// Cannot be specified if `allow` is present contextWindowSize?: number; detect?: (tokens: string[]) -> Array<SensitiveInfoType | undefined>;};The arcjet client is configured with one or more sensitiveInfo rules which take
one or many SensitiveInfoOptions.
Per route 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);
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);
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);
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);
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 middleware.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 middleware.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 /middleware.ts:
import arcjet, { createMiddleware, sensitiveInfo } from "@arcjet/next";export const config = { // The matcher prevents the middleware executing on static assets and the // /api/hello API route because you already installed Arcjet directly matcher: ["/((?!_next/static|_next/image|favicon.ico|api/hello).*)"],};const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});// Pass any existing middleware with the optional existingMiddleware propexport default createMiddleware(aj);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);
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);
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);
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);
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);}Decision
The quick start example will deny requests that are determined to be suspicious, immediately returning a response to the client using SvelteKit’s server hook.
Arcjet also provides a single protect function that is used to execute your
protection rules. This requires a RequestEvent property which is the event
context as passed to the request handler.
This function returns a Promise that resolves to an
ArcjetDecision object. This contains the following properties:
id(string) - The unique ID for the request. This can be used to look up the request in the Arcjet dashboard. It is prefixed 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 IP analysis in the SDK reference for more information.
See the SDK reference for more details about the rule results.
You check if a deny conclusion has been returned by a sensitive info rule by using
decision.isDenied() and decision.reason.isSensitiveInfo() respectively.
You can iterate through the results and check whether a sensitive info rule was applied:
for (const result of decision.results) { console.log("Rule Result", result);}This example will log the full result as well as the sensitive info rule:
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);
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);
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 { 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);
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);
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/next";import { NextResponse } from "next/server";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Tracking by ip.src is the default if not specified //characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function POST(req: Request) { const decision = await aj.protect(req);
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { console.log("Sensitive info rule", result); } }
if (decision.isDenied()) { return NextResponse.json({ error: "Forbidden" }, { status: 403 }); }
return NextResponse.json({ message: "Hello world", });}import arcjet, { sensitiveInfo } from "@arcjet/next";import { NextResponse } from "next/server";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Tracking by ip.src is the default if not specified //characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export async function POST(req) { const decision = await aj.protect(req);
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isSensitiveInfo()) { console.log("Sensitive info rule", result); } }
if (decision.isDenied()) { return NextResponse.json({ error: "Forbidden" }, { status: 403 }); }
return NextResponse.json({ message: "Hello world", });}import arcjet, { sensitiveInfo } from "@arcjet/next";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Tracking by ip.src is the default if not specified //characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler(req, res) { const decision = await aj.protect(req); 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!, // Tracking by ip.src is the default if not specified //characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
export default async function handler( req: NextApiRequest, res: NextApiResponse,) { const decision = await aj.protect(req); 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/node";import http from "node:http";
const aj = arcjet({ key: process.env.ARCJET_KEY, // Get your site key from https://app.arcjet.com characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
const server = http.createServer(async function (req, res) { const decision = await aj.protect(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";
const aj = arcjet({ key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com characteristics: ["ip.src"], rules: [ sensitiveInfo({ deny: ["EMAIL"], mode: "LIVE", }), ],});
const server = http.createServer(async function ( req: http.IncomingMessage, res: http.ServerResponse,) { const decision = await aj.protect(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);Custom entity detection
When configuring Arcjet Sensitive Info you can provide a custom detect function, this enables you to detect entities that we don’t support out of the box using custom logic.
The function will take a list of tokens and must return a list of either
undefined, if the corresponding token in the input list is not sensitive, or
the name of the entity if it does match. The number of tokens that are provided
to the function is controlled by the contextWindowSize option, which defaults
to 1. If you need additional context to perform detections then you can increase
this value.
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);
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);
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);
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);
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); 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); 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";
// 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);
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);
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";
// 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);
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";
// 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);
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);
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);
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}`);});Error handling
Arcjet is designed to fail open so that a service issue or misconfiguration does
not block all requests. The SDK will also time out and fail open after 500ms
when NODE_ENV is production and 1000ms otherwise. However, in most cases,
the response time will be less than 20-30ms.
If there is an error condition, Arcjet will return an
ERROR type and you can check the reason property for more information, like
accessing decision.reason.message.
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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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 { 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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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/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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return 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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return NextResponse.json({ error: "Service unavailable" }, { status: 503 }); }
if (decision.isDenied()) { return NextResponse.json( { error: "Unexpected sensitive info received", // Useful for debugging, but don't return it to the client in // production //reason: decision.reason, }, { status: 400, }, ); }
return NextResponse.json({ message: "Hello world", });}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);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //return NextResponse.json({ error: "Service unavailable" }, { status: 503 }); }
if (decision.isDenied()) { return NextResponse.json( { error: "Unexpected sensitive info received", // Useful for debugging, but don't return it to the client in // production //reason: decision.reason, }, { status: 400 }, ); }
return NextResponse.json({ message: "Hello world", });}import arcjet, { sensitiveInfo } from "@arcjet/node";import http from "node:http";
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); console.log("Arcjet decision", decision);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //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";
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); console.log("Arcjet decision", decision);
if (decision.isErrored()) { // Fail open by logging the error and continuing console.warn("Arcjet error", decision.reason.message); // You could also fail closed here for very sensitive routes //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);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.