Skip to content

Bun 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 arcjet, { detectBot } from "@arcjet/bun";
import { env } from "bun";
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 default {
port: 3000,
fetch: aj.handler(async (req) => {
const decision = await aj.protect(req);
if (decision.isDenied()) {
return new Response("Forbidden", { status: 403 });
}
return new Response("Hello world");
}),
};

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 arcjet, { detectBot } from "@arcjet/bun";
import { env } from "bun";
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 default {
port: 3000,
fetch: aj.handler(async (req) => {
const decision = await aj.protect(req);
if (decision.isDenied()) {
return new Response("Forbidden", { status: 403 });
}
return new Response("Hello world");
}),
};

Decision

The quick start example will deny requests that match the bot detection rules, immediately returning a response to the client.

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

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

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

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

You check if a deny conclusion has been returned by a 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 arcjet, { detectBot } from "@arcjet/bun";
import { env } from "bun";
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 default {
port: 3000,
fetch: aj.handler(async (req) => {
const decision = await aj.protect(req);
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 new Response("Forbidden", { status: 403 });
}
return new Response("Hello world");
}),
};

Bot type

Arcjet also returns more information about the bot type of the client we think made the request:

import arcjet, { detectBot } from "@arcjet/bun";
import { env } from "bun";
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", "LIKELY_AUTOMATED"],
}),
],
});
export default {
port: 3000,
fetch: aj.handler(async (req) => {
const decision = await aj.protect(req);
console.log("Arcjet decision", decision);
if (decision.isDenied() && decision.reason.isBot()) {
return new Response("Forbidden", { status: 403 });
}
return new Response("Hello world");
}),
};

Error handling

Arcjet is designed to fail open so that a service issue or misconfiguration does not block all requests. The SDK will also time out and fail open after 500ms when ARCJET_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, { detectBot } from "@arcjet/bun";
import { env } from "bun";
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 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("Forbidden", { status: 403 });
}
return new Response("Hello world");
}),
};