Hosted browser platforms: what a Browserbase or Kernel signature tells you

A hosted browser signature identifies the platform, not its customer. Rate limit per platform and require a session for writes.

7 min read
In short: A Browserbase Web Bot Auth signature proves that a Browserbase browser session sent the request, not which customer's agent sent it or what it intends. Kernel and Cloudflare Browser Run work the same way. Arcjet reports the platform's bot ID with SIGNATURE evidence and the key directory's hostname as operator. Allow signed platform traffic on read routes, rate limit it per platform, and require a signed-in session before it writes.

What does a Browserbase or Kernel Web Bot Auth signature prove?

A Browserbase Web Bot Auth signature proves that the request came from a Browserbase browser session, not which Browserbase customer's agent sent it or what that agent intends. The same holds for Kernel and Cloudflare Browser Run. A hosted browser platform runs browser sessions for many unrelated companies and signs their requests with the platform's own key, so a valid signature identifies the platform as the operator.

That's still useful. A request that verifies against the platform's key directory didn't come from a script that copied a User-Agent header, and you can rate limit, allow, or deny the platform as one client. What the signature doesn't give you is the customer or the person behind the session.

For more information about how Web Bot Auth signatures work, see Web Bot Auth.

Which hosted browser platforms sign their requests?

As of November 2026, Browserbase, Kernel, and Cloudflare Browser Run document Web Bot Auth signing for the browser sessions they host, and Arcjet verifies all three by bot ID. Each platform turns signing on in a different way, so not every session from a platform arrives signed.

PlatformArcjet bot IDArcjet categoryHow signing works, per the platform's docs
BrowserbaseBROWSERBASECATEGORY:AI_AGENT

Web Bot Auth is in beta, and customers request access. See

Browserbase identity

.

KernelKERNEL_AGENTCATEGORY:TOOL

Kernel's own signing identity is off by default and enabled on request for eligible plans. Customers can sign with their own keys instead. See

Kernel Web Bot Auth

.

Cloudflare Browser RunCLOUDFLARE_BROWSER_RUNCATEGORY:TOOL

Browser Run adds the signature headers automatically, and customers can't remove them. See

Browser Run automatic request headers

.

Browserbase describes the feature as a way to "identify your browser traffic with cryptographic signatures so participating websites can recognize it," and says that websites apply their own access policies to it. Kernel's docs describe two options: sign with one of Kernel's bot identities, or publish your own key directory and sign with your own keys. Cloudflare's docs state that the User-Agent header isn't a reliable way to identify Browser Run requests, and point site owners to the signature instead.

Kernel also runs a search crawler, KERNEL_SEARCH, which signs with a separate key directory and is in CATEGORY:SEARCH_ENGINE. It's a crawler, not a hosted browser session.

Why does one signature cover many customers?

One signature covers many customers because the platform holds the signing key, and every session that the platform signs uses it. Arcjet reports what the key proves: the bot ID of the platform, SIGNATURE evidence, and an operator that is the hostname of the platform's key directory. The well-known-bots catalog records the platform, not the customer, and describes each of these entries as a signing identity for browser sessions, not a claim about the customer's agent.

A Browserbase request that verifies produces the following identity:

{
"kind": "AI_AGENT",
"botId": "BROWSERBASE",
"operator": "www.browserbase.com",
"evidence": "SIGNATURE",
"spoofed": false,
"delegated": false
}

The kind follows the catalog category. Browserbase is in CATEGORY:AI_AGENT, so its identity has kind AI_AGENT, and isAiAgent returns true for it. Kernel's and Browser Run's browser signers are in CATEGORY:TOOL, so their identities have kind OTHER, and a rule that allows only CATEGORY:AI_AGENT denies them.

A customer that signs with its own key directory, as Kernel allows, isn't a platform identity. If that directory isn't in the catalog, you can allow or deny it by its URL with a SIGNED_BOT: entry, and Arcjet reports the SIGNED_BOT: ID as the bot ID.

When a request matches several bots, Arcjet reports the one with the strongest evidence. A verified platform signature outranks a User-Agent claim in the same request. For more information about the evidence levels, see AI agent evidence levels.

What can't a hosted browser signature tell you?

A hosted browser signature can't tell you which customer runs the session, which person the agent works for, or whether the action is one that person wants. It also doesn't cover sessions that the platform didn't sign. Those requests look like Chrome from a cloud network.

The following limits apply to every platform signature:

  • No customer. Unrelated companies share one bot ID, one operator, and one key.
  • No delegation. delegated is false. Only a verified Personal Agent Protocol session from an agent in the catalog sets it. For more information, see what is the Personal Agent Protocol.
  • Replay within the expiry window. A signature that covers only @authority can be replayed until it expires.
  • Partial coverage. Signing is opt-in on Browserbase and Kernel, so unsigned sessions from the same platforms fall back to your other signals, such as advanced signals.

What policy fits signed hosted browser traffic?

Admit signed hosted browser traffic on read routes, give each platform one rate limit, and require a signed-in session before it writes anything. Because many customers share one identity, a per-platform budget caps the total that all of them can use, and one customer's job can't take capacity that your other visitors need.

Rate limit hosted browsers per platform in JavaScript

The following Express route allows search engines, AI agents, and the two hosted browser signers in CATEGORY:TOOL. It keys a rate limit on the bot ID of any signed platform, and keeps writes for signed-in sessions:

import arcjet, {
detectBot,
slidingWindow,
type ArcjetBotIdentity,
type ArcjetDecision,
} from "@arcjet/node";
import express from "express";
const HOSTED_BROWSERS = new Set([
"BROWSERBASE",
"KERNEL_AGENT",
"CLOUDFLARE_BROWSER_RUN",
]);
const aj = arcjet({
key: process.env.ARCJET_KEY!,
rules: [
detectBot({
mode: "LIVE",
allow: [
"CATEGORY:SEARCH_ENGINE",
"CATEGORY:AI_AGENT", // Includes BROWSERBASE
"KERNEL_AGENT",
"CLOUDFLARE_BROWSER_RUN",
],
}),
],
});
// One budget for each platform, shared by all of its customers
const platformLimit = arcjet({
key: process.env.ARCJET_KEY!,
characteristics: ["botId"],
rules: [slidingWindow({ mode: "LIVE", interval: "1m", max: 300 })],
});
// Return the hosted browser platform that signed the request, if any
function signedPlatform(
decision: ArcjetDecision,
): ArcjetBotIdentity | undefined {
for (const result of decision.results) {
if (!result.reason.isBot()) continue;
const identity = result.reason.identity;
if (
identity?.evidence === "SIGNATURE" &&
HOSTED_BROWSERS.has(identity.botId)
) {
return identity;
}
}
return undefined;
}
const app = express();
app.get("/products/:id", async (req, res) => {
const decision = await aj.protect(req);
if (decision.isDenied()) {
return res.status(403).json({ error: "Forbidden" });
}
const platform = signedPlatform(decision);
if (platform) {
const limit = await platformLimit.protect(req, { botId: platform.botId });
if (limit.isDenied()) {
return res.status(429).json({ error: "Too many requests" });
}
}
res.json({ id: req.params.id });
});
app.listen(3000);

On a write route, such as a cart or a form, check for a signed-in session before you accept a request from a signed platform. The signature tells you the platform sent the request, and the session tells you which of your users is accountable for it.

Rate limit hosted browsers per platform in Python

The Python SDK reads the same identity from reason_v2:

from arcjet import BotIdentity, Decision
HOSTED_BROWSERS = {"BROWSERBASE", "KERNEL_AGENT", "CLOUDFLARE_BROWSER_RUN"}
def signed_platform(decision: Decision) -> BotIdentity | None:
"""Return the hosted browser platform that signed the request, if any."""
for result in decision.results:
reason = result.reason_v2
if reason.type != "BOT" or reason.identity is None:
continue
identity = reason.identity
signed = identity.evidence == "SIGNATURE"
if signed and identity.bot_id in HOSTED_BROWSERS:
return identity
return None

Pass the identity's bot_id as the botId characteristic of a sliding_window rule, as the AI agents guide in the Arcjet docs shows.

To deny one platform outright, add its bot ID to a deny list. A deny list with BROWSERBASE blocks verified Browserbase sessions without blocking every Chrome user on a cloud network. For more information about choosing limits, see the rate limiting guide.

Frequently asked questions

Does a Browserbase signature identify the customer?

No. Browserbase signs sessions for many unrelated customers with its own key, so a valid signature proves that a Browserbase session sent the request. It doesn't identify the customer, the person the agent works for, or what the agent intends.

Is Browserbase an AI agent in Arcjet?

Yes. BROWSERBASE is in CATEGORY:AI_AGENT, so a verified Browserbase signature has kind AI_AGENT and SIGNATURE evidence, and isAiAgent returns true for it. The operator is the hostname of Browserbase's key directory.

Why does Arcjet deny Kernel sessions when I allow CATEGORY:AI_AGENT?

Kernel's browser signer, KERNEL_AGENT, and Cloudflare Browser Run, CLOUDFLARE_BROWSER_RUN, are in CATEGORY:TOOL, not CATEGORY:AI_AGENT. Add their bot IDs to the allow list of detectBot to admit them.

Can a hosted browser customer sign with its own key?

Kernel's docs describe signing with your own key directory as an alternative to Kernel's identity, as of November 2026. A directory that isn't in the well-known-bots catalog can be allowed or denied with a SIGNED_BOT: entry that names its URL.

Should I block hosted browser platforms?

Usually not on public read routes, because customers' agents use them to research products and answer questions. Give each platform one rate limit keyed on its bot ID, require a signed-in session before it writes, and deny a platform by bot ID if you don't want its traffic.

Does every Browserbase or Kernel session arrive signed?

No. As of November 2026, signing is in beta on Browserbase and enabled on request on Kernel, so unsigned sessions look like Chrome from a cloud network. Cloudflare's docs state that Browser Run adds the signature headers automatically.

Application security in your code

Protect your application with Arcjet

Arcjet verifies hosted browser signatures by bot ID and reports the platform as the operator, so you can give each platform one rate limit and keep writes for signed-in sessions.