Agentic Commerce Protocol, Explained: What ACP and SharedPaymentToken Mean for Merchants — and Where Crypto Fits
ACP lets AI agents buy on a user's behalf inside chat — with SharedPaymentToken scoping what the agent may spend. A plain-English breakdown of how it works, what it means for merchants, and the parallel rail ACP doesn't cover: stablecoin payments agents can make natively.
The short answer: the Agentic Commerce Protocol (ACP) is an open standard — introduced by OpenAI with Stripe — that lets an AI agent complete a purchase for a user without leaving the conversation: the merchant exposes a programmatic checkout, and payment travels as a SharedPaymentToken, a delegated credential scoped to that merchant and amount instead of a raw card number. It's the card world's serious answer to "my agent wants to buy something." What it isn't: the whole picture. Agents that pay from machine-held funds — per API call, per task, without a human's card on file — need a different rail, and that rail is stablecoins speaking protocols like x402. This guide explains ACP mechanics honestly, then maps where each rail wins. (Merchant in a hurry? Both rails are testable in our sandbox.)
Why agentic commerce needed a protocol at all
An AI agent that shops hits a wall the moment money moves. The old workarounds were all bad: hand the agent your card number (unbounded trust in a text box), let it drive a browser through checkout like a human impersonator (fragile, and merchants can't tell agents from fraud), or stop and summon the human for every purchase (which defeats "agentic").
The structural problem: commerce infrastructure authenticates humans, and agents aren't humans. Every serious answer to agentic commerce is some way of saying "this purchase is authorized, delegated, and bounded" in a machine-verifiable form.
How ACP actually works, in one pass
Three parties, one flow:
- 1The user tells their agent to buy — inside ChatGPT or another agent surface. The user's payment method already lives with the platform (or its payment partner); the agent never sees a card number.
- 2The merchant exposes an agent-readable checkout — products, prices, and an order endpoint the agent can call programmatically, instead of a human-only web page. The merchant stays the merchant of record: it's your sale, your customer, your fulfillment.
- 3Payment travels as a SharedPaymentToken — a delegated credential minted for this merchant, this amount, this purchase-ish scope. The merchant charges it through their processor like a normal tokenized payment. The agent carried authorization, never the underlying card.
The design is genuinely clever about its trust boundary: the user delegates bounded spending to the agent; the token's scoping means a leaked or misbehaving agent can't drain a wallet — it can at most spend what was delegated where it was delegated.
What ACP means for merchants, practically
- A new front door. Agent surfaces become a sales channel the way mobile web once did. Merchants who expose agent-readable checkout get found and bought from inside conversations; merchants who don't are invisible where a growing slice of purchase decisions happen.
- The card stack rides along. SharedPaymentToken settles through card rails — which means the familiar economics ride along too: processing percentages, chargeback exposure, settlement delay. ACP changes who initiates checkout, not what the money does afterward.
- Bounded delegation is the pattern to learn. Whatever rail wins, "scoped, verifiable, delegated authority" is how agent-era payments will work everywhere — a pattern crypto readers will recognize, because welding constraints into credentials is exactly how vault subscriptions already work.
The half ACP doesn't cover
Now the honest boundary. ACP answers: how does an agent spend a human's card? It does not answer: how does software pay for things as itself?
Consider the purchases agents increasingly make: API calls metered per request, datasets bought per query, compute rented per task, another agent's services invoked mid-workflow. These are machine-to-machine purchases — thousands of them, for cents each, at machine speed. Card rails were priced and built for human-sized baskets: a fixed fee per transaction makes a $0.03 purchase absurd, authorization latency makes per-request payment sluggish, and no card issuer wants to underwrite an autonomous process.
This is where the crypto rail stops being ideological and starts being mechanical: stablecoins are money software can hold, and on-chain settlement is final in under a second for a fraction of a cent — with no chargeback machinery an agent could never navigate anyway. Protocols like x402 put that capability behind a plain HTTP handshake: request a resource, receive a price, pay in stablecoins, get the resource — no account, no card, no human. Finality's rails speak this natively: the same dedicated-address settlement that serves your human customers serves agent payers, and machine-friendly integration is the same API you'd wire anyway.
The two-rail map (bookmark this)
| ACP / SharedPaymentToken | Stablecoin rails (x402-style) | |
|---|---|---|
| Who pays | A human, via their delegated agent | Software, from funds it holds |
| Best for | Consumer purchases in chat surfaces | API metering, data, compute, agent-to-agent |
| Money moves on | Card networks | Chains — final in seconds |
| Unit economics | Human-basket pricing | Sub-cent fees, viable at $0.01 |
| Merchant setup | Agent-readable checkout + processor | One payment API, agent-callable |
| Reversibility | Card disputes apply | Final settlement |
The strategic read for merchants: these rails are complements, not competitors. If you sell to consumers, ACP-style checkout puts you in the conversation window. If you sell anything machines consume — APIs, data, digital services — the stablecoin rail is where autonomous demand will actually be able to pay you.
FAQ
What is the Agentic Commerce Protocol in one sentence?
An open standard letting AI agents complete purchases from merchants programmatically, with payment delegated via scoped tokens instead of shared card numbers.
What is a SharedPaymentToken?
A delegated payment credential minted for a specific merchant and bounded amount — the agent carries proof of authorization rather than the user's actual card details.
Is ACP a crypto protocol?
No — it settles over card rails via the merchant's processor. It's the card ecosystem's architecture for agentic checkout; the crypto counterpart for machine-native payments is x402 and stablecoin settlement.
Do merchants need to choose between ACP and crypto rails?
No — they serve different purchases. Consumer sales via agents → ACP-style. Machine-consumable goods and per-use billing → stablecoin rails. Many merchants will run both.
Can an AI agent pay with crypto today?
Yes — an agent holding stablecoins can pay any Finality checkout like any payer: dedicated address, instant settlement, no wallet-connect ceremony. x402 formalizes the handshake for HTTP-native flows.
What does agentic commerce mean for chargebacks?
On card rails, dispute rules for agent-initiated purchases are still settling — one to watch. On stablecoin rails the question doesn't arise: settlement is final, which is precisely what machine-speed commerce needs.
How do I make my store agent-readable?
Structured product data, a programmatic order path, and payment a machine can complete. On the crypto side, a payment API with dedicated addresses already is that — no browser assumed anywhere in the flow.
Will agents really buy subscriptions?
Agent-managed subscriptions are a natural next step — and vault subscriptions fit them unusually well: bounded pre-funding, welded terms, and an exit that needs no customer-service conversation an agent couldn't have.
Is agentic commerce actually happening or still hype?
The protocol work is real and shipping; volumes are early. The sober read: infrastructure arrives before behavior — the merchants who wired mobile checkout in 2009 felt early too.
Where should a merchant start this quarter?
Two afternoons: expose your catalog in structured form, and stand up a stablecoin checkout in sandbox — you'll be ready for both kinds of agent before either becomes table stakes.
Agentic commerce splits into two questions — "how do agents spend human money?" (ACP's answer is good) and "how does software pay as itself?" — and the second one is already answerable: open the sandbox, make a payment the way an agent would, and watch settlement land with no human in the loop. That's the rail the machines get.