How AI Agents Pay: Wallets, Agent-to-Agent Payments and API Micropayments

Short version: An AI agent pays the same way a person does, with one structural difference: it never holds raw credentials. Instead it gets a mandate (what it may spend, where, and until when) and a scoped way to pay: a funded stablecoin wallet, a tokenized card credential that only works inside the mandate, a one-time virtual card, or a pre-funded platform balance. Which of those it uses depends on what it is buying: API calls are paid per request over HTTP 402 protocols like x402 and MPP; goods from normal stores are paid with card tokens via ACP and the card networks' agent programs; other agents are paid wallet to wallet in stablecoins. This guide walks each route. For the platforms that provide the wallets and credentials, see the best agentic payment platforms; for the protocol specs, see agentic payment protocols compared.

AI agent wallets

An agent wallet is the account an agent spends from. Four models exist in production today, and the differences are custody and control:

1. Non-custodial smart wallets. The wallet is a smart contract account whose permissions are enforced onchain. Crossmint's Agent Wallets work this way: the owner sets a spend cap, allowed counterparties and a time window, neither the owner nor Crossmint takes custody of the funds, and permissions can be revoked at any time.
2. Platform-managed wallets with isolated keys. Coinbase Agentic Wallet has the agent authenticate by email and one-time code, hold USDC and pay on Base, Polygon and Solana, while private keys stay inside Coinbase infrastructure and spending guardrails (maximum per call, maximum per session) are enforced before any transaction, alongside KYT and OFAC screening.
3. Custodial platform wallets. Skyfire manages the wallet for every agent account, funds it with USDC or by card, and moves funds between buyer and seller wallets at settlement. The agent does not hold keys at all; it holds tokens that authorize charges against the wallet.
4. Pre-funded account balances. ATXP gives the agent an account with an IOU balance: the developer loads funds, each tool call deducts, and the balance hitting zero is the hard stop. No keys, no chain transactions per call, and per-category limits on top.

Two design rules show up in every serious implementation. First, keys and card numbers are never exposed to the model: the agent requests a payment, and a separate, deterministic layer checks it against the mandate and executes it. Second, every control is set before the agent starts: caps, allowlists, expiry and revocation. If a wallet pitch cannot tell you who holds the keys and what stops a runaway agent, it is a demo, not infrastructure. Agent banking, where the agent holds actual bank accounts, is the next step: Catena Labs is building it, with identity handled by its ACK-ID credentials, but it is not generally available yet.

Agent-to-agent payments

When the seller is also software, the checkout disappears entirely. Agent-to-agent payments settle wallet to wallet, almost always in stablecoins, because both sides can hold them, settlement is final in seconds, and no card network or bank hours intervene.

The common patterns:

• Pay per service call. Agent A needs data, inference or a tool that agent B sells. B's endpoint answers with a payment demand (usually x402), A pays from its wallet or balance, B delivers. ATXP's whole account model is built around agents paying for tools this way, and ATXP agents carry their own identity and email address alongside the balance, so the counterparty relationship persists between calls.
• Marketplaces and catalogs. Nevermined runs an AI services catalog where buyers' agents pay sellers' services per request, settling in fiat via Stripe on card rails or in USDC on crypto rails. Discovery plus payment in one place is what makes agent-to-agent trade practical at small values.
• Delegated budgets. A parent agent or a business funds sub-agents with separate balances and budgets, so each agent's spend is capped and auditable independently. Per-agent balances are a published ATXP feature and the natural pattern for teams of agents.

Identity is the unsolved layer here. Two wallets can settle instantly, but knowing whether the counterparty agent is who it claims to be is what KYA systems (Skyfire's tokens, Catena's ACK-ID with decentralized identifiers and verifiable credentials, and the identity work inside AP2) are being built for. Until that matures, most agent-to-agent volume runs inside platforms that know both sides.

How agents pay for API calls

This is the most concrete use case, because the flow is fully specified by two protocols. The older model, an API key tied to a human's credit card with a monthly invoice, fails agents in three ways: keys leak, spend is discovered after the fact, and a seller cannot sell to an agent that has no account. Pay-per-request fixes all three.

The x402 flow. The agent requests a resource. The server responds HTTP 402 with the price, the recipient and the accepted assets. The agent signs a stablecoin payment and retries with proof attached. A facilitator verifies the signature, screens the transaction and settles onchain; the server returns the resource with a confirmation. No account setup, no API key management, and the protocol itself charges no fee. Coinbase's facilitator settles the first 1,000 transactions per month free, then charges $0.001 per settlement, which is what makes sub-cent pricing models arithmetically possible.

The MPP flow. Same shape, wider payment options. Stripe and Tempo's Machine Payments Protocol (launched March 2026) has the server return 402, the agent authorize, and the resource delivered with a receipt, but the agent can pay in stablecoins or with card and buy-now-pay-later methods via Shared Payment Tokens, and the seller settles in fiat into its Stripe balance. Published minimums on Stripe are $0.50 for card payments and 0.01 USDC for stablecoin payments. MPP sessions let an agent set funds aside once and stream many small payments against them, which suits high-frequency tool use.

The platform shortcut. If you do not want to implement either protocol, platforms will stand in front of your API: Nevermined wraps APIs and MCP servers with a paywall and charges per call; Crossmint gives the buying agent the wallet that can pay both x402 and MPP endpoints; ATXP funds tool calls from the agent's balance and provides paid tools through MCP servers. On the Coinbase side, Agentic Wallet's MCP form lets an agent in an MCP client discover and pay for services with no code at all. The trade-off is the usual one: a platform fee and dependency, against weeks of protocol work.

Micropayments for AI agents

Micropayments are where agent payments stop being a feature and become an economic unlock. A human will not pay $0.01 for one search result or $0.001 for one inference call through a card checkout: the card fee alone (roughly $0.30 fixed on mainstream pricing) is 30 to 300 times the price. Agents transact at exactly that scale, so the rails had to change:

• Stablecoin settlement on low-cost chains makes a $0.001 payment viable: the network fee is a fraction of the payment, and facilitators batch and absorb the rest (Coinbase's facilitator at $0.001 per settlement after the free tier is priced for exactly this).
• Session and channel models aggregate thousands of micro-charges into one settlement: MPP sessions deposit once and stream, so the per-call cost approaches zero while the seller still gets paid in full.
• Pre-funded balances move the accounting off-chain entirely: ATXP's IOU balance deducts per call with no chain transaction, and the cap is simply the funded amount.
• Scoped card tokens are the fiat bridge: a Shared Payment Token with a maximum amount and expiry lets an agent make card payments that would individually be uneconomic for a merchant to key in manually, though the $0.50 card minimum on MPP shows the floor card rails still impose.

The honest constraint: micropayments work today for digital goods between software. They do not yet work for physical goods, regulated services, or anywhere a chargeback regime applies, which is why the card networks are building their agent programs in parallel rather than conceding the category.

What this means if you sell something agents buy

Three checks decide whether an agent can pay you this quarter. First, can your price be expressed per call or per unit, not per month? Second, is your endpoint payable by x402 or MPP directly, or through a platform like Nevermined that wraps it? Third, if the agent arrives with a card token instead, does your checkout accept Shared Payment Tokens via ACP or your existing Stripe setup? The agentic payments hub keeps the platform and protocol matrix current, and the processor directory covers the conventional side when the agent's owner is a business that also needs normal merchant processing.

FAQ

Do AI agents have their own bank accounts?

Mostly no. Production agents today spend from stablecoin wallets, platform balances or tokenized card credentials. Agent banking with real accounts is being built (Catena Labs is the visible example) but is not generally available.

Can an agent spend more than its owner intended?

Not if the mandate is enforced outside the model, which is every serious design: onchain wallet permissions (Crossmint), balance caps (ATXP), mandate checks on every purchase (Nevermined), per-call and per-session limits (Coinbase), or token limits (Stripe SPTs and Mastercard Agentic Tokens). The agent proposes; the payment layer disposes.

What currency do agents pay in?

USDC is the default across x402, Coinbase Agentic Wallet, Crossmint and Nevermined crypto rails. Card-funded routes settle in fiat. Bitcoin and Lightning are not published as supported rails by any platform verified for this guide, despite Lightning's micropayment history.

How much does it cost an agent to pay for an API call?

The payment amount is set by the seller. The infrastructure cost on top can be near zero: x402 charges no protocol fee, and Coinbase's facilitator charges $0.001 per settlement after 1,000 free settlements a month. On card rails, expect card minimums (from $0.50 on MPP) and normal processing economics.

Sources and method

Flows, limits and prices in this guide were checked on the providers' and protocols' own documentation on 25 October 2026: Coinbase Developer Platform (Agentic Wallet, x402 facilitator pricing), Stripe docs and blog (MPP minimums, sessions, Shared Payment Tokens), x402.org, Crossmint agent docs (wallet permissions), Nevermined docs and pricing, ATXP docs and blog (IOU balance model, per-agent budgets), Skyfire docs (wallet and token model), and Catena Labs (ACK-ID). Where a platform does not publish a rail or a price, this guide does not claim it.