/.well-known/ucp discovery manifest, FIDO AP2 intent mandates, cryptographic request signatures, delegated spending ceilings, and out-of-band payment tokenization. For network-level verification mechanisms, review our comprehensive breakdown on How Payment Networks Verify AI Agents.
AI agent verification is the process by which merchants confirm that an AI agent requesting a transaction is legitimate, authorized, and operating within defined permissions — as opposed to a bot, scraper, or malicious actor.
This is the gatekeeping problem of agentic commerce. Merchants have spent decades fighting bot traffic. Now they need to let some automated agents through while blocking others. The difference between a legitimate AI shopping agent and a credential-stuffing bot is the difference between revenue and fraud.
How Verification Works Today
November 2026 update: Google’s settled authentication is RFC 9421 ES256 request signatures verified against `keys[]` (`Signature` / `Signature-Input`; `UCP-Agent`/`User-Agent` routing/analytics only; `Cache-Control: max-age=86400`, refetch on unknown `kid`), with mTLS at the perimeter. Header/DNS identification alone is not authentication.
UCP’s Discovery Endpoint
Google’s UCP includes a /.well-known/ucp discovery endpoint. The agent fetches the merchant’s /.well-known/ucp profile to learn which `ucp.services` and `ucp.payment_handlers` the merchant supports (each capability names name/version/date-string and schema URL).
The Five Things Merchants Verify

Note: general practice/analysis — not UCP-settled protocol.
- Agent identity. Is this agent from a recognized platform (ChatGPT, Google AI Mode, etc.)?
- User authorization. Does the agent have proof proving a real user authorized this action?
- Scope compliance. Is the requested transaction within the authorization’s spending limits, category restrictions, and time window?
- Credential freshness. Has the authorization credential expired? Has it been revoked?
- Transaction integrity. Do the transaction details match what the credential authorizes?
What Happens When Verification Fails
If any check fails, the transaction is rejected and the agent receives a structured error response explaining which verification step failed.
Related Reading
- What Is Agentic Commerce?
- Verifiable Intent: The Privacy Architecture
- Visa vs Mastercard Compliance Race
- How AI Shopping Agents Work
How Merchants Verify an AI Agent’s Identity at Checkout
Note: general engineering analysis — not UCP-settled protocol. Merchants verify an AI shopping agent at checkout by confirming three things before the transaction is authorized: who the agent is (a registered, cryptographically identifiable agent), who authorized it (a specific human principal who granted consent), and what it is allowed to do (a scoped mandate covering the merchant, the amount, and the spending limit). In practice this means validating a signed payment mandate or scoped token, checking that its signature comes from a trusted issuer or payment network, and ensuring the cart, price, and merchant all fall inside the boundaries the user approved. Checkout completes only when every condition holds.
Under the emerging 2026 standards stack, agent identity and authority are no longer inferred from a session cookie or a shared password. They are carried in tamper-evident, machine-readable credentials: a UCP discovery handshake plus a signed request, an OAuth 2.0 access token scoped to the agent, and a chain of cryptographically signed mandates. The merchant’s job is to verify that chain end to end rather than to trust the agent’s word.
Step-by-Step Verification Flow

- Discovery and capability handshake. The agent fetches the merchant’s
/.well-known/ucpprofile to learn which `ucp.services` and `ucp.payment_handlers` the merchant supports (each capability names name/version/date-string and schema URL). - Identify the agent. The agent presents a distinct, verifiable identifier. Under UCP the
UCP-Agentheader (andUser-Agent) is for routing and analytics only — never authenticate on headers alone. Authentication is cryptographic request signatures (RFC 9421): verify the ES256 signature in theSignature/Signature-Inputheaders against the public signing keys in the profile’skeys[](for Google surfaces:https://ucp.goog/.well-known/ucp.json, cache no longer thanCache-Control: max-age=86400, refetch on unknownkid), with mTLS at the perimeter; verifiers MUST ensure the authenticated identity is consistent with theUCP-Agentheader. - Authenticate and authorize the call. The merchant validates the OAuth 2.0 access token or verifies the request signature against the agent’s published key.
- Verify user consent and intent. The merchant inspects the mandate or delegated-payment credential to confirm a specific human authorized this purchase.
- Check scope and limits. The merchant confirms the transaction falls inside the approved constraints: correct merchant, amount at or below the spending cap, allowed product category, and a valid (unexpired) authorization window.
- Validate the payment credential. The merchant or its payment service provider (PSP) verifies the payment token, confirming it is bound to this agent, this merchant scope, and this consent policy before settling.
- Authorize, settle, and log. On success, the merchant processes payment as it would any order and retains the signed mandate chain as a non-repudiable audit trail for dispute, chargeback, and accountability purposes.
Verification Methods Compared
| Verification Vector | Merchant Inspection Target | Underlying Verification Standard | Failure Error Code | Latency Budget | Security Objective |
|---|---|---|---|---|---|
| Agent Identity & Origin | Header: UCP-Agent: Google-Agent/2.1. |
RFC 9421 cryptographic signature verified against public registry. | 401 Unauthorized. |
<10ms execution. | Separates authorized buyer bots from malicious web scrapers. |
| Human Consent Attestation | Header: X-User-Delegation-Token. |
Hardware-attested FIDO AP2 biometric assertion. | 403 Forbidden (Consent Missing). |
<20ms execution. | Guarantees that a verified human authorized the purchase intent. |
| Real-Time Price Floor Rule | Payload: Negotiated line-item unit prices. | WebAssembly edge rule evaluated against store database. | 409 Conflict (Below Floor). |
<5ms execution. | Automatically enforces minimum profit margins during negotiations. |
| Velocity & Spend Rate Limit | Token metadata: Cumulative daily transaction volume. | Distributed Redis sliding-window token bucket. | 429 Too Many Requests. |
<2ms execution. | Prevents inventory exhaustion from runaway algorithmic bots. |
| Settlement Credential Proof | Payload: Ephemeral single-use virtual payment card. | Real-time payment gateway zero-dollar pre-authorization. | 402 Payment Required. |
<200ms execution. | Ensures guaranteed payment clearing prior to inventory allocation. |
Merchant Verification Checklist
Note: general practice checklist — not UCP-settled protocol.
- Publish a complete, current
/.well-known/ucpmanifest so compliant agents can discover capabilities and the correct payment handlers. - Require every agent to present a cryptographically verifiable identity (RFC 9421 signature verifiable against its published
keys[]or OAuth client identity;UCP-Agentalone is routing/analytics only) — do not accept unauthenticated callers for write/checkout actions. - Validate request signatures against the agent’s published key, and reject unsigned or tamper-altered requests.
- Verify OAuth tokens are short-lived and scoped to your endpoint; reject replayed or over-broad tokens.
- Confirm a signed user mandate (or delegated-payment credential) authorizes this specific purchase, and that its issuer is trusted.
- Enforce scope on every transaction: correct merchant, amount within the spending cap, allowed category, and an unexpired authorization window.
- Validate the payment token is bound to this agent and merchant scope before settling.
- Apply an accept / decline / step-up policy per agent or per transaction for high-risk, high-value, or out-of-pattern orders.
- Use idempotency keys to prevent duplicate agent-driven charges.
- Retain the signed mandate chain as a non-repudiable audit trail for disputes, chargebacks, and accountability.
Trust Signals: Verifiable Intent, Consent, and Spending Limits
Verifiable intent is the anchor. Rather than trusting that an agent “meant” to buy something, the merchant relies on cryptographically signed proof of what the user instructed. AP2 Intent and Cart Mandates, and Mastercard’s Verifiable Intent (Mastercard’s framework, co-developed with Google), produce a tamper-evident log binding the user’s authorization to the agent’s action — which directly addresses the risk of agent error or hallucination.
User consent and mandates establish authority. A mandate is the on-the-record permission slip: it names the human principal, the agent, and the boundaries of what was approved.
Spending limits and scope contain the blast radius. Tokens and mandates are deliberately narrow: a credential carries a maximum amount, a merchant or category scope, and an expiry. A grocery-shopping token cannot pay for travel, and a $200-limit token cannot clear a $500 charge. Merchants should treat these constraints as hard gates — verify them on every call, and step up to additional confirmation when a request sits at the edge of, or outside, the approved envelope.
Merchants validate the RFC 9421 ES256 request signature (`Signature` / `Signature-Input` against the agent’s published `keys[]`) or scoped OAuth access token (`UCP-Agent` is routing/analytics only), and then confirm a signed mandate or delegated-payment credential proves a specific user authorized the purchase. They also check the amount, merchant, and category fall within the approved scope before settling and logging the signed mandate chain.
Related reading
- UCP Pricing Model: Fees, Costs & Merchant Value (2026)
- UCP Dispute Resolution: Who Arbitrates AI Agent Transactions?
- Is Agentic Commerce the Same as Agentic AI? Here’s the Difference
- Returns and Refunds in Agentic Commerce: Agent State Management and Exception Handling
- Agent Commerce Returns: How AI Systems Handle Refunds, Exchanges, and Customer Dissatisfaction
Updated November 8, 2026: Updated November 2026 to correct request authentication to RFC 9421 ES256 signatures (UCP-Agent routing-only), fix Mastercard Verifiable Intent attribution, and strip unverified mandate-as-VC and count claims, preserving the original April 2026 publish date. First published 2026-04-01.
Frequently Asked Questions
How does a merchant verify an AI agent has permission to spend a customer’s money?
The merchant’s backend validates the cryptographic signature on the X-User-Delegation-Token against the issuing identity provider’s public key, confirming the token contains an active spend allowance and valid timestamp.
What is the difference between scraping bots and verified AI commerce agents?
Scraping bots make unauthenticated HTTP requests to harvest HTML text, whereas verified commerce agents present cryptographic RFC 9421 signatures and query machine-readable endpoints with verified purchasing intent.
How can Shopify and WooCommerce stores deploy agent verification without custom coding?
Merchants can install verified UCP gateway plugins or deploy Cloudflare Workers on their domain that validate incoming agent signatures at the edge before proxying requests to the store.

Leave a Reply