prismRPCDocs

Quickstart

Three steps: create a key, point your client at the endpoint, make a call. There is no package to install and no configuration file.

1. Create an API key

Sign in on the dashboard and create a key. You get one key per environment by default - keep testnet and mainnet keys separate so a limit hit in staging never affects production.

Your endpoint is your key appended to the network host:

bash
# Mainnet
https://mainnet.prismrpc.co/v1/YOUR_API_KEY

# Testnet
https://testnet.prismrpc.co/v1/YOUR_API_KEY

Treat the URL as a secret. If a key needs to ship in browser code, origin-lock it and restrict it to read methods first.

2. Make a call

Any JSON-RPC client works. Here is the raw request:

bash
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":[]}'
json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1f4a2c"
}

The response is byte-compatible with what a Robinhood Chain node returns. Prism adds nothing to the body - routing information is carried in response headers instead.

3. Wire it into your app

With viem:

ts
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'] },
  },
  blockExplorers: {
    default: { name: 'Explorer', url: 'https://explorer.robinhoodchain.com' },
  },
});

const client = createPublicClient({
  chain: robinhoodChain,
  transport: http(),
});

const block = await client.getBlockNumber();

With ethers:

ts
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://mainnet.prismrpc.co/v1/YOUR_API_KEY', {
  chainId: 42088,
  name: 'robinhood-chain',
});

const block = await provider.getBlockNumber();

That is the whole integration. Every call from here is pooled across providers, retried when it is safe to retry, and measured.

What happens next

Behind that URL, each request is scored against every healthy upstream and sent to the fastest one. If a provider starts failing, its circuit breaker trips and traffic moves without your code noticing.

Do not build your own retry loop on top of Prism. Reads are already retried across providers. An outer retry loop multiplies your request count against your quota without improving success rates.

Next steps