Getting started

Every network is served at the same URL shape:

https://rpc.solidrpc.io/YOUR_API_KEY/evm/{chainId}

This is the only provider endpoint your application needs. SolidRPC selects qualified upstream capacity for the chain, method, and block range, monitors health, and moves requests to qualified capacity behind the same URL when a route degrades. See routing and failover for the operating model and migration plan.

The API is JSON-RPC 2.0 over HTTPS POST. There is no WebSocket endpoint, if you need new-block updates, poll eth_blockNumber instead of using eth_subscribe. Chain IDs for every supported network are on the networks page. Ethereum is 1, Base is 8453, and so on.

Create an account, no card required.

Every new account starts on the Free plan: 10K responses per UTC day, 2 RPC method calls/s (burst capacity 10 calls), and 1 API key. Paid plans currently start at $25/mo. See current pricing.

A Default API key is created for you the moment your account activates, find and copy it on the API Keys page in the dashboard. All keys on an account share the account's quota and rate limit. Extra keys (on paid plans) are for organizing projects and reading per-key analytics, not for extra throughput. The dashboard shows response-unit counts, success rates, and latency per key and per chain.

Keys are unrestricted by default, preserving the basic endpoint flow. Advanced users can optionally require a customer-signed Bearer JWT and apply source IP, network, method, or method-rate ceilings. See API key security before enabling a policy in production.

Fetch the latest block number on Ethereum. Replace YOUR_API_KEY with your key from the API Keys page:

curl https://rpc.solidrpc.io/YOUR_API_KEY/evm/1 \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

The raw JSON-RPC response looks like this:

{ "jsonrpc": "2.0", "id": 1, "result": "0x163d3a3" }

Send a JSON array and you get a JSON array back, one result per entry:

curl https://rpc.solidrpc.io/YOUR_API_KEY/evm/1 \
  -X POST \
  -H "Content-Type: application/json" \
  -d '[{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1},
       {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":2}]'

Each billable method call in a batch counts as 1 response unit against your quota and needs 1 rate-limit token. Batching saves round-trips, not money. In viem, enable batching on the transport, ethers v6 batches automatically by default.

import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http("https://rpc.solidrpc.io/YOUR_API_KEY/evm/1", { batch: true }),
});

• HTTPS POST only. GET requests are not JSON-RPC and are rejected.
• No eth_subscribe, there is no WebSocket transport. Poll instead.
• Request bodies are capped at 5MB.
• Standard methods get a 30s server-side budget; trace and debug methods get 45s. Set client timeouts to 60s or more, see tracing.
• Caching: head methods (eth_blockNumber, eth_gasPrice, anything at latest) are never cached. Responses for unfinalized blocks are cached for at most 10 seconds, finalized data is cached long-term. You never get a stale chain head.

The gateway uses a denylist, not an allowlist: read methods are never blocked, on any chain. What is blocked is node and consensus control, the namespaces admin_*, personal_*, miner_*, engine_*, clique_*, and les_*, txpool_*, plus any debug_* method outside this allowlist:

• everything matching debug_trace*
• everything matching debug_getRaw*
• debug_storageRangeAt
• debug_getBadBlocks
• debug_accountRange
• debug_getModifiedAccountsByNumber and debug_getModifiedAccountsByHash

A blocked method returns HTTP 200 with a JSON-RPC -32601 error and is never billed. Details in the error reference.

Quotas and rate limits are account-wide across all chains and keys. Full details on pricing and rate limits.