Free-tier maxxing¶
Run RPC Plane at zero cost by stacking free and public endpoints. Each provider has a per-second or per-day request limit; spreading traffic across four of them means no single key ever sees enough load to hit its cap.
Providers¶
One endpoint requires no sign-up:
| Provider | URL | Notes |
|---|---|---|
| Solana Foundation | https://api.mainnet-beta.solana.com |
Public RPC operated by the Solana Foundation. Rate limited, no SLA. |
Three providers offer free tiers that require an account:
| Provider | Free tier | URL format |
|---|---|---|
| Helius | Developer plan | https://mainnet.helius-rpc.com/?api-key=KEY |
| QuickNode | Free endpoint (~1 month only, then paid) | https://your-endpoint.quiknode.pro/KEY |
| Alchemy | Free compute units | https://solana-mainnet.g.alchemy.com/v2/KEY |
Config¶
[health]
interval_ms = 2000
window_secs = 30
circuit_open_failures = 3 # open quickly when a key rate-limits
circuit_error_threshold = 0.4
circuit_cooldown_secs = 2 # RPS windows reset per-second; recover fast
[routing]
strategy = "weighted_random" # spread load evenly across all providers
max_retries = 3 # try all four before giving up
[[providers]]
name = "solana-foundation"
url = "https://api.mainnet-beta.solana.com"
weight = 1
max_rps = 10 # illustrative — set to your plan's documented per-second limit
[[providers]]
name = "helius"
url = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"
weight = 1
max_rps = 10
# http3 = true # opt-in QUIC; can help on a lossy home link, but no HTTP/2 fallback
[[providers]]
name = "quicknode"
url = "https://your-endpoint.quiknode.pro/${QUICKNODE_API_KEY}"
weight = 1
max_rps = 15 # heads up: QuickNode's free endpoint only lasts ~1 month, then it's paid
[[providers]]
name = "alchemy"
url = "https://solana-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}"
weight = 1
max_rps = 15
Save this as free-tier.toml or use the bundled example (examples/free-tier.toml):
export HELIUS_API_KEY=...
export QUICKNODE_API_KEY=...
export ALCHEMY_API_KEY=...
rpc-plane -c examples/free-tier.toml run
Why it works¶
weighted_random over failover_ordered
failover_ordered hammers the first provider until its circuit opens, then dumps all traffic on the second, and so on. This cycles through your quota fast. weighted_random distributes requests roughly evenly from the start so each provider stays under its limit.
circuit_cooldown_secs = 2
Free tier limits are typically enforced as requests-per-second or requests-per-minute windows that reset continuously. The default cooldown of 30 seconds leaves most of that capacity untouched. Setting it to 2 seconds lets the proxy recover and route to the temporarily-limited provider again as soon as its window resets.
max_retries = 3
With four providers, setting max_retries to N - 1 means every provider is tried before the proxy gives up and returns an error.
max_rps per provider
The circuit breaker is reactive — it only reroutes after a key has already started returning 429s. Adding a max_rps cap makes it proactive: once a provider is dispatching at its documented per-second limit it's treated as unavailable and load sheds to the others before the 429s start. Set each cap to the limit your plan actually publishes. It's a load-shedding hint, not a hard throttle — if every key is momentarily at its cap the proxy still forwards rather than dropping the request.
When to upgrade¶
This setup is ideal for development, side projects, and non-critical traffic. Free endpoints are rate-limited and carry no SLA, so for production workloads or anything latency-sensitive, add a paid provider as primary and keep the free stack as failover using failover_ordered.