What is agentic commerce bot protection?
Agentic commerce bot protection is the set of controls that lets an AI agent browse, fill a cart, and buy on a person's behalf while scripts that only claim to be agents stay out of your checkout. Agentic commerce is an AI agent taking part in discovery, comparison, or purchase on a merchant's site for a person who asked it to. The protection problem is that the agent and the attacker both send automated requests, so the question "is this a bot?" no longer separates a customer from a fraud attempt.
Three questions replace it:
- Which bot is this? A named agent, such as ChatGPT agent or Meta's Muse, or an unnamed script.
- How sure are you? A
User-Agentclaim costs nothing to forge. A verified signature does. - Is it acting for one of your users? An agent that signed in through your OAuth server with scopes the person approved is a different client from one that didn't.
This guide walks a checkout flow step by step – browse, add to cart, sign in, pay – and shows which identity signals apply at each step and what policy fits. The examples use Arcjet, which answers all three questions in one bot identity that your route handler reads next to the cart, the session, and the order total.
Why does blocking all bots hurt revenue?
Blocking every bot turns away customers who send an AI agent to shop for them, and allowing every bot opens checkout to card testing and inventory hoarding. A person who asks an agent to reorder groceries is a paying customer even though software sends the request. A script that tests stolen card numbers against your payment form is not, even when its User-Agent names an AI product.
The agents are already shopping. Meta's help center describes Muse as an agent that fills in forms and completes purchases in a cloud browser. Meta's own post about the Personal Agent Protocol says businesses use it so Muse can "help customers shop, get answers, and manage bookings."
The cost of the opposite mistake is public too. When Amazon blocked Muse from its store in September 2026, the reason Amazon gave was that Muse didn't identify itself. A merchant can only make a per-agent decision when the agent identifies itself in a way the merchant can verify.
A blanket rule fails in both directions:
- Block all bots. Paying customers who use an agent can't buy, and your products drop out of the answers that agents give.
- Allow everything that claims to be an agent. Card testing, account takeover, and inventory hoarding arrive with an AI agent's
User-Agentheader.
The workable policy sits between the two and changes at each step of the flow. For more information about classifying agent traffic across your whole site, see AI agent bot management.
Which AI shopping agents identify themselves?
As of November 2026, AI agents identify themselves to a merchant in three ways: a Web Bot Auth signature, a Personal Agent Protocol session, or requests from published IP ranges. Agents that run in a person's own browser don't identify themselves at all. Each method proves something different, and Arcjet reports which one it verified as the identity's evidence.
| Method | What it proves | Arcjet evidence | Examples (as of November 2026) |
|---|---|---|---|
| Personal Agent Protocol (Poppy) session | Which agent sent the request, and that it acts for one of its users |
| Meta Muse |
| Web Bot Auth signature | Which operator's key signed the request | SIGNATURE | ChatGPT agent, Google's agent, Manus, Muse, Browserbase |
| Published IP ranges or reverse DNS | The request left the operator's network | IP | ChatGPT-User, Claude-User, Perplexity-User |
| Nothing: it's a claim | UNVERIFIED | Any client that sends an agent's name |
| None | The request looks like the person's own browser | No identity, or | Claude in Chrome, Perplexity Comet, Muse without a signature |
The Personal Agent Protocol (Poppy) is an open protocol that lets a person's AI agent act at a business on their behalf. The agent identifies itself with an HTTPS client_id, signs in through the business's OAuth server with scopes the person approves, and signs a short-lived Poppy-Session token for each request. Specification 1.0 was published on November 14, 2026. The companies listed as design partners on the protocol's path to 1.0 page include retailers such as Gap Inc., Nordstrom, Target, Walmart, and Wayfair, and payment companies such as Adyen, Mastercard, Stripe, and Visa (as of November 2026). Meta's post calls Muse "the first personal agent to support Poppy." For more information about how a session works, see what is the Personal Agent Protocol.
Web Bot Auth is a way for a bot operator to sign each request with a key that it publishes on its own domain. A signature identifies the operator of the key, which isn't always the agent. Hosted browser platforms, such as Browserbase, sign for many unrelated customers. For more information, see Web Bot Auth and what a hosted browser signature tells you.
How do you apply bot policy at each checkout step?
Apply a different policy at each step, because each step risks something different: browsing risks capacity, the cart risks inventory, sign-in risks accounts, and payment risks money. The following sections assign a tier to each request from its bot identity, then decide what each tier gets at each step.
The examples use four tiers:
- Delegated: a verified Poppy session (
delegatedistrue,evidenceisSIGNATURE). - Verified: a named AI agent with
SIGNATUREorIPevidence and no session. - Claimed: an AI agent identified only by its
User-Agentheader (UNVERIFIED). - No agent: no AI agent identity. This includes people, and agents that run in a person's browser.
| Step | Delegated | Verified | Claimed | No agent |
|---|---|---|---|---|
| Browse | Allow, per-agent rate limit | Allow, per-agent rate limit | Allow, tight per-IP rate limit | Allow, standard limits |
| Add to cart | Allow with an access token that has a cart scope | Allow on the person's own session | Deny, point to your API | Allow on a session |
| Sign in | Through your OAuth server, not the password form | The person signs in; deny automated password posts | Deny | Allow, with login rate limits |
| Pay | Allow within scope and spend limit; confirm above it | Require the person to confirm | Deny | Allow, with your fraud checks |
Check the agent's identity in JavaScript
Each step starts from the same check. The following helper reads the identity from a detectBot result with isAiAgent from @arcjet/inspect and returns a tier. isAiAgent is true for a LIVE result whose identity has kind AI_AGENT and isn't spoofed. It doesn't check the evidence, so the helper reads evidence and delegated itself:
import arcjet, { detectBot, slidingWindow, type ArcjetBotIdentity, type ArcjetDecision,} from "@arcjet/node";import { isAiAgent, isSpoofedBot } from "@arcjet/inspect";
type Tier = "delegated" | "verified" | "claimed" | "none";
// Return the AI agent that sent the request, if anyfunction aiAgent(decision: ArcjetDecision): ArcjetBotIdentity | undefined { for (const result of decision.results) { if (isAiAgent(result) && result.reason.isBot()) { return result.reason.identity; } } return undefined;}
function tierOf(agent: ArcjetBotIdentity | undefined): Tier { if (!agent) return "none"; if (agent.delegated) return "delegated"; if (agent.evidence === "SIGNATURE" || agent.evidence === "IP") { return "verified"; } return "claimed";}isAiAgent returns false for a spoofed identity, so each route in the following steps also denies a request when isSpoofedBot flags a result. Without that check, a script that fails IP verification would land in the none tier with people.
Step 1: Browse the catalog
Product pages are where an agent does the research that leads to a sale, so allow AI agents and search engines on read routes and block AI crawlers that collect your catalog for training. Then give each agent its own rate limit. Keying the limit on the bot ID gives one agent one budget across every person it serves. Keying the limit for a claimed agent on its IP address keeps a script that sends a popular agent's name from sharing that agent's budget.
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ detectBot({ mode: "LIVE", // Search engines and AI agents. AI crawlers and other bots are denied. allow: ["CATEGORY:SEARCH_ENGINE", "CATEGORY:AI_AGENT"], }), ],});
// One budget for each verified agent, shared across the people it servesconst verifiedAgentLimit = arcjet({ key: process.env.ARCJET_KEY!, characteristics: ["botId"], rules: [slidingWindow({ mode: "LIVE", interval: "1m", max: 600 })],});
// A small budget for each IP address that only claims to be an agentconst claimedAgentLimit = arcjet({ key: process.env.ARCJET_KEY!, characteristics: ["ip.src"], rules: [slidingWindow({ mode: "LIVE", interval: "1m", max: 30 })],});
app.get("/products/:id", async (req, res) => { const decision = await aj.protect(req); if (decision.isDenied() || decision.results.some(isSpoofedBot)) { return res.status(403).json({ error: "Forbidden" }); }
const agent = aiAgent(decision); const tier = tierOf(agent);
if (agent) { const limit = tier === "claimed" ? await claimedAgentLimit.protect(req) : await verifiedAgentLimit.protect(req, { botId: agent.botId }); if (limit.isDenied()) { return res.status(429).json({ error: "Too many requests" }); } }
res.json(await getProduct(req.params.id));});app, getProduct, and the other functions without an import in these examples stand in for your own application code.
An allow list of CATEGORY:AI_AGENT doesn't admit every hosted browser. Arcjet lists Browserbase as an AI agent, but Kernel's and Cloudflare Browser Run's browser signers are in CATEGORY:TOOL, so this rule denies them unless you add them. Check the categories of the signers that you care about in the Arcjet bot list.
Step 2: Add to cart
A cart reserves inventory and holds state for one person, so an agent needs to be acting for someone before it can write to one. A delegated agent proves that with an OAuth access token from your authorization server. A verified agent without delegation uses the cookie session of the person who signed in, the same as the person's browser would. A claimed agent has neither, so send it to your API:
app.post("/cart", async (req, res) => { const decision = await aj.protect(req); if (decision.isDenied() || decision.results.some(isSpoofedBot)) { return res.status(403).json({ error: "Forbidden" }); }
const tier = tierOf(aiAgent(decision));
if (tier === "claimed") { return res.status(403).json({ error: "Automated carts use the API.", api: "https://api.example.com/docs", }); }
// Delegated agents present an access token from your OAuth server. // Everyone else uses a signed-in or guest session. const actor = tier === "delegated" ? await verifyAccessToken(req, { scope: "cart:write" }) : await getSession(req);
if (!actor) { return res.status(401).json({ error: "Sign in to use a cart." }); }
res.json(await addToCart(actor, req.body));});Arcjet checks the Poppy session against the request: the signature, the method and URL it's bound to, and its freshness. It doesn't check the access token or its scopes. That stays with your authorization server, which is why the delegated branch calls verifyAccessToken.
Step 3: Sign in
Agents that follow the Personal Agent Protocol don't use your password form. They sign in through the OAuth endpoints that your /.well-known/poppy.json file names, with scopes the person approves. That makes the password form the one route where no automated client has a reason to post, so deny every detected bot there:
const loginGuard = arcjet({ key: process.env.ARCJET_KEY!, rules: [ // An empty allow list denies every detected bot, agents included detectBot({ mode: "LIVE", allow: [] }), // Limit attempts per account, so a proxy pool still shares one budget slidingWindow({ mode: "LIVE", characteristics: ["email"], interval: "10m", max: 5, }), ],});
app.post("/login", async (req, res) => { const decision = await loginGuard.protect(req, { email: req.body.email }); if (decision.isDenied() && decision.reason.isBot()) { return res.status(403).json({ error: "Agents sign in through OAuth.", authorization: "https://example.com/.well-known/poppy.json", }); } if (decision.isDenied()) { return res.status(429).json({ error: "Too many attempts" }); }
// Check the password with your own authentication code});If a cloud browser agent lets the person take over its browser to sign in, the person types the password, but the request can still carry the agent's signature. To support that flow, allow the agent's bot ID on the login route and keep the per-account limit.
Step 4: Pay
Payment is the step to protect most, because money that has moved is the hardest thing to undo. A delegated agent can pay within the scopes and spend limit that the person granted it. Above that limit, or for an agent without delegation, the person confirms the order in a channel that the agent doesn't control, such as your app or an email link. Claimed agents don't reach the payment step:
app.post("/checkout", async (req, res) => { const decision = await aj.protect(req); if (decision.isDenied() || decision.results.some(isSpoofedBot)) { return res.status(403).json({ error: "Forbidden" }); }
const tier = tierOf(aiAgent(decision));
if (tier === "claimed") { return res.status(403).json({ error: "Forbidden" }); }
if (tier === "delegated") { const token = await verifyAccessToken(req, { scope: "orders:create" }); if (!token) { return res.status(401).json({ error: "Missing orders:create scope" }); }
const order = await priceCart(token.userId); if (order.total > token.spendLimit) { // Hold the order until the person approves it in your app const pending = await holdForConfirmation(token.userId, order); return res.status(202).json({ status: "pending", id: pending.id }); } return res.json(await placeOrder(token.userId, order)); }
const session = await getSession(req); if (!session) { return res.status(401).json({ error: "Sign in to check out." }); }
const order = await priceCart(session.userId);
if (tier === "verified") { // A signed agent with no delegation: the person confirms the order const pending = await holdForConfirmation(session.userId, order); return res.status(202).json({ status: "pending", id: pending.id }); }
res.json(await placeOrder(session.userId, order));});The bot identity, the token's scopes, and the order total meet in one handler. That's the reason to make this decision in application code: an edge rule sees the request, but not the cart or the person's limit. For more information about holding an action for a person, see human approval gates for agent actions.
Check the agent's identity in Python
The Python SDK reads the same identity from reason_v2, and is_ai_agent applies the same rules as isAiAgent. The following FastAPI checkout route holds orders from agents without delegation:
import os
from arcjet import ( BotCategory, Decision, Mode, arcjet, detect_bot, is_ai_agent, is_spoofed_bot,)from fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponse
aj = arcjet( key=os.environ["ARCJET_KEY"], rules=[ detect_bot( mode=Mode.LIVE, allow=[BotCategory.SEARCH_ENGINE, BotCategory.AI_AGENT], ), ],)
app = FastAPI()
def agent_tier(decision: Decision) -> str: """Return delegated, verified, claimed, or none.""" for result in decision.results: reason = result.reason_v2 if is_ai_agent(result) and reason.type == "BOT" and reason.identity: identity = reason.identity if identity.delegated: return "delegated" if identity.evidence in ("SIGNATURE", "IP"): return "verified" return "claimed" return "none"
@app.post("/checkout")async def checkout(request: Request): decision = await aj.protect(request) spoofed = any(is_spoofed_bot(r) for r in decision.results) if decision.is_denied() or spoofed: return JSONResponse({"error": "Forbidden"}, status_code=403)
tier = agent_tier(decision) if tier == "claimed": return JSONResponse({"error": "Forbidden"}, status_code=403) if tier == "verified": # Hold the order until the person confirms it return JSONResponse({"status": "pending"}, status_code=202)
# Delegated agents: check the access token and spend limit here return {"status": "placed"}Check the agent's identity in Go
In Go, decision.IsAIAgent() applies the same rules, and the identity is on result.Reason.Bot.Identity:
// agentTier returns delegated, verified, claimed, or none.func agentTier(decision arcjet.Decision) string { if !decision.IsAIAgent() { return "none" } for _, result := range decision.Results { bot := result.Reason.Bot if bot == nil || bot.Identity == nil { continue } id := bot.Identity if id.Kind != arcjet.BotKindAIAgent || id.Spoofed { continue } switch { case id.Delegated: return "delegated" case id.Evidence == arcjet.BotEvidenceSignature, id.Evidence == arcjet.BotEvidenceIP: return "verified" default: return "claimed" } } return "none"}agentTier returns none for a spoofed claim, so deny when decision.IsDenied() or decision.IsSpoofedBot() is true before you read the tier. For the full configuration in each SDK, see customize the response for AI agents in the Arcjet docs.
What can a delegated agent do at checkout?
A delegated agent can do what the person granted it through your OAuth server, and nothing more. A verified Poppy session proves which agent sent the request and that it acts for one of its users. It doesn't prove that the person approved this specific purchase, so scopes and spend limits decide what the agent may do.
A verified session sets the following identity fields:
kindisAI_AGENTandbotIdnames the agent, such asMETA_MUSE.evidenceisSIGNATUREandoperatoris the agent's domain.delegatedistrue.
Poppy doesn't tell you who the person is. The user's sub is a pseudonymous ID that's different at each business, and Arcjet doesn't log or store it. Your authorization server links the access token to an account when the person approves the sign-in.
Arcjet verifies sessions only for agents vetted in the open well-known-bots catalog. It doesn't fetch a client_id that a request supplies, so a request can't make Arcjet fetch an arbitrary URL. A session that fails verification, or comes from an agent outside the catalog, doesn't change the identity.
The following scopes give a delegated agent room to help without handing it the account:
- Read scopes for order history, saved addresses, and loyalty balance.
- A cart scope for adding and removing items.
- An order scope with a spend limit that the person sets, so purchases above it wait for confirmation.
- No scope for changing the password, email address, or payment methods. Keep those for the person.
For more information about verifying sessions, see agents that act for a user in the Arcjet docs.
Where does fraud prevention fit with verified agents?
Fraud prevention stays in your code and with your payment provider, because a verified agent identity says who sent the request, not whether the payment is legitimate. A delegated agent can act for a person whose card is stolen, and a signed cloud browser can carry a fraudster's session. Bot identity removes the anonymous automation from the payment step, and your fraud checks handle the rest.
Keep the following controls on every order, whatever the tier:
- Velocity limits per account and per card. Card testing sends many small payments. A rate limit keyed on the account or a hash of the card fingerprint stops it, even across a proxy pool.
- Your payment provider's risk checks. Address verification, card security codes, and the provider's own risk scoring see signals that bot detection doesn't.
- Spend limits on delegated tokens. The person sets the ceiling. Your code enforces it.
- Confirmation for actions you can't undo. A large order, a change of shipping address, or a gift card purchase waits for the person. For more information, see prevent irreversible AI agent actions.
A CAPTCHA in front of payment doesn't replace these controls: it challenges the agents that customers send and costs a card tester a solver fee. For more information, see CAPTCHAs vs Arcjet.
Verified identity does make fraud checks more precise. A spike in failed payments from one botId is a signal about one agent, not about all automated traffic. When the identity is UNVERIFIED, treat the name as a claim and key the limit on the IP address or account instead.
What do you do about agents that don't identify themselves?
Treat an agent that doesn't identify itself as the person whose browser or session it uses, and rely on the controls that apply to people: rate limits, sign-in, and fraud checks. Agents that run in a person's own browser, such as Claude in Chrome and Perplexity Comet, send that person's cookies, IP address, and fingerprint, so no server-side check can separate them from the person.
Agents in a cloud browser that don't sign their requests look like Chrome. Muse requests that carry no signature or session look like Chrome on Linux. For those requests, advanced signals can detect browser automation and report an identity with kind AUTOMATION and FINGERPRINT evidence. That tells you a program drives the browser, not which agent it is or whom it serves.
For an agent you can't name, the following steps keep the checkout safe:
- Rate limit actions that people don't repeat at machine speed, such as adding items to many carts or trying several cards.
- Require sign-in before the cart holds inventory, so the person is accountable for what the agent does.
- Publish
/.well-known/poppy.jsonand support Web Bot Auth, so agents that can identify themselves have a reason to.
For more information about the identification methods, see how to identify AI agents and bots and how to detect Meta's Muse AI agent.
Frequently asked questions
Should I let AI agents complete purchases?
Let a delegated agent complete purchases within the OAuth scopes and spend limit that the person granted, and hold larger orders for the person to confirm. For a verified agent without delegation, require the person to confirm the order. Deny checkout to agents identified only by a User-Agent claim.
How do I stop card testing from fake AI agents?
Treat an UNVERIFIED agent identity as a claim and deny it at payment. Keep velocity limits per account and per card on every order, whatever the tier, and keep your payment provider's risk checks. A spoofed claim, where IP verification failed, is denied before the tier is read.
Does the Personal Agent Protocol handle payment authorization?
No. A verified Poppy session proves which agent sent the request and that it acts for one of its users. It doesn't prove that the person approved a specific purchase. Your authorization server checks the access token and its scopes, your code enforces spend limits, and your payment provider authorizes the payment.
What do I do about agents that don't identify themselves?
Treat them as the person whose browser or session they use. Agents in a person's own browser, such as Claude in Chrome and Perplexity Comet, can't be separated from that person on the server. Rate limit actions that people don't repeat at machine speed, require sign-in before the cart holds inventory, and use advanced signals to detect browser automation.
Does a Browserbase signature mean a customer sent the agent?
No. A Browserbase signature proves that a Browserbase session sent the request. Browserbase signs for many unrelated customers, so the signature doesn't identify the customer, the person, or their intent. Rate limit the platform as one client and require a signed-in session before it writes.
Can I give AI agents a separate rate limit from people?
Yes. Read the agent's bot ID from the Arcjet bot identity and pass it as the botId characteristic of a rate limit rule, so each verified agent has one budget across every person it serves. Key the limit for an agent that's only claimed on the IP address instead.
Application security in your code
Protect your application with Arcjet
Arcjet reports which agent sent each request, how strongly it was proven, and whether it acts for one of your users, so your checkout handler can decide with the cart and the order total in hand.