Which Chain for x402? Settlement Speed and Fees Compared

x402 is an open payment protocol from Coinbase, now a Linux Foundation standard, that revives the HTTP 402 "Payment Required" status code so an app or AI agent can pay for a single request in stablecoins (usually USDC) with no account, API key, or subscription. It is the rail behind agentic payments (also called agentic commerce): software paying software, per request, with no human in the loop. The chain it settles on decides how fast and how cheap each payment clears, so here are the four rails an x402 endpoint is most likely to use, compared on the two things that matter for pay-per-call: settlement finality and fee.

Characteristics sourced 2026-08-08 from each project's docs (cited below). See the note on what is documented vs measured before you rely on the finality figures.

The four x402 rails, side by side

Why the rail matters for x402

x402 traffic is unlike normal payments: it is high frequency, synchronous, and the amounts are tiny (the network average is about $0.30 a call). That shape rewards two things. First, a fee that rounds to nothing, because a cent of gas on a thirty-cent payment is a real tax once an agent makes thousands of calls. Second, finality you can trust instantly, because the server ships the paid data the moment the payment clears; if that settlement can still be reversed, so can the deal. Deterministic-finality chains close that gap cleanly; probabilistic ones are fast to confirm but reach hard finality a little later.

Why Algorand is the strongest technical fit for x402

Line up x402's actual needs against what each chain guarantees, and Algorand stands out for reasons that are engineering, not hype:

• Instant, deterministic finality (a 0-second finality delay). Every Algorand block is final the moment it is certified, about every 2.8 seconds, with no forks and no reorganizations. That is exactly what a synchronous x402 delivery wants: when the payment clears it is settled for good, so the server can hand over the data with zero reversal risk. Probabilistic chains confirm fast but reach hard finality later.
• A fixed fee that rounds to nothing. Every transaction costs 0.001 ALGO, a fraction of a cent, and it does not spike with congestion. Against a payment averaging about $0.30, the fee is noise, which is the whole point once an agent fires thousands of tiny calls.
• Throughput in the tens of thousands of TPS. Algorand has clocked a record of 14,722 TPS, is engineered to reach around 46,000 TPS, and the Algorand Foundation has proposed a roadmap toward 500,000 TPS. Because the fee is fixed, that capacity comes with predictable cost exactly when agent traffic spikes.
• Pedigree that is not marketing. Algorand was founded by Silvio Micali, an MIT professor and 2012 Turing Award winner who co-invented zero-knowledge proofs and verifiable random functions, primitives that now underpin much of modern blockchain cryptography. Algorand's pure proof-of-stake consensus uses that VRF work to stay leaderless and fork-free.

The honest catch: today Algorand has a smaller x402 footprint than Base or Solana. Coinbase runs its free first-party facilitators on Base, Solana and Stellar; on Algorand you go through the GoPlausible facilitator(which also covers Base and Solana). If your buyers already live in the Coinbase or Solana ecosystems, that pull is real. But measured purely on the properties x402 depends on, finality and fee, Algorand is the one built for the job, which is why our own measured benchmark (below) starts there.

Measured: Algorand USDC settlement

Here is the part that is actually ours. The finality figures in the table above are each chain's documented specs (sourced, cited). The number below we measured: we ran50 real USDC payments on Algorand mainnet and timed each one from submit to on-chain finality (on Algorand, the same instant, no reorgs). Raw run dated 2026-08-08.

And it is beautifully consistent. All 50 payments settled, and the times barely moved: median 5.20s, p95 5.27s, a spread of about 70 milliseconds from the middle to the tail. For an agent firing thousands of tiny calls, that predictability is a feature in its own right, you are not gambling on a slow tail. This is what "no forks, deterministic finality" looks like when you actually clock it.

Why it is ~5s and not the ~2.8s everyone quotes. The 2.8-second figure is Algorand's block time, how often the chain produces a new final block. That is the chain's heartbeat, not how long your payment takes. A payment you submit has to (1) wait for the next block to include it, then (2) be observed as confirmed on that block. It is not a round trip and it is not waiting for extra confirmations (Algorand blocks are final the instant they are produced, with no reorgs), you are simply crossing roughly two block boundaries between clicking send and seeing it settle. That is why the measured number lands near two block times. The block time is how fast the chain beats; the settlement time is what a payer actually waits, and only the second one matters for an x402 call. That gap, the marketing number versus the measured one, is exactly what this site exists to show.

Finality is not one thing. Each chain reaches it differently: Algorand is final the instant a block is produced; Stellar finalizes when a ledger closes (~5s); Solana needs about 32 slots of validator votes (~12s); Base is only truly final once it settles down to Ethereum (~15 minutes). So the two-blocks math above is Algorand's alone, not a universal rule, and you cannot read a chain's real settlement off its block-time spec. That is why we measure each chain to its own true finality, and why the Base and Solana rows will land differently when they fill in.

Settlement time is a property of the chain, not of where we measure from (unlike API latency), so the number travels. We run every x402 chain through the identical test, same sample count, same payment, same submit-to-final timing, so the comparison stays apples to apples. The 50 payments are sent sequentially, one submitted and confirmed before the next goes out, so each sample is a clean measure of a single payment's own settlement time, which is exactly what an x402 call experiences (one independent payment per request), not throughput under a burst. Firing all 50 at once would mostly test how the chain batches a flood into its next block or two, a separate throughput question we measure on its own in the x402 burst throughput benchmark. Base and Solana are next.

Proof, not trust: every payment was made from our benchmark account 4R34...LYPJI on Algorand mainnet, so you can open the block explorer and see the real transactions land. The raw benchmark JSON is published here, and mirrored under CC BY 4.0 in our public data repo, so the numbers on this page are verifiable end to end and free to reuse with attribution.

Trading on these chains rather than paying on them? The same four rails host active decentralized exchanges, see our best DEX by chain guide (Tinyman on Algorand, Jupiter on Solana, Aerodrome on Base, and Stellar's native order book).

Common questions

Sources

• x402 docs: network & token support
• Coinbase: introducing x402
• Algorand: x402 agentic commerce and the GoPlausible facilitator
• Cloudflare Monetization Gateway (x402 at the edge)
• Algorand Foundation: network throughput (record 14,722 TPS; ~46,000 TPS capacity; 500,000 TPS proposed)