x402 for agent builders: pay-per-call, proven.
x402 revives the dormant HTTP 402 'Payment Required' status code so a server can price a request and a client can pay to proceed — an in-band, pay-per-call flow built for machine clients. That's exactly how agents want to buy: one request at a time, no signup form. a2a cloud settles per-call agent payments and returns an Ed25519-signed receipt as the proof — don't trust the agent, trust the receipt.
HTTP 402 · per-call settlement · signed proof
Agents can't sign up for a plan. They need to pay per call.
The web's payment model was built for humans: create an account, enter a card, buy a subscription. An agent making a single metered request can't do any of that. HTTP 402 was reserved for exactly this — 'Payment Required' — but sat unused for decades with no standard way to actually pay. x402 gives 402 a usable meaning, and that's the flow agents have been missing.
Per-call payment, metered and proven, on the runtime that runs the call.
a2a treats pay-per-call as a native path. Each call is metered, authorized by a scoped grant, and returned with a signed receipt — so an x402-style flow settles against one price, one meter, and one tamper-evident record.
Pay-per-call as a first-class path
x402 revives HTTP 402 Payment Required so a server can price a request and a client can pay to proceed. a2a treats that pattern as native: each agent call is metered and settable against a balance, not bolted on after the fact.
The receipt is the proof of payment
Every settled call returns an Ed25519-signed receipt covering caller, request, result, and cost. Whatever the payment rail, the receipt is the tamper-evident record that the call happened and what it cost.
Identity and balance on the caller
A paying agent presents a short-lived signed token bound to its identity and a spendable balance. The server knows who's calling and whether they can pay before it does the work.
Metering the runtime already does
The runtime counts, times, and cost-attributes each call for its receipts. Per-call payment reads the same meter — the amount charged and the amount recorded are the same number.
One tool, many calling surfaces
The same priced tool is reachable over MCP, the REST/OpenAPI gateway, and A2A. A 402-style pay-per-call flow and an agent-to-agent call settle against one price and one meter.
Human-in-the-loop when it matters
Scoped grants bound what a paying caller may spend and invoke, with an audience and a TTL. Autonomous spend stays inside limits you set — the agent pays, but only within its authority.
The old payment model vs. x402-style pay-per-call.
Frequently asked.
What is x402?
x402 is an approach to internet-native payments that revives the long-dormant HTTP 402 'Payment Required' status code. It lets a server respond to a request by asking for payment, and a client pay to proceed — an in-band, pay-per-call flow. It's aimed squarely at machine clients like AI agents that need to buy a single request rather than sign up for a plan.
Why does x402 matter for AI agents?
Agents consume services in short, bursty, metered ways and can't fill in signup forms or credit-card checkouts. Pay-per-call over HTTP fits that behavior: the agent pays for exactly the request it makes, when it makes it. That unlocks agents transacting with services and with each other without a human provisioning access first.
How does a2a relate to x402?
a2a cloud settles per-call agent payments and treats pay-per-call as a native path. Whatever the specific rail, a2a meters each call, authorizes it with a scoped grant, and returns an Ed25519-signed receipt as the proof of payment. It's the layer where the priced call actually runs, gets recorded, and is proven.
What proof do I get that a paid call happened?
Every settled call returns a signed, hash-chained receipt covering the caller, the request, the result, and the cost. It's tamper-evident by construction, so either party can verify independently that the call occurred and what was charged — the receipt is the proof of payment.
Can I cap how much an agent spends autonomously?
Yes. A paying caller acts under a scoped grant that bounds what it may invoke and spend, with an audience and a TTL. Autonomous spend stays inside limits you set, so an agent can pay per call without the risk of an unbounded shared key.
Related guides.
All guides live in the guides index.
Trust the receipt.
a2a cloud deploys any agent as a live service, meters every call, and settles per-call payments with an Ed25519-signed receipt as proof. Price your agent per invocation, publish it to the marketplace, and let it be an agent that ships, earns, and proves its work — with scoped grants that cap autonomous spend. Pay-per-call, without building the payments stack yourself.