Quick Answer: A payments team proves a bot is really acting for you by checking three things at once, not one: a verifiable identity credential that says which AI agent this is and who built it, a cryptographically signed mandate chain that says a specific human authorized this specific purchase at this specific price, and a network-level attestation flag that lets the card network and issuer see the first two signals before they approve or decline. As of late 2026, four overlapping systems supply those checks — Google’s Agent Payments Protocol (AP2), the Agentic Commerce Protocol (ACP) built by OpenAI, Stripe, and Meta, Visa’s Trusted Agent Protocol, and Mastercard Agent Pay — and none of them fully replaces the others yet. Merchants and issuers who only look for one signal are still exposed to the other two failure modes.
Why Payments and Risk Teams Can’t Treat This as a Future Problem
Six months ago, “an AI made this purchase” was a novelty line in a product demo. It is now a line item on a chargeback report. Shopping agents built into ChatGPT, Gemini, and a growing list of browser-based assistants can browse a catalog, add items to a cart, and complete checkout without a human touching a keyboard between the search query and the confirmation email. That shift moves a question that used to belong to engineering — can our API support this? — into the risk and compliance function, where it belongs alongside chargeback ratios, know-your-customer obligations, and Regulation E disputes.
The specific audience this guide is written for is the group sitting in that gap: payments engineers, fraud and risk analysts, and compliance officers at merchants, payment facilitators, and card issuers who are being asked, sometimes on short notice, whether their systems can tell a legitimate shopping agent from a scraping bot, a credential-stuffing script, or a compromised session replaying someone else’s saved card. That question did not have a clean answer as recently as early 2025. It has a partial answer now, built from four separate industry initiatives that launched within about twelve months of each other and that solve overlapping but not identical pieces of the puzzle.
The stakes are not abstract. A merchant that blocks legitimate agent traffic loses a sale and, increasingly, loses visibility into an entire emerging retail channel. A merchant that waves agent traffic through without verification inherits the same fraud exposure that unauthenticated card-not-present transactions have always carried, except now the attacker doesn’t need to steal a card number — they just need to convince an agent, or impersonate one, that a purchase was authorized. Getting agent identity verification payments infrastructure right is no longer a nice-to-have integration; it is a core risk-control decision with a dollar figure attached, and the rest of this guide walks through how that dollar figure gets calculated.
For a broader look at how the identity and trust problem extends beyond payments into the rest of agent-driven transactions, see our companion piece on the security model behind agentic commerce, which covers machine identity and verifiable credentials at the infrastructure level rather than the payments-specific mechanics covered here.
The Three-Layer Identity Stack Behind Every Agent Checkout
Strip away the branding on any of the 2025–2026 agent-payments announcements and the same three-layer structure shows up underneath. Understanding these layers separately matters because a system that is strong on one layer and weak on another creates a specific, predictable kind of fraud exposure — and knowing which layer is weak tells a risk team exactly where to put a manual review rule or a velocity limit.
Layer 1: The Registry Layer — Who Built This Agent?
This is the most basic question and, until recently, the hardest one to answer at scale. A registry credential answers “what software is making this request, and who is accountable for it?” separate from any specific transaction. On the blockchain side, proposals like ERC-8004 give an AI agent an on-chain identity record — effectively a durable, publicly checkable reputation and ownership record tied to a wallet address. On the centralized side, OpenAI’s and Google’s agent platforms issue their own signed attestations that a given request originated from their hosted agent runtime rather than an arbitrary script pretending to be one. Neither approach is universal yet, and a merchant that only checks registry-layer credentials has confirmed the software’s pedigree without confirming that a specific human actually asked for this specific purchase.
Layer 2: The Mandate Layer — Did a Human Actually Authorize This?
This is where most of the real engineering happened in 2025. A mandate is a signed, timestamped record that a specific person granted a specific agent the authority to do a specific thing, usually bounded by a price ceiling, a merchant allowlist, or a time window. Google’s AP2 formalizes this into a chain of three mandate types, described in detail in the next section. The Agentic Commerce Protocol takes a related but distinct approach, using OAuth 2.0-style delegated authentication and a payment token handed from buyer to agent to business, rather than a chain of independently signed credentials.
Layer 3: The Network Signal Layer — Does the Card Network See Any of This?
A perfect mandate chain is worthless if the acquiring bank’s fraud model has no way to see it. This is the layer Visa’s Trusted Agent Protocol and Mastercard Agent Pay were built to fill. Rather than defining how the agent itself proves authorization to the merchant, these frameworks define how a merchant or its agent platform passes an “this is a known, registered agent” signal into the existing card-authorization message, so an issuer’s fraud model treats a signed agent transaction differently from an anonymous card-not-present request. Visa’s version, introduced in 2025 and expanded with edge-security partners like Akamai through 2026, focuses on distinguishing legitimate agents from bots at the network edge before a transaction is even attempted. Mastercard’s Agent Pay program layers tokenized, agent-scoped credentials on top of its existing tokenization infrastructure so a compromised agent credential can be revoked without reissuing the underlying card.
Cryptographic Mandates: How AP2 Chains Intent, Cart, and Payment
Google’s Agent Payments Protocol, announced in September 2025 with more than sixty launch partners spanning Mastercard, American Express, PayPal, Coinbase, Adyen, Salesforce, and Okta’s Auth0 unit, is the most structurally ambitious answer to the mandate problem so far. Instead of relying on a single “buy button click” as the moment of truth — the way most e-commerce checkouts have worked for two decades — AP2 builds a three-link cryptographic chain, and each link closes off a different way a transaction can go wrong.
The Intent Mandate is signed the moment a person tells an agent what to do, and it captures the boundaries of that instruction: “find me white running shoes under $120” or “buy tickets the instant they go on sale, up to $300 total.” This mandate is what lets a merchant or issuer later confirm that an agent had standing authorization to act, even for a delegated task completed hours or days after the person walked away from the device.
The Cart Mandate is signed later, at the moment the agent presents a specific cart — exact items, exact prices, exact shipping cost — and the person (or a pre-authorized policy) approves it. This is the mandate that answers “authenticity”: it stops a scenario where an agent’s summary of a purchase and the actual line items charged diverge, whether from a bug, a price change, or a manipulated product feed.
The Payment Mandate closes the loop by cryptographically binding a specific payment method to the approved Cart Mandate contents, creating what Google’s documentation calls a non-repudiable audit trail. If a dispute happens later, an issuer or arbitrator can trace, step by step, whether the person authorized the general intent, approved the specific cart, and bound a specific payment instrument to it — and assign liability to the user, the agent platform, the merchant, or the payment processor depending on exactly where the chain breaks.
AP2 is deliberately payment-rail agnostic. It sits on top of Google’s existing Agent2Agent (A2A) protocol and the Model Context Protocol (MCP), and it extends to stablecoin and crypto-native payments through an x402-based extension co-developed with Coinbase, the Ethereum Foundation, and MetaMask, alongside conventional card and bank-transfer rails. That breadth is a strength for adoption and a complication for risk teams, because it means “AP2 compliant” doesn’t tell you which rail a given transaction actually traveled on — that detail has to be checked separately.
Network Attestation: Visa’s Trusted Agent Protocol and Mastercard Agent Pay
Where AP2 and ACP operate mostly between the agent, the user, and the merchant, Visa and Mastercard approached the same problem from the rails up. Visa introduced its Trusted Agent Protocol in 2025 as an open framework built on existing web infrastructure, designed specifically to help merchants distinguish legitimate AI shopping agents from malicious bots and scraping traffic before a transaction is even attempted. Through 2026, Visa expanded the model with edge-security partners — Akamai’s integration adds behavioral intelligence and bot-abuse detection at the network edge, layering identity and fraud signals on top of the existing authorization message rather than replacing it.
Mastercard’s Agent Pay program takes a tokenization-first approach that will feel familiar to anyone who has worked with Mastercard’s existing digital-card tokenization infrastructure, extended to scope credentials specifically to a given agent rather than a given device or app. The practical effect for a risk team is that an agent-scoped token can be revoked the moment an agent misbehaves or a platform reports a compromise, without touching the underlying card number and without waiting for a full card reissue cycle. That granularity is the main advantage network-level attestation has over mandate chains alone: a mandate chain proves what was authorized after the fact, while a scoped, revocable token limits blast radius in real time, before a dispute even needs to be filed.
Neither network’s framework is a full substitute for a mandate chain, though, and that is the trap worth flagging early: network attestation confirms an agent is registered and behaving normally, not that a specific human authorized a specific purchase amount. A registered agent that has been prompt-injected into buying the wrong thing, or buying too much of the right thing, will still pass network attestation cleanly. It needs a mandate-style record to catch that failure mode.
OAuth Delegation and the Agentic Commerce Protocol
The Agentic Commerce Protocol, co-developed by Stripe, OpenAI, and Meta and used to power ChatGPT’s Instant Checkout feature, takes a more familiar path for anyone who has built with modern web authentication: OAuth 2.0-style delegated authorization, extended with commerce-specific building blocks. ACP defines an agentic checkout flow for creating and completing a checkout session, a cart-and-feed mechanism for browsing a merchant’s catalog, a delegated-payment mechanism for passing a payment token securely from buyer to agent to business, and a delegated-authentication mechanism for letting an agent act on a buyer’s behalf with a specific business under an OAuth grant.
The practical difference from AP2’s mandate chain is architectural rather than a difference in security intent. Where AP2 builds a chain of independently signed, portable credentials that any participant in the ecosystem can verify without a centralized authority, ACP leans on the existing OAuth trust model most merchants and payment processors already run in production, plus a payment token exchange that mirrors how a saved-card or wallet token already flows through a checkout. For a merchant already integrated with Stripe, ACP is often the lower-friction path to accepting agent traffic from ChatGPT specifically; for a merchant that wants a rail-agnostic, portable credential that works the same way whether the payment is a card, a bank transfer, or a stablecoin, AP2’s mandate chain is the more general-purpose tool. Most large merchants that this guide’s audience represents will end up supporting both, at least through 2027, because the two protocols answer to different agent platforms rather than competing head-to-head for the same traffic.
A Worked Example: What Verification Actually Saves a Mid-Size Merchant
Numbers make this concrete faster than protocol names do. Consider a direct-to-consumer merchant processing $50,000 a day in checkout volume that originates from AI shopping agents rather than a human clicking through a website — a realistic figure for a mid-size retailer by late 2026 given how quickly agent-driven browsing has grown inside ChatGPT and Gemini. The following model uses illustrative loss rates built from published card-network ranges for card-not-present fraud, applied across three verification postures a risk team might choose between.
Run that daily gap over a year and the difference between “no agent signal” and “full mandate chain” on this merchant’s agent-originated volume alone works out to roughly $273,750 in avoided losses (($925 − $175) × 365), before accounting for the operational cost of manually reviewing disputed agent transactions, which tends to run higher per case than reviewing a standard card dispute because someone has to reconstruct what the agent was actually told to do. That reconstruction cost is exactly what a mandate chain is designed to eliminate: instead of a support agent trying to recreate an AI’s reasoning from chat logs, the Cart Mandate and Payment Mandate already contain the signed record of what was approved and for how much.
The network-attestation-only middle tier is worth sitting with for a moment, because it is where a lot of merchants will land by default in 2026 and 2027, simply because their card network rolled out TAP or Agent Pay support before their checkout stack integrated AP2 or ACP mandates. It captures roughly half the benefit of full mandate verification — useful, but not a substitute for the harder integration work.
Comparing the Four Frameworks Side by Side
No single protocol covers every layer described earlier in this guide, and picking the right combination depends on which agent platforms your customers actually use and which card networks carry the bulk of your volume. The table below lines up the four most consequential frameworks as of late 2026 against the dimensions that matter most to a payments or risk team making an integration decision.
| Framework | Layer Addressed | Cryptographic Mechanism | Primary Backers | Payment Rails |
|---|---|---|---|---|
| AP2 (Agent Payments Protocol) | Mandate (authorization, authenticity, accountability) | Verifiable Credentials signing Intent, Cart, and Payment Mandates | Google, Mastercard, PayPal, Coinbase, Adyen, 60+ others | Cards, bank transfer, stablecoins (via x402 extension) |
| ACP (Agentic Commerce Protocol) | Mandate (delegated auth + checkout) | OAuth 2.0 delegated authentication + shared payment tokens | OpenAI, Stripe, Meta | Cards and stored payment methods via Stripe |
| Visa Trusted Agent Protocol | Network signal (bot vs. agent detection) | Edge-based behavioral attestation, agent registration flags | Visa, Akamai, issuing and acquiring partners | Visa card rails |
| Mastercard Agent Pay | Network signal (scoped, revocable credentials) | Agent-scoped tokenization built on existing digital-card tokens | Mastercard and issuing partners | Mastercard card rails |
Common Mistakes Payments and Risk Teams Make With Agent Identity
Most of the failures a risk team runs into in this area come from treating agent identity verification payments infrastructure like a single feature flag rather than a layered control. The specific mistakes tend to repeat across merchants of very different sizes.
- Checking registry credentials and stopping there. Confirming that a request came from a genuine, registered agent runtime says nothing about whether the amount or the items were actually approved by a person. Registry verification alone still lets through a correctly-identified agent that has been manipulated into an unwanted purchase.
- Treating a mandate chain as a fraud filter instead of a liability record. AP2’s and ACP’s signed mandates are primarily built to establish who is accountable after something goes wrong, not to predict fraud before it happens. Teams that skip a separate real-time risk score because “the mandate is signed” are missing the point of the mandate.
- Assuming network attestation and mandate verification are interchangeable. They answer different questions, and a merchant that only integrates Visa TAP or Mastercard Agent Pay signals still has no cryptographic proof that a specific human approved a specific cart. This gap is the single most common blind spot found in early agent-checkout integrations.
- Applying one policy to every agent platform. An agent operating under a tightly scoped Intent Mandate with a $50 ceiling carries a fundamentally different risk profile than one operating with an open-ended, unbounded authorization. Flattening these into a single “agent traffic” risk bucket throws away the most useful signal available.
- Ignoring revocation speed. A compromised agent credential that takes days to revoke, because the process still routes through a manual card-reissue workflow, defeats much of the purpose of a scoped, agent-specific token in the first place.
- Underestimating dispute reconstruction cost. When a mandate chain doesn’t exist, resolving an agent-related dispute often requires reconstructing conversation logs and agent reasoning from scratch, which is slower and more expensive per case than a standard card dispute.
A Practical Checklist for Payments and Risk Teams
The following checklist is built for a team deciding, in the next quarter, how far to go on agent identity verification for their own checkout flow and card portfolio.
- Identify which agent platforms already send you meaningful transaction volume (ChatGPT, Gemini, browser-based assistants) and check which protocol each one speaks natively.
- Confirm with your acquirer or payment processor whether Visa Trusted Agent Protocol or Mastercard Agent Pay signals are already available in your authorization messages, even if your team hasn’t turned on any handling logic for them yet.
- Decide whether to integrate AP2’s mandate model, ACP’s OAuth-based delegation, or both, based on which agent ecosystems drive the most volume for your business rather than which protocol launched first.
- Set explicit dollar ceilings and merchant allowlists inside every Intent Mandate or equivalent authorization grant you accept, rather than accepting open-ended agent authority by default.
- Build a separate real-time risk score for agent-originated transactions rather than reusing your human-checkout fraud model unmodified; the signal set is genuinely different.
- Test credential revocation end-to-end, including how long it takes an agent-scoped token to actually stop working after you report a compromise, not just how long it takes to submit the revocation request.
- Draft an internal liability playbook that maps each point in the mandate chain (intent, cart, payment) to who owns the loss if that specific link is later shown to be the point of failure.
- Review your chargeback and dispute workflow to confirm it can ingest and reference signed mandate records, so agent disputes don’t default to a slower manual-reconstruction process.
Key Takeaways
- Agent identity verification for payments works across three separate layers — registry, mandate, and network signal — and each layer catches a different failure mode. Checking only one layer leaves a specific, predictable gap.
- Google’s AP2 and the Stripe/OpenAI/Meta Agentic Commerce Protocol solve the mandate layer differently: AP2 uses a portable chain of signed Intent, Cart, and Payment Mandates, while ACP uses OAuth 2.0 delegation and payment-token exchange built on Stripe’s existing infrastructure.
- Visa’s Trusted Agent Protocol and Mastercard Agent Pay operate at the network-signal layer, helping issuers and acquirers distinguish registered agents from bots and scraping traffic, but neither proves that a specific purchase amount was authorized by a person.
- In a modeled example on $50,000 of daily agent-originated volume, moving from no agent signal to a full cryptographic mandate chain cut estimated daily fraud and chargeback losses from roughly $925 to $175 — a gap worth close to $274,000 a year on that volume alone.
- Most merchants will end up supporting more than one framework through at least 2027, because different agent platforms default to different protocols rather than converging on a single standard.
Frequently Asked Questions
What is agent identity verification in the context of payments?
Agent identity verification for payments is the process of confirming, before a transaction is approved, that an AI shopping agent making a purchase is a genuine, registered piece of software, that a specific human granted it authority to make that specific purchase, and that the card network or issuer can see enough of that evidence to make an approval decision. It combines a registry credential, a signed authorization record called a mandate, and a network-level attestation signal.
What is the difference between Google’s AP2 and the Agentic Commerce Protocol?
AP2 uses a chain of independently signed Verifiable Credentials called Intent, Cart, and Payment Mandates, designed to work across any payment rail including cards, bank transfers, and stablecoins. The Agentic Commerce Protocol, built by Stripe, OpenAI, and Meta, instead extends OAuth 2.0 delegated authentication and payment-token exchange, tying more closely into Stripe’s existing checkout infrastructure. Both aim to prove that a human authorized an agent’s purchase, but they use different technical mechanisms to do it.
Do Visa’s Trusted Agent Protocol and Mastercard Agent Pay replace the need for a mandate chain?
No. Both frameworks operate at the network-signal layer, helping an issuer or acquirer distinguish a registered, well-behaved AI agent from a malicious bot or scraper before or during authorization. Neither one independently proves that a specific human approved a specific cart or dollar amount, which is the job a mandate chain like AP2’s or a delegated-authentication flow like ACP’s is built to do.
What happens if a fraudulent purchase is made through an AI agent?
Liability depends on where the failure occurred in the identity chain. If a signed mandate shows the agent acted outside the authority a person granted it, responsibility typically points toward the agent platform or the entity that deployed the agent. If the mandate shows the person authorized the exact cart and amount that was charged, the transaction is treated as an authorized purchase even though a human didn’t manually click “buy.” Card-network frameworks and mandate-based audit trails are both designed to make that determination traceable rather than a matter of guesswork after the fact.
Should a merchant require full mandate verification for every agent transaction?
Not necessarily for every transaction, but it is the strongest available protection against the highest-value or highest-risk agent purchases. A tiered approach — network attestation as a baseline filter for all agent traffic, with full mandate verification required above a certain dollar threshold or for new agent-merchant relationships — captures most of the fraud reduction benefit without requiring every low-value transaction to carry the overhead of a complete cryptographic chain.
How fast is this space changing, and should a payments team wait before integrating anything?
Waiting carries its own cost. Agent-originated checkout volume has grown quickly enough through 2026 that merchants without any verification layer are already absorbing fraud losses that a basic network-attestation integration would meaningfully reduce. The safer approach is to integrate the network-signal layer first, since it requires the least custom engineering, and treat full mandate-chain support as a parallel project rather than a blocking prerequisite.
References
- Google Cloud, “Announcing the Agent Payments Protocol (AP2),” September 2025.
- Stripe, “Developing an Open Standard for Agentic Commerce” and Agentic Commerce Protocol documentation, 2025–2026.
- OpenAI, “Buy It in ChatGPT: Instant Checkout and the Agentic Commerce Protocol,” 2025.
- Visa, “Visa Introduces Trusted Agent Protocol: An Ecosystem-Led Framework for AI Commerce,” 2025, and subsequent partner announcements through 2026.
- Mastercard, Agent Pay program materials and digital-card tokenization documentation, 2025–2026.
- Ethereum ecosystem documentation on ERC-8004 agent identity registries.
