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 six 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 six x402 rails, side by side

"Final" gets blurred together, so we keep three senses apart. Instant: irreversible the moment the block is produced, zero confirmations, no reorgs (only Algorand). Deterministic but not instant: irreversible once the round or block is accepted a second or few later (Avalanche, Stellar and XRP; Stellar's own docs pointedly avoid the word "instant"). Probabilistic: a fast confirmation that can still be reversed until hard finality lands later (Base, Solana). The "Instant finality?" row below answers only the first sense.

One thing the table makes plain: as of our latest run, Avalanche posts the fastest measured true finality of any rail here (~1.6s), ahead of Algorand's ~5.2s. That does not make it the automatic pick. Algorand's edge is a different shape: it is the only rail with 0-second instant finality, it has a 7-year zero-downtime record (Avalanche has had outages) and native post-quantum accounts, and its fee is fixed and never spikes. "Fastest measured" and "strongest all-round fit" are not always the same chain, which is exactly why we publish the whole table instead of a single winner. We compare uptime and quantum readiness across all six rails separately.

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 (we break down one chain's real per-transaction cost in the Solana transaction fees analysis). 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-10.

And it is beautifully consistent. All 50 payments settled, and the times barely moved: median 5.18s, p95 5.24s, a spread of about 60 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; Avalanche finalizes when Snowman consensus accepts a block (~1-2s, no reorgs); Stellar finalizes when a ledger closes (~5s); Solana needs about 32 slots of validator votes (~12.8s); XRP finalizes once its ledger is validated (~6s); 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, XRP included.

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. All six rails are now measured.

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.

The other rails are just as verifiable. Every payment came from a benchmark account you can open on a block explorer: Solana AJCU...4k2K9 ↗, Stellar GCAW...VGEGO ↗, and Base 0x2014...7F35 ↗. The raw JSON for each is published with the throughput results and mirrored under CC BY 4.0.

Measured: real end-to-end x402 through the GoPlausible facilitator

The number above is the settlement leg on its own. This is the whole x402 handshake. We stood up the resource-server side, built and signed a real Algorand USDC payment in the x402 exact scheme, and drove it through a live facilitator, GoPlausible, hitting its /verify then /settle endpoints exactly as a paid API would. 50 payments, Algorand mainnet, measured from the same us-east box as every other number here. Raw run dated 2026-08-10.

The finding worth the whole exercise: the facilitator says "paid" in about 1.17 s, but the payment is not actually final on-chain for another ~4 seconds. GoPlausible's /settle returns optimistically on submission, before the transaction is in a block, on 100% of our 50 payments. Acknowledging sooner is convenient, but it quietly shifts finality risk onto whoever trusts the ack: ship the paid resource the instant the facilitator returns and you are trusting a payment that is still ~4 seconds from being irreversible. Worth knowing, and not something the docs tell you.

The protocol is cheap; the chain is the floor. True end-to-end finality here is 5.32 s, essentially the same ~5.2s we measured for raw settlement. So the facilitator plus the full handshake add only about 1.17 s on top of Algorand's own finality: the facilitator does not make the chain faster, it just acknowledges sooner. Two independent measurements landing on the same ~5.2s is a good sign the numbers are real.

Trading on these chains rather than paying on them? The same 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)
• Finality specs behind the "Instant finality?" row: Algorand block finality (a block is final the moment it is produced, no forks, no reorgs) and Stellar (deterministic finality once a ledger closes, about 3 to 5 seconds; Stellar's own docs deliberately avoid the word "instant" and treat the ledger-close vote as its own step). Solana reaches its "finalized" commitment after roughly 32 slots (~12.8s); Base inherits Ethereum L1 finality, only truly final once its state settles down to Ethereum (~15 minutes).