One endpoint.
Every provider.
Zero downtime.
Prism RPC is managed RPC infrastructure for Robinhood Chain. Swap in one URL and your traffic is refracted across every major provider - with circuit breaking, automatic failover and live observability behind it.
Pooling capacity from
Alchemy
QuickNode
Ankr
Chainstack+ public Robinhood Chain nodesWhy Prism RPC?
A single RPC URL is a single point of failure. Robinhood Chain settles tokenized real-world assets - the endpoint underneath cannot be the weak link.
One provider, one fate
- A single provider rate-limits you the moment volume spikes
- One upstream outage takes your whole app down with it
- Latency drifts by region and you find out from users
- Failed reads need retry logic you have to write yourself
- No shared view of which upstream is actually healthy
Every provider, one URL
- Requests pooled across every major provider on one URL
- Circuit breakers isolate a failing upstream in milliseconds
- Latency-aware routing always picks the fastest healthy node
- Idempotent reads retried automatically with jittered backoff
- Per-provider health, latency and error rates in real time
Light in, spectrum out
Four things happen between your call and the answer, and you configure none of them.
One beam in
Point your client at a single Prism URL. It speaks the same JSON-RPC that Robinhood Chain nodes do, so nothing else in your stack changes.
Refracted out
Each request is scored against every healthy upstream - latency, error rate, remaining quota - and sent to the one that will answer fastest.
Failures contained
A provider that starts timing out trips its breaker and leaves the pool. Traffic reroutes before your users notice, and probes let it back in when it recovers.
Everything observed
Every hop is measured. Per-provider latency quantiles, breaker state and success rates stream to your dashboard and to Prometheus.
Nothing to install
Prism RPC is a URL, not a package. It speaks standard Ethereum JSON-RPC, so viem, ethers, wagmi, Foundry and every other Arbitrum Orbit tool work unchanged. Change one string and you are pooled.
- No SDK, no lockfile churn, no version drift
- Works from browsers, servers, edge runtimes and CI
- Same request and response shapes as a bare node
- Leave at any time by pointing the URL back
curl https://mainnet.prismrpc.co/v1/YOUR_API_KEY \
-X POST \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
# {"jsonrpc":"2.0","id":1,"result":"0x1f4a2c"}import { createPublicClient, http, defineChain } from 'viem';
export const robinhoodChain = defineChain({
id: 42088,
name: 'Robinhood Chain',
nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
rpcUrls: {
default: { http: ['https://mainnet.prismrpc.co/v1/YOUR_API_KEY'] },
},
});
const client = createPublicClient({
chain: robinhoodChain,
transport: http(),
});
// Prism picks the fastest healthy provider for every call.
const block = await client.getBlockNumber();Everything a production endpoint owes you
The resilience work you would otherwise write, test and carry yourself - running on the other side of one URL.
Latency-aware routing
Four strategies, including a p50-weighted router that continuously re-ranks upstreams.
Circuit breakers
Per-provider breakers with half-open probing stop one bad node from cascading.
Automatic retries
Idempotent reads retried across providers with exponential backoff and full jitter.
Active health checks
eth_blockNumber probes every few seconds, plus block-height drift detection.
Rate-limit smoothing
Token buckets per provider keep you under every upstream quota at once.
Request deduplication
Identical in-flight reads collapse into one upstream call and fan the answer back out.
Response caching
Deterministic results - receipts, finalized blocks, chain ID - served from a shared cache.
WebSocket subscriptions
eth_subscribe with automatic reconnection and replay of your active subscriptions.
Prometheus metrics
Latency quantiles, breaker state and per-method success rates on a scrape endpoint.
Batch requests
Standard JSON-RPC batches, split across providers and reassembled in order.
Consistency guards
Reads pinned to a minimum block height so you never see a stale node go backwards.
Scoped API keys
Per-key method allowlists, origin locks and independent rate limits.
Pick how your traffic splits
Set a strategy per API key. Every strategy skips unhealthy upstreams automatically.
Latency-based
Ranks healthy upstreams by rolling p50 and sends each request to the current leader. Best for read-heavy apps.
Round robin
Even distribution across the pool. Predictable load, useful when every provider is on the same plan.
Weighted
You set the split - 70% primary, 30% backup - and Prism honours it while skipping unhealthy nodes.
Random
Uniform random selection. The lightest possible routing decision when every millisecond of overhead counts.
Ship on Robinhood Chain without RPC anxiety
Create a key, paste the URL, and let the pool absorb whatever the network does next.