Bring your own provider keys. The RPC Plane binary adds intelligent multi-provider routing, slot-aware health scoring, circuit-breaker failover, write broadcast, and HTTP/3 — in front of Helius, QuickNode, Triton, Alchemy, and any JSON-RPC endpoint. One binary, one config file, no databases.
# Linux / macOS
curl -sSf https://rpcplane.dev/install.sh | sh
Swap your provider endpoint for http://localhost:9400. That's the whole integration. No SDK changes, no refactoring, no new dependencies — just failover, health scoring, slot-drift detection, and HTTP/3 on top of the providers you already pay for.
# before const conn = new Connection( "https://mainnet.helius-rpc.com/?api-key=..." ); # after — one line const conn = new Connection( "http://localhost:9400" );
Everything below ships in the free binary. Items marked coming soon are in active development.
Each read goes to the healthiest provider, scored in real time on latency, error rate, and slot freshness. Not round-robin, not random — a live ranking.
A per-provider circuit breaker opens on failure in under a second, probes for recovery, and resumes traffic automatically. No on-call rotation, no endpoint swaps at 2am.
Continuously tracks each provider's slot height against network tip. A provider can return HTTP 200 and still be 14 slots behind — RPC Plane sees it and deprioritizes it.
At ~400ms slot times, staleness is measured in fractions of a second. Drifting nodes are demoted before your application ever reads stale data from them.
sendTransaction fans out to every healthy provider in parallel — the transaction reaches a leader through whichever path is fastest, maximizing landing probability.
Your app stays on HTTP/1.1. The proxy speaks HTTP/3 (QUIC) to providers that support it — lower connection overhead and better p99, with zero client changes.
An exporter on :9401/metrics publishes health scores, slot drift, circuit state, failover counts, and request durations — scrape it straight into Grafana.
Edit rpc-plane.toml and changes apply within ~2 seconds — add a provider, retune routing, flip HTTP/3 — no restart, no dropped connections.
A single statically linked binary. No Postgres, no Redis, no queues, no orchestration. Drop it in a container or run it beside your service.
Periodically sample the same call across providers to catch when they disagree — identical request, divergent state — and demote the one serving stale data so routing steers around it.
Understands processed / confirmed / finalized and verifies providers actually respect the commitment level you asked for.
Set one line in your config. Writes always broadcast to every healthy provider regardless of strategy.
Stack the free tiers of Helius, QuickNode, and Alchemy with the keyless Solana Foundation public endpoint, point them all at RPC Plane, and weighted_random spreads traffic so no single key ever hits its limit. When one rate-limits, the circuit opens and reopens within seconds. Production-grade redundancy before you can justify a paid plan.
# four providers, $0/mo api.mainnet-beta.solana.com # no key Helius free tier QuickNode free tier # ~1 mo, then paid Alchemy free tier [routing] strategy = "weighted_random" circuit_cooldown_secs = 2
Two ways teams handle Solana RPC today — and where each one leaves you exposed.
The default setup: your app talks to a single RPC URL.
A retry loop that flips to a backup URL on error.
# Linux / macOS curl -sSf https://rpcplane.dev/install.sh | sh
rpc-plane init # writes rpc-plane.toml with # every option and its default
rpc-plane run # proxy on :9400 # metrics on :9401/metrics
NAME SCORE SLOT DRIFT LATENCY CIRCUIT -------- ------- ------------ ------ ---------- ------- provider-a 0.912 341892471 0 23.4ms closed provider-b 0.841 341892469 2 31.1ms closed provider-c 0.000 — — — open
Run it free forever. Add hosted visibility and zero-ops on top when you need them — same routing engine throughout.
The proxy. Your keys, your machine.
Hosted observability, cost analytics, and alerts. You run the binary; we host the dashboard.
We run the proxy too. Configure providers in the UI, zero ops.
Yes — free and source-available under the Elastic License 2.0. No per-request fees, no request or provider limits.
No. The binary runs on your machine and talks to your providers directly. No data custody; nothing leaves your infrastructure unless you opt in to the hosted dashboard.
No. Point your client at http://localhost:9400. Standard JSON-RPC means solana-web3.js, Anchor, the CLI, and bots all work unchanged.
Any HTTP JSON-RPC Solana endpoint — Helius, QuickNode, Triton, Alchemy, Chainstack, the public endpoint, and your own validators.
Yes. Single Rust binary, sub-millisecond routing overhead, Prometheus metrics, hot reload, per-provider circuit breakers. Run it as a sidecar.
Yes — write broadcast plus slot-drift demotion is built for landing transactions before the slot closes. See more →
Free, source-available, drop-in. One config file, one URL change.