> ## Documentation Index
> Fetch the complete documentation index at: https://goldrush.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# JSON-RPC Overview

> Multi-chain JSON-RPC endpoints with multi-provider failover, archive depth, debug, and trace.

GoldRush JSON-RPC gives you raw, uniform JSON-RPC access to every chain GoldRush supports: EVM chains and Solana. On EVM chains it is drop-in compatible with `viem`, `ethers`, `web3.js`, and `web3.py`, with archive depth, `debug_*`, and `trace_*`. On Solana it speaks the full Solana JSON-RPC and WebSocket subscription protocol, drop-in compatible with `@solana/kit`, `@solana/web3.js`, and `solana-py`.

> [!NOTE]
>
> GoldRush JSON-RPC uses the **same API key** as your other GoldRush products. No new account, no second dashboard.

## What is JSON-RPC?

JSON-RPC is the standard remote-procedure-call protocol that blockchain nodes expose. A client sends a JSON request naming a method (e.g. `eth_getBalance`, `eth_call`, `getAccountInfo`) with its parameters, and the node returns a JSON result. An **RPC endpoint** is the URL you send these requests to, and an **RPC node** is the server (an Ethereum, EVM, or Solana node) that answers them. Wallets, indexers, and dapps talk to chains almost entirely through JSON-RPC.

Running your own node to serve JSON-RPC is operationally heavy, so most teams use a hosted RPC endpoint instead. GoldRush JSON-RPC is one such endpoint, with multi-provider failover and archive depth, described next.

## What is GoldRush JSON-RPC?

A JSON-RPC interface in front of a smart router that fronts multiple independent upstream providers. GoldRush continuously collects analytics per `(provider, chain, method)` triple, including success rate, p50/p95 latency, error class, and cost. Each incoming call is routed to the provider that currently scores best on the cost/performance frontier for that chain and method. Failed providers are demoted automatically and re-probed on a backoff.

```
                       ╔═ GoldRush Edge ════╗
                       ║                    ║░            ╔═════════════════╗
╔══════════╗           ║   ╔══════════════╗ ║░            ║ Best upstream   ║░
║ Your App ║░ ──API──▶ ║   ║ Smart Router ║ ║░ ──route──▶ ║ provider for    ║░
╚══════════╝░          ║   ╚══════════════╝ ║░            ║ (chain, method) ║░
 ░░░░░░░░░░░░          ║                    ║░            ╚═════════════════╝░
                       ╚════════════════════╝░             ░░░░░░░░░░░░░░░░░░░
                        ░░░░░░░░░░░░░░░░░░░░░░
```

The result: lower p99 latency than any single provider, no single-vendor dependency, and a uniform error surface across chains and node software.

## What you get

* Pay-per-call from your GoldRush credits
* Archive depth (full historical state)
* `debug_*` and `trace_*` namespaces
* Sub-100ms p50 latency from regional edge POPs
* 99.9% production SLA
* Suited for explorers, indexers, wallets, and production apps

## What's supported

* **10 mainnet networks at launch**: Ethereum, Polygon, BNB Smart Chain, Arbitrum, Base, HyperEVM, MegaETH, Monad, Tempo, and Solana
* **EVM methods** across the `eth_*`, `net_*`, `web3_*`, `debug_*`, and `trace_*` namespaces
* **Solana methods**: the full account, block, transaction, token, slot, network, and inflation method set, plus WebSocket subscriptions (`accountSubscribe`, `logsSubscribe`, `programSubscribe`, `signatureSubscribe`, …)
* **Drop-in compatibility** with `viem`, `ethers`, `web3.js`, `web3.py` (EVM) and `@solana/kit`, `@solana/web3.js`, `solana-py` (Solana), plus raw `fetch` and `curl`
* **Header-based authentication** so your API key never appears in URLs, server logs, or copy-pasted endpoints

See [supported chains](https://goldrush.dev/docs/goldrush-json-rpc/supported-chains.md) for the full chain list. Each chain page enumerates its methods by category in the sidebar.

## JSON-RPC vs Foundational API

> [card] JSON-RPC
>
> Raw, untyped, opcode-level access. You compose calls. Best for: building wallets, indexers, simulators, and anything that needs the lowest level of node access.

> [card] Foundational API
>
> Decoded, typed, multi-chain REST endpoints (token balances, NFT metadata, USD pricing, transaction histories). Best for: dashboards, agents, anything that consumes already-enriched data.

The two products use the same API key. Use them together: JSON-RPC for primitives, Foundational API for the heavy lifting.

## Next steps

> [card] [Quickstart](https://goldrush.dev/docs/goldrush-json-rpc/quickstart.md)
>
> Make your first call in under a minute.

> [card] [Authentication](https://goldrush.dev/docs/goldrush-json-rpc/authentication.md)
>
> How to attach your API key to requests.

> [card] [Supported chains](https://goldrush.dev/docs/goldrush-json-rpc/supported-chains.md)
>
> Which networks are live.

> [card] [Migrating from another provider](https://goldrush.dev/docs/goldrush-json-rpc/migrating-from-other-providers.md)
>
> Side-by-side diffs against Infura, Alchemy, and Ankr.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.