Payments for AI Agents: Wallets, x402 and Real Costs

Payments for AI agents are the protocols that let autonomous software spend money on API calls without a human. The agent holds a funded balance, discovers a paid API, and pays per call over an open protocol like x402 or MPP. Both are built on the HTTP 402 status code. That wallet is what turns an agent from a chatbot into an economic actor that can transact on its own.

How do AI agents actually pay for things?

An AI agent pays by holding its own funded wallet and settling each call at request time, with no human at the checkout screen. It discovers a service and reads the price the server quotes. Then it signs a stablecoin payment and gets the data back inside one request.

This is the third evolution of commerce. First it happened in person, then on the internet, now agents do it for you.

Most "agent does X" demos work right up until checkout, then quietly cut away. The reason is structural. The internet was built for people, not software. So an agent either borrows your credentials or wires up every merchant by hand in advance. Borrowing credentials creates a security problem, and wiring up each merchant defeats the point of autonomy in the first place. A wallet fixes both by giving the agent its own financial identity and its own balance to spend.

Picture an agent researching a market. It needs a data feed it never signed up for. With a wallet it just calls the endpoint, pays the quoted price, and keeps going.

The pay-per-call loop, step by step

The pay-per-call loop runs in four steps, and all of them happen inside the single request the agent already made. There's no signup and no invoice, and the agent never waits on a monthly bill. Here's the sequence:

1. The agent finds a paid endpoint and calls it.
2. The server answers with the price.
3. The wallet signs a payment for that exact amount.
4. The server hands back the data, and the agent keeps going.

The whole point is speed: get in, get what you need, get out. Your agent buys one email address for a penny and moves on, with no account to open and no subscription or relationship to manage.

Wallet vs managed credit

Two models exist. In a wallet-based model, the one AgentCash uses, the agent's runtime holds a funded wallet and signs payments directly. That keeps custody and clean on-chain accounting with you. In a managed-credit model, the one a platform like Payman uses, a third party holds the balance and pays on the agent's behalf. It's simpler to start, but it centralizes trust.

AgentCash uses the wallet-based model. You create a wallet, fund it, and the agent pays providers directly.

Why can't agents just use a credit card?

Agents can't rely on credit cards because the fees make small payments uneconomic. A card charges 30¢ + 2.9% per transaction, so a 4-cent API call would cost more in fees than the call itself. Stablecoins settle for a fraction of a cent, which is what makes per-call payments work.

Picture this. You walk into a mall and pay a $5 fee every time you buy a single T-shirt. You'd never buy just one, right? You'd bundle 20 to make the fee worth it. That bundling instinct is the whole reason subscriptions exist, and it's roughly how the internet charges today.

Cards do the same thing to agents. A 30¢ + 2.9% fee on every transaction is fine for a $200 purchase. It's fatal for a 4-cent one. Stablecoin transfers on a Layer 2 like Base cost well under a cent, so the fee no longer swamps the payment.

Cards still have a place. For a big one-off buy, say booking a flight, the agent can run the whole flow and prompt you to finish the card payment. But for the thousands of tiny calls an agent makes per task, stablecoins are the only rail that pencils out.

How does an agent pay for a single API call?

An agent pays for a single call over one of two open protocols, x402 or MPP, both of which turn the HTTP 402 status code into a real payment handshake. x402 signs a payment per call on-chain. MPP signs one authorization up front, then settles each call without re-signing.

x402 was built by Coinbase. The server quotes a price in its 402 response, the wallet signs a USDC transfer, and the server settles it and returns the data in one round-trip. Here's the x402 handshake, step by step:

1. The server responds with HTTP 402 and a JSON body naming the price, the currency (USDC), a destination address and the chain.
2. The agent's wallet signs the payment and retries the request with a PAYMENT-SIGNATURE header.
3. The server verifies the payment, settles on-chain, and returns the data.
4. Settlement details come back in a PAYMENT-RESPONSE header.

The handshake skips OAuth, redirects and invoices entirely, and any HTTP client can be extended to support it.

MPP, the Machine Payments Protocol, was co-authored by Stripe and Tempo and launched in March 2026. It works differently from x402. Instead of signing a payment on every call, the agent signs one authorization up front, then settles each later call without re-signing.

Think OAuth for payments. That one permission is off-chain, so the stablecoin still settles on-chain per call while the per-call signature goes away. The session model lets MPP handle more than one-shot calls, including recurring subscriptions and streaming usage. Its payment methods are broader than x402's too. Fiat cards from Stripe, Visa and Mastercard all work, and so do buy-now-pay-later and Bitcoin over Lightning. Stablecoins run on Tempo, its own L1. Adoption came fast. Visa, Mastercard and Shopify integrated it on the payments side, with Anthropic and OpenAI on the agent side. More than 50 services were live within its first week.

Here's how the two compare:

Here's where AgentCash fits. One AgentCash wallet works across both rails, so the agent doesn't care which protocol a server speaks. Fund it on Base or Solana and x402 calls go through. Fund it on Tempo and MPP calls go through.

If you want the protocol in depth, see what x402 is and how it works or the x402 spec.

What do agents actually pay for today?

AgentCash's mppscan shows the MPP side in real numbers: 1.76 million transactions from 147K unique paying agents, settling $253K in volume to 4,523 recipient services on Tempo. x402scan, AgentCash's x402 explorer, shows $52.4 million settled all-time across 195M+ transactions and 844K unique buyers on Base and Solana.

This isn't hypothetical. mppscan indexes the agents, servers and prices across the MPP directory, and the figures move daily. The recipients are real APIs: crypto data feeds, IP lookups, LLM inference and enrichment tools. Every call in there is a payment an agent made without a human.

Compare that to how the rest of the category talks about agent payments: press releases about card-network pilots, with no usage data attached. Here are live per-call prices from x402scan, AgentCash's x402 explorer:

Per-call prices from x402scan, pulled 2026-07-20. Real per-call prices run from a fraction of a cent to about a dollar. That's exactly the range a 30¢ + 2.9% card fee would swamp.

What does it cost: subscriptions vs pay-per-call?

For spiky, on-demand agent usage, paying per call almost always beats a monthly subscription. A subscription charges a flat fee whether the agent makes ten calls or ten thousand, while pay-per-call bills only for what runs. Think of it as serverless billing for data: cost per invocation, not a standing tier.

Here's the contrarian part. The subscription economy runs on friction: forgotten renewals, hard cancels, and commodity data marked up a thousand times over. Agents break that model. They find the best price, buy exactly what they need, and leave. Some data vendors charge $60 for what would cost 4 cents per call, and those vendors won't give up that margin gracefully.

Think of per-call pricing the way cloud teams think about serverless: you pay per invocation, not for a standing server you mostly idle. For spiky agent workloads, that math almost always favors pay-per-call. See why agents need pay-per-call APIs for the deeper case.

Say a data feed prices two ways. These figures are illustrative, not a quoted price, but they show the shape of the tradeoff:

How do you give your agent a wallet?

You give your agent a wallet in three steps: create the wallet, fund it with USDC, and set spend caps before it runs. Install the AgentCash CLI and it creates a local wallet with a funding address:

Send USDC on Base, Solana or Tempo and every paid API is callable.

The wallet is the agent's financial identity, so it's worth understanding what an AI agent wallet is before you fund one.

Fund it and set caps

Fund the wallet by sending USDC to the address the CLI shows. Once the balance confirms, every paid API is callable with no further signup. Set spend caps per session or per task so the agent can't run past a limit you choose. Start low and raise it as trust grows.

Install the MCP server

For coding agents, install the AgentCash MCP server into your agent config. That covers Claude, Cursor and Claude Code. It handles the full x402 handshake for you, so the agent pays and retries without extra code. After that, any paid tool the agent reaches just works.

Tradeoffs and limits

Agent payments come with three tradeoffs: settlement latency, USDC exposure, and APIs that don't speak x402 yet. None is a dealbreaker for most builds, but each is worth pricing in before you ship:

• Settlement latency. On-chain settlement adds a little latency and one extra HTTP round-trip, which is negligible for most workloads.
• USDC exposure. You hold a stablecoin balance, a different risk profile than a credit card.
• Non-x402 APIs. The x402 index is early, so an agent that needs an API that doesn't speak x402 still uses a traditional key for that one.

That's the whole picture of payments for AI agents: a wallet, the x402 handshake, and real per-call costs you can see before you pay. When your agent is ready to spend on its own, start at agentcash.dev/onboard.