A Solana RPC proxy that routes across every provider you already pay for. Bring your own keys — RPC Plane handles intelligent routing, slot-aware health scoring, and automatic failover.
# Linux / macOS
curl -sSf https://rpcplane.dev/install.sh | sh
Measured against a backend with a realistic ~20 ms provider RTT, 100 concurrent connections, 80,000 requests. Full conditions and caveats →
Solana RPC has fragmented into proprietary stacks — different caches, proxies, validator clients, and patches. Two providers can return different answers to the same request, and both report perfect health.
Provider returns data 14+ slots behind tip.
With 200 ms slots, staleness is measured in fractions of a second. Standard monitoring won't catch it.
Some getAccountInfo calls return stale balances.
Partial cache rot inside provider middleware — silent and selective.
4xx/5xx for 30 minutes during a config push.
Provider rolls a bad deploy. Your trading desk eats it until rollout completes.
Transactions accepted but never land.
sendTransaction returns OK; the leader never sees it. Legacy single-provider setups have no recourse.
Historical queries silently return incomplete data.
Slow block replay on the backend. The query succeeds. The data is incomplete.
Every getTransaction is now a line item.
Providers moved to per-call billing. Teams want to cut cost without cutting reliability — provider dashboards aren't built for that.
“Solana is lagging behind by >20K blocks due to RPC node provider issues.”
status.dune.com ↗“Service Solana RPC Pool seems to be down.”
status.phantom.com ↗“RPC service is experiencing intermittent issues due to high load… Blockchain itself is not impacted.”
@SolanaStatus ↗“Delays in SOL-related transfers due to the instability of some Solana RPC nodes.”
@okx ↗“Many dapps run their own RPC endpoints, and are not impacted by this Foundation service interruption.”
@SolanaStatus ↗RPC Plane runs locally alongside your application — speaking directly to provider endpoints with your credentials. Routing decisions are made at the application layer, so providers see normal client traffic.
# rpc-plane.toml — minimal config [[providers]] name = "provider-a" url = "https://rpc.provider-a.example/${PROVIDER_A_KEY}" [[providers]] name = "provider-b" url = "https://rpc.provider-b.example/${PROVIDER_B_KEY}" [[providers]] name = "provider-c" url = "https://rpc.provider-c.example/${PROVIDER_C_KEY}" [routing] strategy = "best_score" max_retries = 2
Route per request on real-time latency, error rate, and slot freshness at every commitment level. Not round-robin. Not random.
The novel differentiator. Periodically sample the same call across providers to catch when they disagree — identical request, divergent state. The provider serving stale data gets demoted in the health ranking, so routing steers around it. No existing product does this.
Per-provider circuit breaker — opens on failure, probes for recovery, resumes traffic automatically. No engineer wake-up needed.
Turn on broadcast_writes and sendTransaction goes to every healthy provider in parallel — maximizes landing probability.
Free and public endpoints keep days of history, not years, and answer older lookups with a quiet null. Mark one history = "recent" and that miss fails over to an archive provider instead of telling your app the transaction doesn't exist.
Give a key its plan's limit with max_rps and traffic sheds to a provider with headroom before the 429s start. Enough to stack nine free tiers into ~110 req/s.
The same reliability layer, tuned to four very different failure costs.
A transaction one slot late is a missed fill. Write broadcast and slot-drift demotion land it.
Read more →Balance APIs, history services, and notification workers all read from one provider. Automatic failover keeps a degraded provider invisible to every user at once.
Read more →Stale-but-200 data silently corrupts your dataset. Slot-aware scoring catches it.
Read more →You run RPC for everyone else. One binary instead of a failover layer you maintain forever.
Read more →The proxy stays free. The hosted dashboard adds visibility and alerts on top of the same routing engine — free during the beta. Managed cloud is on the way.
The proxy. Bring your own provider keys. Run anywhere.
Unified observability and cost analytics across every provider. We host the dashboard; you run the binary.
We run the proxy too. Configure providers in the UI. Zero ops.
Providers come and go. Pricing changes. Outages happen. Architectures diverge. The reliability layer persists.
The proxy is source-available and free to self-host. The hosted dashboard is in open beta — sign in with GitHub or Google to see provider health, cost analytics, and alerts across every provider.