x402 inference billing: pay-per-call routing for AI agents

x402 inference billing meters each model call as a USDC micropayment, settled over HTTP at the moment the call happens, instead of drawing down a prepaid balance or a monthly API budget. The model name, the chosen provider, the price, and the payment all travel in the same request, and the agent pays from its own wallet without an account or an API key.

This is no longer a thought experiment. ClawRouter, an agent-native LLM router that settles calls in USDC over the x402 protocol, crossed 6.6k GitHub stars this month, and two adjacent projects shipped the same metering pattern. Per-call billing for inference has moved from idea to running code, so it is worth a clear-eyed look at how it works, where it earns its place, and where a plain monthly budget is still the right call.

What x402 inference billing actually is

x402 is an open standard from Coinbase that revives the dormant HTTP 402 Payment Required status code. When a client requests a paid resource, the server answers with a 402 that carries the price, the token, the destination wallet, and the chain. The client signs a stablecoin transfer, attaches the proof to a request header, and resends. A facilitator verifies the payment on-chain and the server returns the resource. The whole round trip settles in roughly two seconds, with no protocol fee.

Inference billing applies that handshake to model calls. Instead of one 402 in front of a generic API, a router prices each completion: it picks a model, computes the per-call cost, and demands payment for that exact call before streaming tokens back. The unit of billing becomes a single inference, not a monthly invoice.

If you want the wider standards picture (how x402 sits next to Google's AP2 and Stripe's MPP), we covered that in agentic payments: what x402, AP2 and MPP mean for builders. This article zooms into the narrower question of metering inference itself.

The handshake, call by call

The detail that matters for engineers: the wallet signature is the authentication. There is no signup, no key rotation, no shared secret sitting in an environment variable. ClawRouter generates a local BIP-39 wallet on first run and exposes an OpenAI-compatible /v1/chat/completions endpoint on localhost, so existing client code points at a new base URL and otherwise works unchanged. It routes across 55+ models from nine providers, prices calls from $0 (eight free NVIDIA-hosted models) up to about $0.105 for premium reasoning, and keeps USDC non-custodial in your wallet until a call spends it.

The problem it solves

The honest framing is narrow. Per-call billing fixes a real but specific set of problems, and pretending it replaces all API economics is how teams get burned.

The first is attribution. With a shared API key and a monthly bill, you know you spent $4,000 on a provider and almost nothing about which agent, task, or tenant caused it. A per-call payment is a discrete on-chain event tied to a wallet, so cost attribution is a property of the system rather than a logging afterthought.

The second is autonomy. An agent that runs unattended for hours cannot stop to ask a human to top up a balance or provision a key for a new provider. Wallet-signed payment lets it transact the moment it needs a model it has never used, which is exactly the kind of long-horizon operation that newer agents are built for (see Claude Fable 5 and the long-horizon agent problem).

The third is granularity. Card rails make sub-dollar charges uneconomic because interchange and minimums swamp the transaction. Stablecoin micropayments settle a $0.0003 call without that floor, which is what makes metering a single inference viable at all.

What the running code looks like

Three projects show the pattern at different layers. ClawRouter is the client-side router: it decides the model and pays for the call, aimed at agents that want to reach many models without managing keys. AIephant is a gateway that sits between apps and 320+ models across 50+ providers, and lets you publish agent capabilities as paid endpoints over x402 and MPP, so the payment surface is the gateway rather than each agent.

Covenant addresses the gap the other two leave open. x402 pays for access (a call returns a response, you pay). Covenant pays for work that needs verification: it locks USDC in a Solana program account, opens a 24-hour challenge window after the agent submits a result, and auto-releases payment if no one disputes, escalating to bonded arbitration when someone does. The slogan in its repo is precise: x402 powers paid access, Covenant powers paid work. If your agent's output needs to be checked before money moves, access-payment alone is not enough.

x402 itself is not a niche experiment. By March 2026 it had processed over 119 million transactions on Base and 35 million on Solana, with the Coinbase facilitator supporting Base, Polygon, Arbitrum, World, and Solana. Cloudflare and Coinbase formed an x402 Foundation, and Cloudflare's Agents SDK can now pay for resources and expose paid MCP tools over the protocol. The rails are real; the open question is whether your inference workload belongs on them.

The trade-offs, stated plainly

A per-call on-chain settlement is not free. Each call now carries a settlement step and its fee, plus the latency of signing and verifying a transfer. For a chat product fielding millions of cheap calls a day, paying and confirming on-chain per call can cost more in fees and milliseconds than the inference it guards. Aggregated billing exists precisely because batching is cheaper at volume.

There is also a sharper failure mode.

The discipline here is the same one any payments team learns the hard way: money movement needs idempotency keys, spend ceilings, and reconciliation, whether the rail is a card processor or a USDC wallet. The matching and integrity problems do not disappear because the payment is two seconds and on-chain. If anything, an autonomous payer raises the stakes, and the reconciliation thinking we use for payment engines applies directly to an agent's wallet ledger.

You are also taking on stablecoin operational surface: wallet custody and key handling, chain availability, and the price and settlement behavior of USDC on Base or Solana. None of that is exotic, but it is real infrastructure work, the same unglamorous plumbing we wrote about in shipping stablecoin rails without the pain.

When to reach for it, when not to

Reach for x402 inference billing when the agent is genuinely autonomous and must access models it was not pre-provisioned for, when per-task or per-tenant cost attribution is a hard requirement rather than a nice-to-have, or when you are a provider who wants to expose a model or tool as a paid endpoint without running accounts and billing. In those cases the wallet-as-identity model removes real friction.

Skip it when you run a fixed set of providers behind known keys, when your call volume is high and individual calls are cheap (aggregate billing wins on fees and latency), or when a simple monthly budget with alerting already answers every question you have about spend. Pay-per-call is a sharper instrument, not a strictly better one.

The pattern is early but no longer hypothetical, and the parts that will bite are the parts every payments engineer already respects: idempotency, spend limits, and reconciliation against a ledger you trust. If you are weighing agentic payments for a fintech or AI product and want a frank read on whether per-call settlement fits your workload, the team at CodeDecoders is happy to talk it through.