Solana RPC latency benchmarks, June 2026: what the public endpoint actually costs you

Every Solana RPC provider claims to be fast. Few publish latency numbers by method, and most comparisons use synthetic tests from ideal network conditions. This is a set of real measurements from a production-adjacent setup, focused on the methods that actually bottleneck applications.

Methodology

Test date: June 22, 2026. Location: APAC (Singapore region). Network roundtrip to US-East endpoints adds roughly 150–180ms to absolute values; relative differences between providers remain valid. Samples: 12 requests per method per provider, sequential with no delay. p50 and p95 calculated from sorted sample arrays. Errors and timeouts (8s limit) counted as failures, not excluded.

Providers tested: Solana Foundation public endpoint (api.mainnet-beta.solana.com), Extrnode (solana-mainnet.rpc.extrnode.com), PublicNode (solana-rpc.publicnode.com). All three are accessible without API keys. Paid providers (Helius, QuickNode, Triton, Alchemy) require API keys and are addressed separately below.

Methods tested: getSlot, getLatestBlockhash, getBalance, getEpochInfo, getSignaturesForAddress (limit 10), and getTokenAccountsByOwner.

Test wallet: 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM. Same wallet for every provider to ensure comparable query cost.

The benchmark script is reproducible — see the appendix.

Results: basic methods

getSlot, getLatestBlockhash, getBalance, and getEpochInfo are lightweight reads that hit in-memory validator state. All three providers cluster tightly:

getSlot (p50 / p95 / min)              — 12 samples each
─────────────────────────────────────────────────────────────
Solana Foundation (public)   326ms / 1030ms / 301ms
Extrnode                     272ms /  526ms / 230ms
PublicNode                   360ms /  470ms / 322ms

getLatestBlockhash
─────────────────────────────────────────────────────────────
Solana Foundation (public)   315ms /  330ms / 296ms
Extrnode                     255ms /  319ms / 235ms
PublicNode                   350ms /  386ms / 319ms

getBalance
─────────────────────────────────────────────────────────────
Solana Foundation (public)   413ms /  524ms / 300ms
Extrnode                     263ms /  284ms / 239ms
PublicNode                   334ms /  405ms / 324ms

getEpochInfo
─────────────────────────────────────────────────────────────
Solana Foundation (public)   305ms /  354ms / 298ms
Extrnode                     296ms /  661ms / 238ms
PublicNode                   354ms /  395ms / 319ms

Takeaway: for transaction submission paths where you need a recent blockhash, or simple balance checks, all three free-tier options deliver similar performance. The Foundation public endpoint is not meaningfully slower for these methods — the 50–100ms difference is in the noise for most applications.

Results: indexing-heavy methods

The gap opens when queries require historical index lookups. This is where the Foundation public endpoint falls apart:

getSignaturesForAddress (limit: 10) — 12 samples each
─────────────────────────────────────────────────────────────
Solana Foundation (public)  1201ms / 2032ms / 1183ms
Extrnode                     265ms /  406ms /  205ms
PublicNode                   351ms /  527ms /  335ms

Raw samples — Solana Foundation:
1183 1185 1194 1196 1197 1198 1201 1205 1218 1272 1274 2032

Raw samples — Extrnode:
205 212 214 219 256 258 265 268 305 312 333 406

getTokenAccountsByOwner
─────────────────────────────────────────────────────────────
Solana Foundation (public)   527ms / 1595ms /  499ms
Extrnode                     265ms /  312ms /  214ms
PublicNode                   — (method unavailable on free tier)

getSignaturesForAddress on the public endpoint averages 4.5× slower than Extrnode (1,201ms vs 265ms p50) — and nearly 6× slower at p95 (2,032ms vs 406ms). For any app that displays transaction history — portfolio views, block explorers, activity feeds — this is the difference between a usable UI and a loading spinner.

getTokenAccountsByOwner shows similar divergence: the Foundation endpoint p95 hits 1,595ms; Extrnode holds at 312ms. PublicNode returned errors on this method at the free tier.

What this means in practice

The core pattern: methods that hit in-memory validator state are fast everywhere; methods that hit historical indexes diverge massively. The Foundation public endpoint runs on the Agave validator's bundled RPC, which was not designed for indexed historical lookups at scale. Third-party providers that run separate indexing infrastructure absorb that cost.

Concretely, if your app calls getSignaturesForAddress on page load, you are adding over 1 second of latency for every user on the public endpoint — for free, with no retry logic, and with p95 exceeding 2 seconds. Switching to any free third-party node cuts that to 265–350ms. Switching to a paid provider cuts it further.

Paid providers: what the published numbers say

We didn't benchmark Helius, QuickNode, Triton, or Alchemy directly — their endpoints require API keys. But the Triton team published benchmark data for Superbank (RPC 2.0) against the public endpoint at p50:

Published Triton/Superbank benchmarks vs public RPC (p50)
─────────────────────────────────────────────────────────────
getSignaturesForAddress    245ms → 50ms   (5× faster)
getSignatureStatuses     1,885ms → 49ms  (38× faster)
getTransaction             460ms → 138ms  (3.3× faster)

Source: Triton, June 2026

Triton's Cloudbreak module (account reads) similarly publishes: getProgramAccounts averages 205ms vs ~2,488ms on Agave (P90: 278ms vs ~6,583ms) — up to 20× faster.

Combining our free-tier data with Triton's published RPC 2.0 numbers, the full latency stack for getSignaturesForAddress looks like:

Solana Foundation public (our test)   ~1,200ms p50
PublicNode free tier (our test)         ~350ms p50
Extrnode free tier (our test)           ~265ms p50
Triton Superbank RPC 2.0 (published)     ~50ms p50

Range: 24× between public endpoint and RPC 2.0

Why the public endpoint underperforms on historical methods

The Agave validator RPC bundles historical data access with the consensus process. getSignaturesForAddress requires scanning a LedgerStore (RocksDB) that isn't optimised for address-keyed lookups — the validator has to iterate, filter, and sort. Third-party providers maintain separate indexes (typically PostgreSQL or ClickHouse) keyed exactly for these queries, which is why they respond in 200–350ms where the public endpoint takes 1,200ms.

This is the structural problem RPC 2.0 is solving: Cloudbreak and Superbank are purpose-built indexed stores, separated from the validator entirely, with query performance that reflects purpose-built design rather than bolted-on indexing.

Recommendations by use case

• Transaction submission only (no history, no token queries). The Foundation public endpoint works. p50 under 400ms for getLatestBlockhash and sendTransaction is acceptable for many apps. Rate limits will bite you at scale.
• Free tier with indexing needs. Extrnode outperformed PublicNode across every method we tested and is the fastest free option in these benchmarks. Note that free tiers vary in rate limits and uptime guarantees.
• Production apps with transaction history. Any paid provider (Helius, QuickNode, Triton, Alchemy) will materially outperform free-tier options on indexing-heavy methods. Based on published numbers, Triton's Superbank is the fastest available for historical queries.
• getProgramAccounts at any scale. Do not use the public endpoint. p90 reportedly exceeds 6,500ms on Agave's bundled RPC. Cloudbreak (RPC 2.0) cuts that to 278ms p90.

Limitations

These results reflect one test location (APAC), one wallet, and a single point in time. Network conditions and provider load vary. Absolute latency numbers from US-East or EU locations will be 150–200ms lower across the board; relative performance differences should be similar. The free-tier results may not reflect paid-tier performance on the same provider — Extrnode and PublicNode both offer paid dedicated nodes with different SLAs.

Helius, QuickNode, Triton, and Alchemy were not directly tested. Their performance will be addressed in a follow-up when API keys are available for a controlled comparison.

Appendix: benchmark script

// Run with: node bench.mjs
const ENDPOINTS = {
  'Solana Foundation': 'https://api.mainnet-beta.solana.com',
  'Extrnode':          'https://solana-mainnet.rpc.extrnode.com',
  'PublicNode':        'https://solana-rpc.publicnode.com',
}

const METHODS = [
  { name: 'getSlot',              body: { jsonrpc: '2.0', id: 1, method: 'getSlot', params: [] } },
  { name: 'getLatestBlockhash',   body: { jsonrpc: '2.0', id: 1, method: 'getLatestBlockhash', params: [] } },
  { name: 'getBalance',           body: { jsonrpc: '2.0', id: 1, method: 'getBalance', params: ['<wallet>'] } },
  { name: 'getSignaturesForAddr', body: { jsonrpc: '2.0', id: 1, method: 'getSignaturesForAddress', params: ['<wallet>', { limit: 10 }] } },
]

async function bench(url, body, n = 12) {
  const times = []
  for (let i = 0; i < n; i++) {
    const t0 = performance.now()
    try {
      const r = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(body),
        signal: AbortSignal.timeout(8000),
      })
      const d = await r.json()
      if (d.error) { times.push(null); continue }
      times.push(Math.round(performance.now() - t0))
    } catch { times.push(null) }
  }
  const v = times.filter(t => t !== null).sort((a, b) => a - b)
  return {
    p50: v[Math.floor(v.length * 0.5)],
    p95: v[Math.min(Math.floor(v.length * 0.95), v.length - 1)],
    min: v[0],
    raw: v,
  }
}

for (const [name, url] of Object.entries(ENDPOINTS)) {
  for (const m of METHODS) {
    const r = await bench(url, m.body)
    console.log(name, m.name, 'p50:', r.p50 + 'ms', 'p95:', r.p95 + 'ms')
  }
}

References

• Solana RPC 2.0 and the RPC Working Group — Cloudbreak and Superbank benchmarks
• Solana RPC providers compared — methods, streaming, and pricing
• Triton — Introducing Superbank (benchmark source)
• Triton — Introducing Cloudbreak (benchmark source)