Agentic payments are payments that are initiated, authorized, and settled by a software agent acting on a human’s mandate — not by a human clicking a buy button. The person sets the goal and the limits (“keep my data pipeline running, spend up to $50 a month”); the agent decides when to pay, whom to pay, and how much, then executes the transaction itself.
The shift is easy to state: commerce moves from click-to-pay to decide-to-pay. For thirty years, every payment on the internet has assumed a human at the keyboard — a person to read the checkout page, type a card number, pass a 3-D Secure challenge. An agentic payment removes that assumption. The buyer is a program, and the entire payment stack has to work when nobody is watching.
How do AI agents actually pay for things?
Three patterns are live today. They differ mostly in whose rails carry the money.
1. Virtual and tokenized cards. The card networks’ answer is to give agents scoped card credentials instead of a raw card number. Mastercard’s Agent Pay and Visa’s Trusted Agent Protocol register an agent, verify it cryptographically, and issue tokenized credentials it can present at checkout. Stripe’s shared payment tokens do the same for its merchants: the agent gets a single-use, merchant-locked token, never the customer’s actual card. The human’s card sits behind the token; the network’s fraud and dispute machinery stays in place.
2. Agent-held crypto wallets. The simpler, more radical pattern: the agent holds its own wallet with a stablecoin balance and pays directly on-chain. No card, no bank account, no issuer approval — just a keypair and USDC. This works because stablecoin payments are machine-legible end to end: an API can construct, sign, and broadcast a transfer, and the receiving side can verify finality without trusting anyone’s word for it.
3. HTTP-native settlement with x402. The newest pattern makes payment part of the web protocol itself. A server answers a request with HTTP 402 Payment Required plus machine-readable payment terms; the agent pays (typically USDC on a fast chain) and retries the request with proof of payment attached. No account creation, no API-key onboarding, no invoice. We walk through the full request cycle in our x402 protocol explainer, and the spec itself lives at Coinbase’s x402 project.
In practice the patterns are converging: card networks are adding agent identity, and crypto rails are adding mandates and spend controls. But they start from opposite ends.
Credit cards or crypto? What agents really use
Honest answer: for agent-to-business spending in the wild today, it’s overwhelmingly stablecoins — roughly 98.6% of x402 payments settle in USDC. Card-based agent payments exist and will matter enormously for consumer retail, but the agent economy that actually runs today — machine-to-machine payments for compute, data, and APIs — runs on crypto rails.
Why the split? Card rails were built around a human who isn’t there anymore:
- Authorization assumes a person. CAPTCHAs, 3-D Secure prompts, “confirm this was you” texts — every fraud control is a human check that an agent either fails or has to be exempted from.
- Chargebacks assume intent disputes. “I didn’t authorize this” means something different when a program authorized it under a mandate you signed.
- Fees assume human-sized purchases. A $0.002 API call can’t carry a $0.30-plus-interchange card fee. Stablecoin transfers on fast chains cost fractions of a cent, which is what makes pay-per-use API pricing for agents economically possible at all.
- Settlement assumes patience. An agent that needs a resource now can’t wait two days for funds to clear. On-chain settlement is final in seconds.
Cards win where the purchase is a human purchase that an agent merely executes — booking a flight, ordering groceries. Crypto wins where the buyer, the seller, or both are machines. Most serious builders expect both to coexist, which is why the identity and mandate layers (below) are being designed to be rail-agnostic.
The trust problem: mandates, spending limits, and Know Your Agent
The hard part of agentic payments is not moving the money. It’s answering three questions before the money moves:
Who authorized this? Google’s Agent Payments Protocol (AP2) answers with cryptographically signed mandates — verifiable records of what the human actually asked for (“buy running shoes under $120”) that travel with the transaction. If something goes wrong, the mandate is the audit trail: you can prove what the agent was and wasn’t allowed to do. The AP2 specification is open and rail-agnostic.
Is this spend within policy? Every credible agent-payment system gates spending behind explicit limits: per-transaction caps, daily budgets, merchant allowlists. Attempts inside the policy go through automatically; attempts outside it escalate to a human for approval. The agent is autonomous inside a box the human drew.
Who is liable when it goes wrong? This is the open frontier, often called Know Your Agent — the emerging analog to KYC. If a verified agent, operating under a valid mandate, makes a bad purchase, liability follows the mandate: did the agent exceed it (agent developer’s problem), was the mandate forged (identity provider’s problem), or did the human sign a broader mandate than they realized (their problem)? The frameworks are young, which is exactly why signed mandates and hard spend limits matter — they turn “the AI did something” into an attributable, bounded event.
Agentic payments today: what’s real vs hype
Worth separating, because the gap is wide.
Real and shipped: the x402 Foundation (Coinbase and Cloudflare) stewarding the x402 standard; Circle’s agent-facing stack for USDC payments; AWS bringing payment capabilities to agents in Bedrock AgentCore; Mastercard Agent Pay and Visa’s agent programs live with partners; Stripe issuing agent payment tokens. Agents genuinely pay for compute, data, and API access today — mostly small amounts, mostly USDC, mostly machine-to-machine.
Projections, not facts: McKinsey sizing agentic commerce at $3–5 trillion by 2030, Juniper at $1.5 trillion in agent-driven transactions. Plausible, unproven. Treat every “trillion” in this space as a forecast.
And a cautionary note: not every launch sticks. OpenAI’s Instant Checkout under the Agentic Commerce Protocol — one of the highest-profile consumer launches — was subsequently wound down. Early infrastructure gets rebuilt; the direction is clear, the specific winners are not.
Where Plaidly sits in this: agent payments run on Plaidly today via payment sessions and API keys on testnet rails — an agent creates a session, pays it in USDC on-chain, and gets a signed webhook on settlement, same as any merchant integration across the twenty supported chains. We also expose an x402 facilitator endpoint for payment validation; full x402 proof settlement is on the roadmap, and we say so plainly rather than pretending otherwise.
Seeing one happen
Definitions only go so far. We ran a testnet demonstration in which six independent AI agents each rented a VPS from a mock hosting merchant and paid for it in real on-chain USDC — session created by API, wallet-signed transfer, settlement confirmed, server provisioned, no human in the loop. The full six-agent case study walks through the whole run, block-explorer links included. It’s testnet, and we label it as such — but every mechanical step is the same one mainnet agents will take.
Where to go next
- The agentic payments hub — the full picture: protocols, rails, and how to accept agent payments.
- The x402 protocol, explained — the HTTP 402 payment cycle in detail.
- Pay-per-use APIs for AI agents — metering and micro-billing patterns.
- Crypto payouts for marketplaces and agents — the money-out side.
- The Plaidly docs — payment sessions, API keys, and webhooks, if you’d rather read request shapes than prose.
The one-line takeaway: agentic payments are what happens when the buyer becomes software. The rails that win will be the ones that never assumed a human in the first place.