SvelteKit bot protection reference
Arcjet bot detection allows you to manage traffic by automated clients and bots.
Configuration
Bot detection is configured by specifying the bot types you wish to block and optional user agent patterns to add or remove from the bot detection list.
The configuration definition is:
type BotOptions = { mode?: "LIVE" | "DRY_RUN"; block?: BotType[]; patterns?: { add?: { [key: string]: BotType }; remove?: string[]; };};
The arcjet
client is configured with one or more detectBot
rules which take
one or many BotOptions
.
Which bots to block?
Which bot types to block is configured by listing one or more types in the
block
configuration block. The types are listed on the bot
types page.
Adding bot detection rules
You can add additional bot detection rules to the patterns
add
configuration
property. Each rule is a regular expression that matches the user agent of the
bot plus a label to indicate what type of bot it is.
The following example adds a rule to detect AcmeBot as an AUTOMATED
bot.
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!, // Get your site key from https://app.arcjet.com rules: [ detectBot({ mode: "LIVE", block: [ // Only block clients we're sure are automated bots "AUTOMATED", ], patterns: { add: { // Allows you to add arbitrary bot definitions "AcmeBot\\/": "AUTOMATED", }, }, }), ],});
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(403, "You are a bot!"); }
return resolve(event);}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } 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: [ detectBot({ mode: "LIVE", block: [ // Only block clients we're sure are automated bots "AUTOMATED", ], patterns: { add: { // Allows you to add arbitrary bot definitions "AcmeBot\\/": "AUTOMATED", }, }, }), ],});
export async function handle({ event, resolve }) { const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, "You are a bot!"); }
return resolve(event);}
Removing bot detection rules
Arcjet includes a set of default matching rules to detect common bots. You can
remove any of these rules by listing them in the patterns
remove
configuration property:
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!, // Get your site key from https://app.arcjet.com rules: [ detectBot({ mode: "LIVE", block: [ // Only block clients we're sure are automated bots "AUTOMATED", ], patterns: { remove: [ // Removes the datadog agent from the list of bots so it will be // considered as ArcjetBotType.LIKELY_NOT_A_BOT "datadog agent", // Also allow curl clients to pass through. Matches a user agent // string with the word "curl" in it "^curl", ], }, }), ],});
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(403, "You are a bot!"); }
return resolve(event);}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } 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: [ detectBot({ mode: "LIVE", block: [ // Only block clients we're sure are automated bots "AUTOMATED", ], patterns: { remove: [ // Removes the datadog agent from the list of bots so it will be // considered as ArcjetBotType.LIKELY_NOT_A_BOT "datadog agent", // Also allow curl clients to pass through. Matches a user agent // string with the word "curl" in it "^curl", ], }, }), ],});
export async function handle({ event, resolve }) { const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, "You are a bot!"); }
return resolve(event);}
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, { detectBot } from "@arcjet/sveltekit";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: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
export async function GET(event: RequestEvent) { const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, { message: "Forbidden" }); }
return json({ message: "Hello world" });}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
export async function GET(event) { const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, { message: "Forbidden" }); }
return json({ message: "Hello world" });}
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, { detectBot } 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: [ detectBot({ mode: "LIVE", // will block requests. Use "DRY_RUN" to log only block: ["AUTOMATED"], // blocks all automated clients }), ],});
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(403, "Forbidden"); }
return resolve(event);}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } 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: [ detectBot({ mode: "LIVE", // will block requests. Use "DRY_RUN" to log only block: ["AUTOMATED"], // blocks all automated clients }), ],});
export async function handle({ event, resolve }) { const decision = await aj.protect(event);
if (decision.isDenied()) { return error(403, "Forbidden"); }
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 rules 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", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
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 match the bot detection rules, immediately returning a response to the client using SvelteKit hooks.
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 ofArcjetRuleResult
objects containing the results of each rule that was executed.ip
(ArcjetIpDetails
) - An object containing Arcjet’s analysis of the client IP address. See IP analysis in the SDK reference for more information.
See the SDK reference for more details about the rule results.
You check if a deny conclusion has been returned by a bot protection rule by
using decision.isDenied()
and decision.reason.isBot()
respectively.
You can iterate through the results and check whether a bot protection 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 bot protection rule:
import { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";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: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
export async function POST(event: RequestEvent) { const decision = await aj.protect(event); console.log("Arcjet decision", decision);
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isRateLimit()) { console.log("Rate limit rule", result); }
if (result.reason.isBot()) { console.log("Bot protection rule", result); } }
if (decision.isDenied()) { return error(403, "Forbidden"); }
return json({ message: "Hello world" });}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, // Get your site key from https://app.arcjet.com rules: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
export async function POST(event) { const decision = await aj.protect(event); console.log("Arcjet decision", decision);
for (const result of decision.results) { console.log("Rule Result", result);
if (result.reason.isRateLimit()) { console.log("Rate limit rule", result); }
if (result.reason.isBot()) { console.log("Bot protection rule", result); } }
if (decision.isDenied()) { return error(403, "Forbidden"); }
return json({ message: "Hello world" });}
Bot type
In the code above, you will see that Arcjet also returns more information in
the decicion
object about the bot type of the
client we think made the request.
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 { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";import { error, json, type RequestEvent } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY!, rules: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
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 a bot!" }); }
return json({ message: "Hello world" });}
import { env } from "$env/dynamic/private";import arcjet, { detectBot } from "@arcjet/sveltekit";import { error, json } from "@sveltejs/kit";
const aj = arcjet({ key: env.ARCJET_KEY, rules: [ detectBot({ mode: "LIVE", block: ["AUTOMATED", "LIKELY_AUTOMATED"], }), ],});
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 a bot!" }); }
return json({ message: "Hello world" });}