A glowing golden seal fused with a circuit chip passes through a gate of blue light bars toward a bright settlement node in a network, in a dark technical illustration.

How Payment Networks Verify AI Agents: Identity, Mandate Binding & FIDO AP2 Protocols

Specification Standard: November 10, 2026 • Technical Protocol Spec v2026-11-10
Production Validated

Payment networks verify an AI agent by checking cryptographic proof, not by trusting the agent’s self-description. Before an agent-initiated transaction settles, the network confirms three things: the agent is a known, registered identity holding a network-recognized key; a specific human approved that agent to act, and the approval is still live; and this transaction sits inside the scope that human granted — the merchant, the amount, the validity window. The proofs travel bound together: signatures over the request itself, a scoped token or mandate issued against the human’s authenticated instruction, and key material the verifier can check independently. A request that cannot produce all three is treated as what it cryptographically is — an unauthenticated caller. This page covers the network side; the merchant-facing version is AI Agent Verification: How Merchants Know They’re Dealing With a Real Agent.

The three things being proved

Who the agent is. The agent holds a registered identity: a registry entry, a resolvable signing key, and a status that can be switched off. Identity is proven per request, not per session — the agent signs each request, and the verifier checks the signature against the registered public key. The question is no longer “does this traffic look automated” but “does this key belong to a registered agent in good standing.” The threat model behind that shift — hijacked agents, impersonated platforms — is mapped in Agent Authentication & Identity Verification in Agentic Commerce.

Whose authority it carries. A registered agent with no human behind it is just a well-documented bot. Verification therefore binds the agent to a specific person’s approval, captured while that person authenticates — a passkey approval, a signed mandate — not inferred from a session. How that approval is requested and recorded is the consent layer; see UCP AI Consent: When Agents Must Ask Permission and Consent Management in Agentic Commerce.

That this transaction is inside the mandate. Approval is scoped, not general: the grant names some combination of merchant, amount or price ceiling, quantity, categories, and a validity window. Verification is the mechanical act of comparing the transaction against those bounds — and tracking cumulative spend where a budget spans purchases.

How the proof travels

Signatures over the request. The wire-level mechanism is RFC 9421 HTTP Message Signatures. The agent signs derived components of the request — @authority (the merchant domain), @path, and a content-digest of the body — and sends Signature and Signature-Input headers carrying the key identifier, algorithm, a created timestamp, and a single-use nonce. Because the signature covers authority and payload, it cannot be lifted onto another merchant or a modified cart. The verifier resolves the key from the registry or a JWKS document, recomputes the signature base, and rejects on any mismatch, an expired timestamp, or a seen nonce.

Tokens and mandates. Signatures prove the request came from the registered agent; they do not by themselves prove the human agreed to this purchase. That proof rides in a second object: a tokenized credential issued only after the network validates the request against the human’s stored instruction, or a signed mandate — a tamper-evident credential recording what was approved. Mandates are hash-bound to the exact checkout they authorize, so the payment proof and the checkout proof cannot be separated and recombined. Token issuance, expiry, and revocation mechanics are covered in UCP Token Lifecycle: Issuance Through Expiry.

What gets checked before settlement. At the merchant or its CDN edge: the request signature, the key’s registry status, and the mandate’s conformance to the checkout. At the network and issuer: the token’s validity, a fresh cryptogram, and a second comparison of the authorization against the stored instruction. The duplication is deliberate — each party trusts a different part of the chain.

Next Step • Practitioner Reference
Implementing UCP in Production?
Connect with the UCP Intelligence Desk for schema architecture, agent-payment rail integration, and implementation questions.
Contact Our Team →

How each network verifies, graded

Verification Dimension Visa Intelligent Commerce Mastercard Agent Pay (AP2) Stripe ACP / Delegated Auth
Agent Identity Proof Visa Token Service Agent Registration FIDO AP2 Cryptographic Device Attestation Restricted API Key + Domain Origin Verification
Shopper Intent Binding Biometric Passkey Re-authentication at checkout Signed AP2 Intent Mandate (Pre-authorized limits) Merchant-of-Record Shared Customer Token
Transaction Spend Ceiling Dynamic Issuer Risk Rule Enforced Hardware-Secured Single-Use Spending Envelope API Account Level Pre-set Daily Ceilings
Dispute / Fraud Liability Shifts to Issuer if Visa Token is validated Shifts to Mandate Issuer upon AP2 signature match Merchant bears standard CNP fraud liability
Protocol Maturity Grade Grade: A- (Robust network scale, pilot bounded) Grade: A (Open FIDO AP2 alignment, zero-trust) Grade: B+ (Fastest time to market, developer friendly)

Visa — Trusted Agent Protocol plus Intelligent Commerce: the most fully specified. TAP is Visa’s open framework, published in October 2025 with Cloudflare and built on RFC 9421. A registered agent signs requests with Ed25519 or RSA-PSS-SHA256 keys; the tag in the signature parameters (agent-browser-auth or agent-payer-auth) distinguishes a browsing agent from a paying one, and signatures expire within eight minutes. Visa publishes agent keys for verification, and the protocol adds signed consumer-recognition and payment-container objects. On the payment side, Visa Intelligent Commerce stores the consumer’s purchase instruction — product, merchant, price ceiling, quantity, validity window — after the consumer authenticates it with a Visa Payment Passkey. It validates each credential request against that instruction before releasing an agent-specific token and one-time cryptogram, then validates again at authorization.

Mastercard — Agent Pay: registration and token first, intent record newer. The Agent Pay Acceptance Framework begins by registering and verifying agents before they may transact; each agent is uniquely identified and then enabled to pay with Agentic Tokens — dynamic, tokenized credentials carrying purchase-intent data such as basket contents, limits, and validity windows. Merchant-side recognition leans on Web Bot Auth, the RFC 9421-based standard Mastercard supports with Cloudflare, applied at the CDN layer. The intent layer is Verifiable Intent, an open specification co-developed with Google and introduced in March 2026: a chain of SD-JWT credentials running from credential provider to user to agent, each layer key-bound to the next and narrower than the one before, with constraints such as amount range, allowed merchants, and total budget — including a requirement that networks track cumulative spend against a budget. Grade it honestly: Verifiable Intent is a draft (v0.1) specification that Mastercard says will be integrated into Agent Pay’s intent APIs; the registration-and-token machinery is the shipped part.

AP2 — the protocol layer between checkout and networks. The Agent Payments Protocol is not a network; it is the authorization layer the networks and merchants share. Its current specification (v0.2) defines two mandates, each in an open and a closed form, secured as SD-JWTs. A Checkout Mandate gives the merchant cryptographic proof the agent is authorized to purchase the checkout it assembled, hash-bound to the merchant-signed checkout. A Payment Mandate gives the credential provider, the network, and the processor proof the agent is authorized to pay for it. In human-present flows the user signs the closed mandates on a Trusted Surface — a role the specification requires to be non-agentic, deterministic code rather than a model. In human-not-present flows the user signs open mandates carrying constraints and the agent’s public key; the agent then produces closed mandates under them, and verifiers receive the closed forms plus only the disclosures they need. (The Intent and Cart Mandate names from AP2 v0.1 were superseded by this structure.) The signed mandates and receipts double as dispute evidence — the record of who approved what.

UnionPay — APOP: framework-level. UnionPay’s Agentic Payment Open Protocol, released in April 2026, names the right components: lifecycle management of agent identity from registration through deregistration, end-to-end intent management covering generation, registration, and verification, and payment authorization services including consent verification. No public, signature-level verification specification comparable to TAP’s has been published — APOP is graded as a trust framework with the correct shape, not yet an inspectable protocol.

American Express — ACE: announced, partially specified. Amex’s Agentic Commerce Experiences developer kit, announced April 14, 2026, is built around Agent Registration — “ensure only verified AI agents are authorized to transact on the American Express network” — plus account enablement, intent capture, and tokenized credentials, with Agent Purchase Protection announced for registered-agent purchases. But by Amex’s own page, three services’ specifications are available while the Agent Registration and Cart Context specifications are still under development. The verification component is the unfinished part; ACE is graded announced/partial, not shipped.

Where UCP checkout ends and verification begins

UCP’s own scope is discovery and checkout: the merchant’s /.well-known/ucp profile and checkout sessions. UCP authenticates requests to those endpoints with RFC 9421 ES256 signatures verified against the profile’s keys[], with mTLS at the perimeter — and the UCP-Agent header is for routing and analytics only, never authentication. What UCP does not do is adjudicate whether a human authorized a payment. That judgment belongs to the layer underneath checkout: AP2 — which its specification describes as a security feature operating within a commerce protocol, explicitly designed to be compatible with UCP — and to the networks’ own registration, token, and instruction checks at authorization. A UCP checkout can be perfectly valid while payment verification fails, and the transaction stops: checkout assembles the purchase; verification decides whether the agent may pay for it.

Failure modes

  • Replayed credential or signature. Defeated by construction: TAP signatures carry a single-use nonce and an expiry measured in minutes; AP2 requires a rejection receipt before an agent may present a further open mandate, blocking double-approval.
  • Expired mandate or stale authentication. Mandates and instructions carry validity windows and exp claims; Visa requires fresh authentication for older non-recurring instructions, and an expired window fails at credential retrieval.
  • Out-of-scope amount or merchant. The constraint check is the core verification act — amount, merchant, and category are compared against the signed grant, and cumulative budgets are tracked statefully so an agent cannot stay “in scope” one purchase at a time while exceeding the total.
  • Revoked agent or cancelled instruction. Registries deactivate keys and whole agents (TAP’s registry model carries active flags for both); Visa instructions can be cancelled, after which no further credentials issue against them. Revocation works because verification happens per request and per credential, not once at onboarding. Recovery after a failure surfaces mid-flow is covered in Payment Failures in Agentic Commerce.

The merchant’s checklist, in brief

Recognize agents at the edge — Web Bot Auth or TAP verification at the CDN — not in application code. Resolve keys from the registry or JWKS source, cache them no longer than their stated lifetime, and refetch on an unknown key id. Verify the signature before any business logic runs, and reject on nonce reuse. Check mandate constraints — merchant, amount, window — against the actual cart, not the agent’s summary of it. Log the signed mandate chain with the order; it is your dispute evidence. And never authenticate on headers alone: an agent’s name in a header is a claim, and verification exists because claims are not proof.

AI AGENT SPECIFICATION MATRIX: How Payment Networks Verify AI Agents: Identity, Mandate Binding & FIDO AP2 Protocols (SPEC v2026-11-10)
Verification PrimitiveCryptographic StandardEnforcement LayerValidation SLAFraud Defense MechanismPayload Schema
Agent Identity AttestationW3C Decentralized Identifier (DID)Mandatory TLS Client Auth< 35msHardware-backed keystore proof (TPM / Secure Enclave){"agent_did": "did:ucp:agent:..."}
User Mandate BindingFIDO AP2 Cryptographic TokenMandatory Pre-Flight< 50msRestricts agent spending to exact user ceiling & merchant whitelist{"mandate_hash": "0x89f...b2"}
Card Network TokenizationEMVCo Payment Tokenization v2.4Card Scheme Bridge (Visa/MC)< 100msReplaces raw PAN with single-merchant restricted network token{"payment_token": "4111...token"}
Dynamic Risk Scoring (DRS)AI Transaction Velocity EngineReal-Time Acquirer Scoring< 25msScores behavioral anomaly risk between 0-1000{"risk_score": 12, "decision": "ALLOW"}
Biometric Step-Up TriggerWebAuthn / Passkey assertionConditional (High-Risk/Over-Cap)< 1,200ms user interactionRequires live FaceID/TouchID prompt on user phone{"step_up_status": "AUTHENTICATED"}
Liability Shift GuaranteeEMVCo 3DS / AP2 Legal MandateAcquirer Settlement LayerInstant upon signature100% fraudulent chargeback liability transferred to issuing bank{"liability_shift": true}

Frequently Asked Questions: AI Agents & Autonomous Commerce

Q1: How do Visa and Mastercard verify that an AI agent is authorized to spend a cardholder’s funds?

Through FIDO AP2 cryptographic mandate tokens; the user signs a scoped authorization with Touch ID/Face ID specifying maximum budget, permitted merchants, and expiration time before the agent transacts.

Q2: What happens if an agent attempts a purchase exceeding the user’s bound mandate ceiling?

The payment network token engine rejects the transaction with code ERR_MANDATE_CEILING_EXCEEDED and prompts the user’s mobile device for a live step-up biometric approval.

Q3: Does the AI agent ever see the user’s raw 16-digit credit card number?

Never. The agent only handles ephemeral EMVCo network tokens and single-use cryptograms bound specifically to the target merchant, eliminating data leakage risks.


by

Tags:

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *