A reliability layer for Solana RPC across heterogeneous providers

Your provider is up. Your data is wrong. We fix that.

Website · Docs · Get the binary

RPC Plane is a smart proxy that makes multi-provider Solana RPC resilient. You bring your own provider keys — it adds intelligent routing, health scoring, automatic failover, and slot-aware validation. One URL change, everything gets better.

Your App → http://localhost:9400 → ┌─ Helius     (your key)
                                   ├─ QuickNode  (your key)
                                   ├─ Triton     (your key)
                                   └─ self-hosted validator (optional)

Swap your provider URL for http://localhost:9400. No SDK changes. No refactoring. No new dependencies.

Providers report 99% uptime — but "uptime" measures HTTP 200, not correctness. Slot drift, stale account data, partial cache corruption, and write-path degradation are all 200s. Two providers can return different answers to the same request while both report healthy. RPC Plane sits above your providers as the neutral intelligence layer that restores reliability.

• Intelligent routing — per-request decisions based on real-time latency, error rate, and slot freshness. Not round-robin.
• Automatic failover — circuit breaker trips in under a second and routes traffic away. No 2am page.
• Slot drift detection — continuously tracks each provider against network tip; deprioritizes drifting nodes before your app notices.
• Write broadcasting — fan out sendTransaction to every healthy provider to maximize landing probability.
• HTTP/3 upgrade layer — your app speaks HTTP/1.1 to the proxy; the proxy speaks HTTP/3 (QUIC) to providers that support it. Free latency, zero code changes.
• Zero infrastructure — single binary, single config file. No databases, no Redis.

Teams where RPC reliability is revenue:

• Trading bots — broadcast sendTransaction to every healthy provider and skip the ones that are slots behind. Higher landing rates without touching your transaction logic.
• DeFi protocols — cross-provider health scoring catches stale state before it reaches your contracts.
• Indexers & data pipelines — detect the provider that's silently 14 slots behind instead of ingesting bad data.
• Wallets & consumer apps — automatic failover so a provider outage never becomes your outage.

Already running Helius + QuickNode for redundancy? You're paying for two providers but using one at a time and failing over by hand. RPC Plane makes both active — routing to the healthiest one per request.

It scales all the way down, too: point a few free tiers plus the keyless public endpoints at RPC Plane and you've got a redundant stack for $0/month to start.

curl -sSf https://rpcplane.dev/install.sh | sh
rpc-plane init      # generate a starter config
rpc-plane run       # start the proxy

Then point your app at http://localhost:9400. That's it.

Minimal config (rpc-plane.toml):

[[providers]]
name = "helius"
url  = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"

[[providers]]
name = "quicknode"
url  = "https://your-endpoint.quiknode.pro/${QUICKNODE_API_KEY}"

[[providers]]
name = "triton"
url  = "https://your-pool.rpcpool.com/${TRITON_API_KEY}"

Prefer containers? Pull the image from GHCR:

docker run -v $(pwd)/rpc-plane.toml:/etc/rpc-plane.toml ghcr.io/rpcplane/rpc-plane

• Docs — docs.rpcplane.dev — configuration reference, routing strategies, observability
• Website — rpcplane.dev
• Releases — prebuilt binaries for Linux & macOS (x86_64 + aarch64)
• Docker — ghcr.io/rpcplane/rpc-plane