x402 Under Load: Burst Throughput, per Chain
Our settlement benchmark times one x402 payment at a time. This one asks the opposite question: when a burst of agent payments hits a chain at once, does finality stay fast, does the fee stay flat, and does every payment still settle? That is what decides whether agentic commerce holds up when traffic spikes.
We fired real micropayment bursts at six chains and timed every one to true, irreversible finality (the moment a seller can safely release the goods). Measured: Avalanche, Algorand, Stellar, XRP, Solana and Base (real USDC on all six). More chains are next.
The results, all six chains at a glance
| Chain | Finality | Block time | Time (total) | Burst | Block capacity (spec) | Fee / payment | Burst cost |
|---|---|---|---|---|---|---|---|
| Avalanche · AVAX | deterministic | ~2s | ~1.6s | 500/500 | ~1,000 / block | ~$0.0006 | ~$0.31 |
| Algorand · ALGO | instant | ~2.8s | ~5.2s | 500/500 | ~25,000 / block | 0.001 ALGO | ~$0.04 |
| Stellar · XLM | deterministic | ~5s | ~5.6s | 100/100 | ~1,000 / ledger | ~$0.00001 | < $0.01 |
| Ripple · XRP | deterministic | ~4s | ~6.2s | 100/100 | ~6,000 / ledger | ~0.00002 XRP | < $0.01 |
| Solana · SOL | probabilistic | ~0.4s | ~14.4s | 500/500 | ~20,000 / block | ~0.000005 SOL | ~$0.19 |
| Base | probabilistic | ~2s | ~15-20 min | 500/500 | ~8,000 / block | ~$0.0007 | ~$0.35 |
Block capacity is each chain's documented maximum transactions per block or ledger (a published spec, verified 2026-08-24, not a FillBench measurement): Algorand ~25,000 (5 MiB blocks), Solana ~20,000 (100M compute units per block), Base ~8,000 and Avalanche ~1,000 (400M / 40M gas per block read live from mainnet, ~50k gas per USDC transfer), XRP ~6,000 per ledger (~1,500 TPS), and Stellar ~1,000 operations per ledger. On the non-serialized chains one wallet can fill the block up to this ceiling; Stellar and XRP order a single wallet by sequence number (Stellar caps one wallet at 1 payment per ledger). Through our single free RPC we actually landed far fewer under a burst (about 30 on Algorand, 46 Avalanche, 50 Base per block), a realistic single-endpoint number, not the chain ceiling. Every payment moved a dust amount of USDC between accounts we own, so ~$0 of value moved, the burst cost is only network fees. For what a single Solana payment actually costs (the fixed base fee, priority fees, and USD), see our Solana transaction fees breakdown.
Read the finality column first. The number that counts for x402 is time to TRUE, irreversible finality. Algorand and Stellar reach it deterministically in ~5s, their fast confirmation already IS final. Solana we time to the finalized commitment (~14s), not the ~1-2s reversible confirmed status. Base is the trap: it confirms in a blazing ~0.3s (Flashblocks), but that is soft and reversible, hard Ethereum L1 finality is ~15-20 min behind (we measured the finalized-block lag). Fastest to look paid, slowest to truly finalize.
Speed is one axis. For the things we cannot benchmark but that still matter for a payment rail, whether a chain has ever gone down and whether it is quantum-ready, see our sourced uptime and quantum-resistance comparison across the same six rails.
What each chain does under a single-wallet burst
- Avalanche: Snowman consensus finalizes an accepted block deterministically (no reorg), so the ~1.6s receipt IS true finality, with no soft-confirm caveat. One wallet bursts like Base (EVM nonces): all 500 settled, up to 46 per block, flat sub-cent fee.
- Algorand: Fired all 500 truly at once; every one landed on the first pass (up to 30 in a single block, median 26 across 20 blocks), fee flat, finality held near 5s.
- Stellar: Sequence numbers cap one wallet at 1 payment per ~6s ledger. Many different wallets still settle in parallel; the limit is per wallet, not the network.
- Ripple: Sequence numbers serialize one wallet (like Stellar), so a burst drains an ordered queue, not 500 at once. All 100 settled first try, finality held ~6s, flat sub-cent fee. A free public node fair-use-caps submission, so the per-ledger count is a floor, not the true XRPL ceiling.
- Solana: The free RPC would not take 500 at once (429s), so we paced them and resubmitted drops until all 500 settled to true finality.
- Base: Fastest to confirm (~0.3s via Flashblocks) but slowest to be irreversible: hard Ethereum L1 finality is ~15-20 min behind (we measured the finalized-block lag). One wallet packs ~50 per 2s block.
The caveat that keeps this honest: the "max per block or ledger" column is about one wallet firing a burst, the artificial thing our test does. Real x402 traffic comes from many different wallets, and then all six settle in parallel at each chain's finality speed. Stellar and XRP are the ones whose chain design serializes a single wallet (both use sequence numbers), and even so they settle each payment among the fastest. One narrow axis, not a verdict.
Proof, not trust. Every payment is real and on-chain, from our benchmark accounts, with raw JSON published under CC BY 4.0: Avalanche 0x2FaA...A7d1 ↗ raw JSONAlgorand 4R34...LYPJI ↗ raw JSONStellar GCAW...GEGO ↗ raw JSONRipple rPFn...NANW ↗ raw JSONSolana AJCU...4k2K9 ↗ raw JSONBase 0x2014...7F35 ↗ raw JSON
Why concurrent load matters for x402
x402 exists so software can pay per request with no human in the loop, which means demand is bursty and parallel in a way human checkout never is. One agent working a task can fan out into many paid API calls at once; a single popular endpoint can be hit by thousands of agents in the same second. On a chain that clears those in a tight window the endpoint just works. On one that queues them, latency climbs, some payments fail, and on a gas-market chain the fee can spike right when volume does. Per-call latency tells you the calm-day experience; behavior under a burst tells you what happens on the busy one.
How this differs from our settlement benchmark
Two different questions, kept separate on purpose. The x402 settlement benchmark sends payments sequentially, one confirmed before the next, to isolate a single payment's own finality time. This page fires them all at once to test capacity under contention. A chain can look great on the first and still strain on the second, which is exactly why both are worth measuring.
What is next (once the RPC bill stops laughing at us)
At scale, the only thing that capped a single wallet was the free public RPC, not the chain. The next upgrade is a dedicated node per chain, which would let us fire a 1,000-payment burst and finally publish an honest payments-per-second ceiling instead of an IOU. The catch: a dedicated RPC is a monthly bill, and these benchmarks already run on one trader's card. So if the tip jar below buys the node its coffee, the 1,000-burst (and more chains) land that much sooner.
Common questions
What is the x402 throughput (burst) benchmark?
It measures how a blockchain behaves when many x402 payments arrive at once, rather than one after another. We fire a burst of real USDC micropayments and record, under that load, how long each takes to reach true finality, whether every payment settles, whether the fee moves, and how many one wallet can land per block. The same test runs on every chain so the results compare apples to apples.
Why measure concurrent payments and not just one at a time?
Because agentic commerce is concurrent by nature. A popular x402 endpoint can receive payments from many agents at once, and a single agent orchestrating a task may fire dozens of micropayments in parallel. A chain that settles one payment quickly can still buckle under a burst, with latency blowups, failed transactions, or fee spikes. Throughput is the dimension the one-at-a-time settlement test does not capture.
Why does Base show ~15-20 min when it confirms in 0.3 seconds?
Because those are two different things and only one of them is finality. Base is an optimistic rollup: its sequencer confirms a payment in about 0.3 seconds (via Flashblocks), which looks instant, but that is a SOFT, reversible acknowledgement. The payment is not truly irreversible until its batch settles to Ethereum L1, which we measured as a ~20 minute lag behind the chain head. For x402, where a seller releases the goods on payment, the number that counts is that hard finality. So Base is the fastest chain to look paid and the slowest to actually be unreversible. We report the ~0.3s soft confirm and the ~15-20 min true finality separately, and never dress the soft number up as settlement.
Can one wallet fire a burst, or is it serialized?
It depends on the chain, and it is the biggest hidden difference. Algorand has no per-account nonce, so one wallet fires many payments that land together in a block. Solana is similar (recent-blockhash, not a nonce). Base uses EVM nonces, so a wallet is ordered, but the mempool queues them and the sequencer packs dozens per block, up to ~50 in our run. Stellar and XRP are the exceptions: a strict sequence number serializes one wallet (Stellar to one payment per ~6s ledger; the XRP Ledger applies consecutive sequences, so it packs several per ~4s ledger). Crucially this is a per-wallet limit, not a network limit: real x402 traffic is many different wallets, which all settle in parallel. The only chains where we hit a ceiling on one wallet at scale were capped by the free RPC endpoint, not the chain.
Which chains are measured, and what is next?
Avalanche, Algorand, Stellar, XRP, Solana and Base are all measured on mainnet, from the same us-east box, with on-chain proof and raw data published under CC BY 4.0 (real USDC on all six). Time to true finality: Avalanche ~1.6s, Algorand ~5.2s, Stellar ~5.6s, XRP ~6.2s, Solana ~14.4s, Base ~15-20 min (its 0.3s confirm is soft). More chains are next, measured the same way. Subscribe below to get each result as it lands.
Get each throughput result as it lands
We measure x402 burst throughput across Avalanche, Algorand, Stellar, XRP, Solana and Base (real USDC on all six), with more chains next. Get each chain's numbers, with on-chain proof, the moment they publish. No spam, unsubscribe anytime.