Agentic commerce: how to let AI agents buy without opening checkout to bots

Let AI shopping agents browse, fill carts, and pay while scripts that claim to be agents stay out of checkout.

16 min read
In short: Agentic commerce bot protection lets an AI agent browse, fill a cart, and buy for a person while scripts that only claim to be agents stay out of checkout. Assign each request a tier from its bot identity: delegated (a verified Personal Agent Protocol session), verified (SIGNATURE or IP evidence), claimed (UNVERIFIED), or no agent. Give each tier a policy per checkout step, and keep OAuth scopes, spend limits, fraud checks, and human confirmation in your own code.

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-Agent claim 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-Agent header.

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.

MethodWhat it provesArcjet evidenceExamples (as of November 2026)
Personal Agent Protocol (Poppy) session

Which agent sent the request, and that it acts for one of its users

SIGNATURE, with delegated set

Meta Muse
Web Bot Auth signatureWhich operator's key signed the requestSIGNATUREChatGPT agent, Google's agent, Manus, Muse, Browserbase
Published IP ranges or reverse DNSThe request left the operator's networkIPChatGPT-User, Claude-User, Perplexity-User

User-Agent header only

Nothing: it's a claimUNVERIFIEDAny client that sends an agent's name
NoneThe request looks like the person's own browser

No identity, or FINGERPRINT if advanced signals detect automation

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 (delegated is true, evidence is SIGNATURE).
  • Verified: a named AI agent with SIGNATURE or IP evidence and no session.
  • Claimed: an AI agent identified only by its User-Agent header (UNVERIFIED).
  • No agent: no AI agent identity. This includes people, and agents that run in a person's browser.
StepDelegatedVerifiedClaimedNo agent
BrowseAllow, per-agent rate limitAllow, per-agent rate limitAllow, tight per-IP rate limitAllow, standard limits
Add to cartAllow with an access token that has a cart scopeAllow on the person's own sessionDeny, point to your APIAllow on a session
Sign inThrough your OAuth server, not the password formThe person signs in; deny automated password postsDenyAllow, with login rate limits
PayAllow within scope and spend limit; confirm above itRequire the person to confirmDenyAllow, 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 any
function 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 serves
const 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 agent
const 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, Request
from 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:

  • kind is AI_AGENT and botId names the agent, such as META_MUSE.
  • evidence is SIGNATURE and operator is the agent's domain.
  • delegated is true.

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.json and 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.