Explainers, comparisons and guides on agent payments

A card tells another agent what you can do once it knows your domain. It does not answer the question an agent usually has, which is who can do this.

x402, AP2, ACP and MPP in one table, with the two questions that actually decide between them and the control none of them gives you.

Two enforcement models, five controls, and one rule: anything the agent can talk itself out of is not a control.

Most mainstream assistants cannot spend money directly. The ones that can do it through a wallet their operator funded, with limits the operator set.

EIP-3009 lets a token holder sign a transfer instead of broadcasting one, so a third party can submit it and pay the gas. It is the mechanism under most x402 payments.

A registry standard giving agents on-chain identity, reputation and validation. Adoption is large, and an empirical study found most of it is placeholders.

Price, latency and evidence of working, in that order, with no brand loyalty anywhere. What that means for a seller trying to win the comparison.

The four routes an agent has to find a paid API it has never seen, what each one misses, and how to make your own endpoint findable.

The three ways software can pay for an API call today, what each one costs in friction, and which to offer when your buyer is an agent rather than a person.

Four independent analyses in 2026 asked the same question and all found the headline figures overstated. Here is what each one measured and what survives.

A seller's dashboard is a claim. The chain is a record. Seven checks you can run against a wallet address before believing either.

A program comparing two endpoints has no loyalty and no inertia. That changes what a price has to do and which pricing mistakes are fatal.

402 was reserved in the original HTTP spec and left unimplemented for three decades. What changed is that the buyer stopped being a person.

KYA borrows a name from compliance and cannot do what compliance does. What it can do is bind a claim to a key and leave a checkable record.

A plain markdown file at your root that tells a model what your site offers. Useful, widely misunderstood, and not a discovery mechanism.

An agent finds you four ways and three of them need something published that most APIs do not have. Here is the whole checklist, in priority order.

Three protocols people treat as competitors sit at three different layers. Getting the stack right removes most of the confusion about agent infrastructure.

MCP has no payment layer, so the money goes in the HTTP transport underneath. That constraint decides the whole design, including what your refusals can say.

A signed mandate proves a user signed, not that they understood. That gap is where injected instructions turn an agent's wallet into the attacker's.

Twelve things to get right before an agent can find, evaluate and pay your endpoint, in the order they actually block you.

Every x402 request is prepaid, which changes what abuse looks like. The limits you need are different from the ones a free tier taught you to build.

Most dashboards in this space show a true number computed over an unstated population. Six habits stop you drawing the wrong conclusion from a correct chart.

Settlement is final and there is no chargeback. That makes the failure cases a design decision rather than a support process.

Usually no. The cases where the answer is yes are specific, and the work you take on is a funded hot wallet rather than a library.

Six checks an agent can run in under a second against a payee it has never used, and the one rule that holds when all six come back empty.

USDC dominates x402 for a technical reason rather than a commercial one. Knowing what that reason is tells you when another asset is viable.

Testnets cover the happy path well and three specific things badly. Knowing which is the difference between a clean launch and a confusing one.

Manufacturing payment volume costs a fraction of a cent and produces numbers indistinguishable from commerce. Five patterns separate the two.

Six paths under /.well-known that agents and crawlers probe, what each one is for, and the status-code trap that makes missing ones look present.

A request, a payment and a settlement are three different things, and only one of them is a fact about the world. Conflating them is how agentic commerce gets miscounted.

A facilitator verifies a signed x402 payment and submits it on-chain, so the seller never touches a blockchain and the buyer never needs gas.

x402 turns HTTP 402 Payment Required into a working payment flow, so software can buy an API call without a card, an account or a human.

The on-chain marker everyone counts predates x402 and is produced by unrelated systems. The actual discriminator is who relayed the transaction.

Spec support and live settlement are different claims, and the gap between them is where most of the confusion lives. Here is what each one means.

The buyer signs but never broadcasts, so the facilitator pays the gas and prices it in. That single design choice is why agents can hold one asset.

Not because of the issuer. Because it implements the one token function that lets a buyer pay with a signature and no gas token.

Trackers reported figures from thousands of dollars to billions for the same protocol in the same year. Six specific differences explain almost all of it.

The payment travels as one base64 header on an ordinary retry, and the receipt comes back the same way. Here is what is inside both.

One scheme charges a fixed price agreed before the work, the other authorises a ceiling and settles for what was used. The choice changes who carries the risk.

Coinbase CDP, thirdweb, PayAI, Cloudflare and self-hosting are the live options. They differ most in chain coverage, replay handling and what happens when they are down.

x402 moved from a Coinbase project to a Linux Foundation body in April 2026. The practical effect is on what can change under you, and how fast.

Base is where x402 launched and where its deepest history sits. What that history is worth depends entirely on which band of it you count.

Solana took the larger share of x402 transaction activity through 2026 while Base held the cumulative lead. Both are true, and the difference is instructive.

A 402 response carries its own price list. Each entry in the accepts array is a complete offer, and two of its fields are where most integrations go wrong.

Independent research in 2026 found five classes of problem, two in the protocol's use and three in implementations. All have mitigations and most are cheap.

Version 2 generalised the network and asset fields so non-EVM chains stopped being a special case. Most v1 integrations keep working, but two assumptions in them break.

ACP structures agent-driven checkout with real merchants on card rails. x402 prices a single HTTP request. The split is retail against infrastructure.

AP2 proves a person authorised a purchase. x402 moves the money. They solve different halves of the same problem and compose rather than compete.

Keys work when the buyer will integrate deliberately. x402 works when the buyer found you a moment ago. Most APIs should offer both, in that order.

L402 used HTTP 402 with Lightning years before x402 existed. Comparing them shows which design choices were about the chain and which were about the buyer.

MPP launched with Tempo in March 2026 and does the same job through Stripe's rails. The choice is between an open settlement layer and a payments company's stack.

Subscriptions bundle risk and reward predictability. Per-call pricing unbundles both. For a product whose buyer may be software, the bundle stops working.