The same cross-chain message can take 10 seconds or 25 minutes to deliver, depending on which chain you send it from and which messaging protocol you use. Same USDC value, same intent, roughly 150x difference in wall-clock time.
If you build anything cross-chain in 2026, the choice between Wormhole, LayerZero, Hyperlane, Axelar, and Chainlink CCIP is often made by trust preference, ecosystem alignment, or which SDK your team already knows. Rarely does it come down to actual measured performance, because independent latency data across all five protocols has been hard to find.
This post shares 24-hour rolling p50 medians for message delivery latency across all five, live from OpenChainBench — an open-source benchmark platform that probes each protocol continuously from three regions.
The finding that surprised me most: the dominant time cost is often the source chain's finality, not the messaging protocol itself. And the "fastest" protocol depends heavily on which source chain you route through.
What this benchmark measures
OpenChainBench runs a Go harness that observes each protocol's public delivery events. For each message, it computes:
- Source-chain observation time (when the source chain includes the message)
- Delivery time (when the destination chain confirms receipt for LayerZero, Hyperlane, Axelar, and CCIP, or when the protocol reaches signing quorum for Wormhole VAAs)
The delta is the latency. Every metric is:
- Sampled every 60 seconds
- Aggregated as a 24-hour rolling p50 median
- Published under CC BY 4.0 licensing
- Open source — the harness is public Go code on GitHub
No canary transactions, no synthetic traffic. Passive observation of live protocol usage. One consequence: routes with low traffic have smaller sample sizes and noisier percentiles. Sample sizes are visible on each live bench page.
Important caveat before comparing: four of the five protocols (Hyperlane, LayerZero, Axelar, CCIP) are measured end-to-end (source → destination). Wormhole is measured only up to VAA quorum (source → Guardian 13-of-19 signatures), because destination-side relay is caller-driven and not intrinsic to the protocol. So Wormhole numbers understate full user-facing latency — the true end-to-end for a Wormhole message is quorum time plus destination relay time.
Hyperlane: fastest end-to-end at 10-22 seconds
| Source chain | Delivery p50 (24h) |
|---|---|
| Celo | 10.0 s |
| Polygon | 10.3 s |
| BNB Chain | 10.3 s |
| Arbitrum | 10.5 s |
| Ink | 11.9 s |
| Unichain | 12.7 s |
| Sonic | 18.4 s |
| Avalanche | 22.5 s |
Live: openchainbench.com/benchmarks/hyperlane-message-latency
Hyperlane delivers in 10 to 22 seconds across all 8 measured source chains — the tightest range of any protocol here. Even the slowest chain (Avalanche at 22.5 s) beats the fastest chain on LayerZero, Axelar, or CCIP.
LayerZero: 26-48 seconds
| Source chain | Delivery p50 (24h) |
|---|---|
| Monad | 26.2 s |
| Robinhood Chain | 26.9 s |
| Arbitrum | 31.5 s |
| BNB Chain | 33.3 s |
| Avalanche | 34.4 s |
| Celo | 42.0 s |
| Sui | 45.0 s |
| Solana | 48.3 s |
Live: openchainbench.com/benchmarks/layerzero-message-latency
LayerZero delivers in 26 to 48 seconds — roughly 2 to 3 times slower than Hyperlane on comparable chains. Interesting anomaly: Arbitrum on LayerZero delivers end-to-end in 31.5 s, while Wormhole reaches quorum on Arbitrum in about 16 minutes (VAA-only, so the true Wormhole end-to-end is longer still). LayerZero's Ultra Light Node model uses different security assumptions than Wormhole's Guardian quorum, which explains the gap.
Wormhole: 5 seconds to 19 minutes (VAA quorum only)
Reminder: Wormhole's benchmark measures only source-side VAA finalization to 13-of-19 Guardian quorum. Destination-side relay adds more time and is caller-driven.
| Source chain | VAA finalization p50 |
|---|---|
| Sui | 4.6 s |
| Monad | 5.2 s |
| Berachain | 7.5 s |
| Polygon | 7.6 s |
| BNB Chain | 7.9 s |
| Avalanche | 8.5 s |
| Ink | 10.0 s |
| Injective | 12.5 s |
| Solana | 18.5 s |
| Moonbeam | 43.0 s |
| Ethereum | 14 min |
| Arbitrum | 16 min |
| Unichain | 18 min |
| Base | 19 min |
Live: openchainbench.com/benchmarks/wormhole-vaa-latency
Two very different behaviors emerge. Non-Ethereum-finality chains (Sui, Monad, BNB, Solana) reach quorum in single-digit seconds. Chains that inherit Ethereum L1 finality (Ethereum, Arbitrum, Base, Unichain) wait 14 to 19 minutes. This is not Wormhole's design — Guardians refuse to sign until the source-chain state is finalized on Ethereum L1, which takes approximately two epochs (~13 min).
Axelar: 40 seconds on fast chains, 15+ min on Ethereum L2s
| Source chain | Delivery p50 (24h) |
|---|---|
| BNB Chain | 40.6 s |
| Osmosis | 47.2 s |
| Polygon | 50.7 s |
| Avalanche | 64.3 s |
| Moonbeam | 95.1 s |
| Ethereum | 17 min |
| Arbitrum | 20 min |
| Base | 25 min |
Live: openchainbench.com/benchmarks/axelar-gmp-latency
Same pattern as Wormhole. Fast on non-Ethereum-finality chains, slow on Ethereum-inheriting L2s. Base at 25 minutes is the slowest end-to-end measurement in this dataset.
Chainlink CCIP: 75 seconds to 17 minutes
| Source chain | Delivery p50 (24h) |
|---|---|
| BNB Chain | 74.8 s |
| Solana | 82.2 s |
| Avalanche | 90.0 s |
| Monad | 92.0 s |
| Polygon | 13 min |
| Ethereum | 17 min |
| Robinhood Chain | 17.5 min |
| Optimism | 17.5 min |
Live: openchainbench.com/benchmarks/chainlink-ccip-latency
CCIP is the slowest of the four end-to-end protocols measured, even on fast chains. This reflects Chainlink's more conservative security model — CCIP uses two independent risk-management systems that add latency but reduce trust assumptions.
The finality-depth choice: Polygon as a case study
Same source chain, dramatically different delivery times depending on the protocol. Polygon illustrates this best:
| Protocol | Polygon delivery p50 |
|---|---|
| Wormhole (VAA quorum only) | 7.6 s |
| Hyperlane (end-to-end) | 10.3 s |
| Axelar (end-to-end) | 50.7 s |
| Chainlink CCIP (end-to-end) | 13 min |
Polygon has the same actual finality time regardless of who observes it. The variance comes from what each protocol chooses to wait for. Hyperlane accepts Polygon at a lower confirmation depth. CCIP waits for a much deeper confirmation before signing, trading time for security. This is a protocol-level design choice, not a chain property.
The takeaway for builders: even after picking your source chain, the protocol's finality-depth policy can multiply your delivery time by 100x. Fast finality is only fast if the protocol trusts it.
The finality tax
Across every protocol, a consistent pattern emerges: chains that inherit Ethereum L1 finality (Ethereum, Arbitrum, Base, Optimism, Unichain) impose 14 to 25 minutes of waiting time regardless of which messaging protocol you use.
This is not the protocol's fault. It is the source chain's finality guarantee.
If your dApp originates cross-chain messages from Base and users complain the bridge is slow, no protocol change will fix it. The wait is in Ethereum L1 finality. The only way to meaningfully reduce it is to originate the message from a chain with faster finality (Sui, Monad, BNB Chain, Solana, Cosmos-adjacent chains).
Conversely, choosing between Hyperlane, LayerZero, and Wormhole matters a lot on fast-finality chains where the messaging protocol itself becomes the bottleneck. On Sui, Wormhole reaches quorum in 5 seconds while other protocols take longer. On Celo, Hyperlane delivers end-to-end in 10 seconds while LayerZero takes 42 seconds. The differences compound depending on your source chain and the protocol's confirmation policy.
Which protocol should you use?
Based on this dataset, a rough decision framework:
Building on non-Ethereum-finality chains (Sui, Monad, BNB Chain, Solana, Avalanche, Cosmos-adjacent):
Hyperlane offers the tightest and fastest end-to-end latencies. Wormhole is competitive at the quorum step but the full end-to-end depends on destination-side relay. LayerZero is a middle option. Same-chain, cross-protocol deltas can be large (see Polygon above) — verify on the specific route you care about.
Building on Ethereum L2s that inherit L1 finality (Arbitrum, Base, Optimism, Unichain):
Protocol choice is largely irrelevant for speed — you'll wait 14-25 min for finality regardless. Choose based on trust assumptions, ecosystem alignment, or which chain you're bridging to.
Building on Ethereum L1:
Same as above — expect a 14-17 minute latency floor imposed by L1 finality.
Building on Cosmos-adjacent chains (Osmosis, Injective, Celo):
Hyperlane is fastest at 10 s on Celo. Axelar is native to Cosmos SDK but slower (47 s on Osmosis).
How to reproduce these measurements
OpenChainBench is fully open source. Every metric on the site is a Prometheus query against public data. You can reproduce any measurement locally.
For Wormhole VAA finalization, the data source is the public wormholescan indexer:
curl "https://api.wormholescan.io/api/v1/vaas?pageSize=100"
Each VAA row includes:
-
timestamp— source chain observation time -
updatedAt— when wormholescan first indexed the VAA as fully-signed
The delta is the VAA finalization latency. OCB polls this endpoint every 60 seconds and computes rolling p50/p90/p99 percentiles.
For the messaging protocols (Hyperlane, LayerZero, Axelar, CCIP), similar public event feeds exist. The Go harness for each is on GitHub, linked from each benchmark page.
Resources
- Full list of benchmarks: openchainbench.com
- Hyperlane message latency
- LayerZero message latency
- Wormhole VAA finalization
- Axelar GMP latency
- Chainlink CCIP latency
- Data license: CC BY 4.0
All figures reflect 24-hour rolling p50 medians as of publication. Live dashboards update every 60 seconds — current numbers may differ. Each live dashboard is the authoritative source at any given moment.
If you're building cross-chain and want a specific data point I didn't cover, ping @openchainbench on X or check the live dashboards directly.
Top comments (0)