What is an RPC endpoint and how does it work

02 September 2026

A Remote Procedure Call, or RPC, is a way for one program to ask another program to run a function and return a result. You already use this pattern constantly. When your phone requests a weather forecast, it sends a message to a server, the server runs a query, and sends back the temperature. That is an RPC under the hood. The "remote" part means the code executing the function lives on a different machine. The "procedure call" part is just the old name for what we now call a function or method.

Blockchain RPC endpoints work the same way, but the remote machine is a blockchain node. A node is a computer running client software that maintains a full copy of the ledger. You connect to that node over the internet, send it a structured request, and it responds with data or executes a state change on your behalf. The endpoint is the URL where that node listens for calls.

The standard protocol for blockchain RPCs is JSON-RPC. It uses JSON as its message format. A request has four fields: jsonrpc (always "2.0"), method (the function name), params (an array of arguments), and id (a number or string you choose to match the response). The response echoes your id and includes either a result field or an error object.

Here is a concrete example. Suppose you want to check the balance of an Ethereum address without sending a transaction. The method is eth_call. It simulates a message call against the node's current state and returns the result. Your request might look like this:

{
 "jsonrpc": "2.0",
 "method": "eth_call",
 "params": [
 {
 "to": "0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18",
 "data": "0x70a082310000000000000000000000003b3d3b3d3b3d3b3d3b3d3b3d3b3d3b3d3b3d3b3d"
 },
 "latest"
 ],
 "id": 1
}

The to field is the contract address. The data field packs the function selector for balanceOf(address) plus the address you are querying. "latest" tells the node to use the most recent block state. The node executes the call - no gas is consumed, no transaction is broadcast - and returns a hex-encoded 256-bit integer as the balance.

That lifecycle is the same for every JSON-RPC call. Your client constructs a payload, sends it over HTTP or WebSocket to the endpoint, the node processes it against its local state database, and sends back a JSON response. If something fails - a malformed parameter, a missing method, a node that is not synced - the error field will tell you why.

Understanding what you are connecting to matters. A modern blockchain node is split into two layers. The execution layer handles transaction processing, smart contract execution, and state storage. That is where eth_call runs. The consensus layer handles block validation, attestations, and fork choice. It speaks a different protocol, often a separate JSON-RPC namespace with methods prefixed beacon_. Some endpoints expose both layers on the same port. Many do not.

When you debug a failed request, the first question is which layer you hit. If you call eth_call and get a "method not found" error, the endpoint likely serves only the consensus layer. If you call eth_getBalance and get a stale result, the execution layer node may be behind the network head. If you get a timeout, the node might be overloaded or your network path is broken.

RPC endpoints are not interchangeable. Different node implementations support different methods. Geth, Nethermind, Besu, and Erigon each expose slightly different sets. Some endpoints are public and rate-limited. Some require an API key. Some are private and serve only a specific application.

The endpoint itself is just a URL. Usually it looks like https://eth-mainnet.example.com or wss://eth-mainnet.example.com. The scheme tells you the transport: HTTP for single requests, WebSocket for persistent connections where the node can push new data to you. The path after the hostname sometimes includes a version string or an API key.

You do not need to run a node to talk to the chain. You need an endpoint. That endpoint is someone else's node. It could be provided by a wallet, a dApp, an infrastructure service, or the chain's foundation. The quality of that endpoint - its uptime, its latency, its support for the methods you need - determines whether your request succeeds or silently fails.

There is no magic to RPC. It is a remote function call. The node executes it, you get the result. When you understand the request format and the two layers inside the node, you can read an error message and know where to look.

Back to rpc & nodes