RPC Plane

Solana RPC proxy with intelligent multi-provider routing, automatic failover, and slot-aware health scoring. A single binary that sits between your app and your RPC providers.

Your App → http://localhost:9400 → [Helius / QuickNode / Triton]

Quick start

# 1. Download the binary
curl -sSf https://rpcplane.dev/install.sh | sh
2. Generate a config
rpc-plane init
3. Add your provider URLs and run
rpc-plane run

Your app replaces its provider URL with http://localhost:9400. No other changes needed.

What it does

• Routes reads to the healthiest provider based on latency, error rate, and slot freshness
• Optional write broadcasting: set routing.broadcast_writes = true to fan out sendTransaction to all healthy providers — maximizes landing probability
• Circuit breaker per provider: opens on failure, probes for recovery, resumes traffic automatically
• Slot tracker: tracks slot height across providers, deprioritizes drifting nodes
• Auto-retry on transient errors (429, 503, timeout) — tries the next-best provider
• Hot reload: edit the config file, changes apply without restart
• Prometheus metrics on :9401/metrics
• Zero infrastructure: single binary, single config file, no databases, no Redis

Install

Script (Linux / macOS):

curl -sSf https://rpcplane.dev/install.sh | sh

Manual download: grab the binary for your platform from GitHub Releases — Linux and macOS, x8664 and aarch64.

The Linux binaries are built against glibc 2.35 (Ubuntu 22.04). They run on Ubuntu 22.04+, Debian 12+, Amazon Linux 2023, and Rocky/RHEL 9+. For older systems (RHEL/Rocky 8, Debian 11), use the Docker image or build from source.

Each release includes a .sha256 checksum and a .cosign.bundle Sigstore signature. The install script verifies both automatically when cosign is installed; manual verification:

cosign verify-blob \
  --bundle rpc-plane-x86_64-unknown-linux-gnu.cosign.bundle \
  --certificate-identity-regexp '^https://github\.com/rpcplane/rpc-plane/\.github/workflows/release\.yml@refs/tags/v[0-9].*$' \
  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
  rpc-plane-x86_64-unknown-linux-gnu

Docker:

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

From source:

cargo install --git https://github.com/rpcplane/rpc-plane rpc-plane

Configuration

Minimal config (rpc-plane.toml):

[[providers]]
name = "helius"
url  = "https://mainnet.helius-rpc.com/?api-key=${HELIUSAPIKEY}"
[[providers]] name = "quicknode" url  = "https://your-endpoint.quiknode.pro/${QUICKNODEAPIKEY}"
[[providers]] name = "triton" url  = "https://your-pool.rpcpool.com/${TRITONAPIKEY}"

Run rpc-plane init to generate a full config with all options and their defaults.

See the configuration reference for every option.

Historical RPC analytics

Historical workload analytics is disabled by default. It is delivered as remote telemetry aggregates for the hosted dashboard and has no Prometheus surface, so it requires a configured [reporting] block. Add the block below to opt in to bounded analysis of getTransaction polling, result reuse, and slot age:

[historical_analytics]
queue_capacity = 512
maxqueuedbytes = 67108864
maxjobbytes = 2097152
state_capacity = 250000
statettlsecs = 172800
flushintervalms = 60000

Starting without [reporting] is a config error rather than a silent no-op: the analyzer would otherwise consume a worker, a queue, and retained fingerprint state while emitting nowhere.

queuecapacity, maxqueuedbytes, and maxjob_bytes bound queued analysis work; statecapacity and statettl_secs bound retained fingerprint state. Jobs that exceed these limits are dropped from analysis without affecting RPC responses. maxjobbytes must not exceed maxqueuedbytes, and all limits must be positive.

The analyzer does not cache or alter RPC responses and makes no additional RPC calls. Results are reported only as aggregate counts in the versioned historicalgettransaction_aggregate telemetry event; no historical metric is exposed on /metrics. It never exports raw signatures, addresses, request IDs, parameters, response bodies, or request fingerprints. Request state uses process-local keyed fingerprints; restarting RPC Plane changes the key and resets that state. These settings are restart-only and changes made by config hot reload do not take effect until the process restarts.

CLI

rpc-plane run        # start the proxy (default)
rpc-plane check      # validate config and test provider connectivity
rpc-plane status     # show live provider health (proxy must be running)
rpc-plane init       # generate a starter config file

rpc-plane --help
rpc-plane -c /path/to/config.toml run

Routing strategies

| Strategy | Description | |----------|-------------| | best_score | Route reads to the highest-scoring provider (default) | | weighted_random | Probabilistic selection by config weight × health score | | failover_ordered | Try providers in config order, skip open circuits | | parallel_race | Send to all healthy providers, return fastest success |

Writes (sendTransaction, simulateTransaction) always broadcast to all healthy providers regardless of strategy.

Observability

Health endpoint:

curl http://localhost:9400/health | jq

Provider status:

rpc-plane status 
  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.724   341892468       3      38.7ms     closed

Prometheus:

http://localhost:9401/metrics

Key metrics: rpcplanerequeststotal, rpcplanerequestdurationseconds, rpcplaneproviderhealthscore, rpcplaneslotdrift, rpcplanecircuitbreakerstate, rpcplanefailover_total.

Example configs

See the examples/ directory:

• helius-quicknode-triton.toml — standard three-provider setup (Helius, QuickNode, Triton One)
• single-provider.toml — single provider with health monitoring
• trading-bot.toml — write-path optimized for transaction landing

Deployment

Ready-to-apply manifests for Docker Compose, Kubernetes (shared Deployment and per-pod sidecar), Nomad, and systemd live in examples/deploy/. The deployment guide walks through each, including when to listen on a TCP port vs a Unix socket.

Architecture

See the architecture overview for how routing decisions are made.

License

Elastic License 2.0 — source-available; you can use, modify, and self-host. You can't offer it as a hosted/managed service to third parties.