Ethereum

Ethereum

Quick Start

TheRPC gives you a hosted JSON-RPC endpoint for Ethereum mainnet so you can read state, watch blocks, and broadcast transactions without running your own geth or erigon node. Developers reach for it to skip the sync, storage, and uptime work of self-hosting and still talk to chain 1 over the standard protocol their tools already speak. This guide takes you from no account to a working eth_blockNumber response in a few minutes: get a key, point your environment at the Ethereum endpoint, and fire the first call in curl, JavaScript, or Python.

Step 1: Get an API Key

Sign up at TheRPC.io, then open the Dashboard and head to the API Keys section to generate a key or copy an existing one. The key is a single opaque string that becomes part of your endpoint URL — it takes the place of YOUR_API_KEY in https://ethereum.therpc.io/YOUR_API_KEY and is also sent as a Bearer token in the Authorization header. The same key works across every network TheRPC serves, so you only do this once.

Step 2: Choose Your Network

TheRPC serves many networks, and each has its own hostname. For Ethereum mainnet you want ethereum.therpc.io. Set the endpoint and your key as environment variables so the rest of your code stays clean and the key never gets hardcoded. If you later need a testnet, the only thing that changes is the host — the request format and key stay the same.

Step 2: Choose Your Network

1API_ENDPOINT="https://ethereum.therpc.io/YOUR_API_KEY"
2API_KEY="YOUR_API_KEY"

Step 3: Make Your First Call

Below is the same eth_blockNumber call in three forms — curl, JavaScript with axios, and Python with requests — so you can run whichever matches your stack. It returns the current chain head as a hex string; decoding it confirms your key and endpoint are live. For other languages and richer client setups, see Tools & SDKs.

Using Curl

1curl --request POST https://ethereum.therpc.io/YOUR_API_KEY \
2  --header 'Content-Type: application/json' \
3  --header 'Authorization: Bearer YOUR_API_KEY' \
4  --data '{
5    "jsonrpc": "2.0",
6    "method": "eth_blockNumber",
7    "params": [],
8    "id": 1
9  }'

Using JavaScript

1const axios = require('axios');
2 
3const config = {
4  url: 'https://ethereum.therpc.io/YOUR_API_KEY',
5  apiKey: 'YOUR_API_KEY',
6};
7 
8async function getBlockNumber() {
9  const response = await axios.post(
10    config.url,
11    {
12      jsonrpc: '2.0',
13      method: 'eth_blockNumber',
14      params: [],
15      id: 1,
16    },
17    {
18      headers: {
19        'Content-Type': 'application/json',
20        Authorization: `Bearer ${config.apiKey}`,
21      },
22    },
23  );
24 
25  console.log('Latest Block Number:', response.data.result);
26}

Using Python

1import requests
2 
3config = {
4    'url': 'https://ethereum.therpc.io/YOUR_API_KEY',
5    'api_key': 'YOUR_API_KEY'
6}
7 
8def get_block_number():
9    response = requests.post(
10        config['url'],
11        headers={
12            'Content-Type': 'application/json',
13            'Authorization': f"Bearer {config['api_key']}"
14        },
15        json={
16            'jsonrpc': '2.0',
17            'method': 'eth_blockNumber',
18            'params': [],
19            'id': 1
20        }
21    )
22    return response.json()['result']

Step 4: Using Web3 Libraries

Raw HTTP is fine for a single call, but once you are encoding contract calldata, decoding return values, signing transactions, or managing nonces, a Web3 library does that work for you. ethers.js and web3.js in JavaScript, or web3.py in Python, handle ABI encoding, unit conversion between wei and ETH, and transaction building so you are not assembling hex by hand. See Tools & SDKs for full, language-specific setups.

Web3.js (JavaScript)

1const Web3 = require('web3');
2const web3 = new Web3('https://ethereum.therpc.io/YOUR_API_KEY');
3 
4// Add API key to requests
5web3.setHeader('Authorization', 'Bearer YOUR_API_KEY');
6 
7async function getBalance(address) {
8  const balance = await web3.eth.getBalance(address);
9  return web3.utils.fromWei(balance, 'ether');
10}

Web3.py (Python)

1from web3 import Web3
2from web3.middleware import http_retry_request_middleware
3 
4w3 = Web3(Web3.HTTPProvider(
5    'https://ethereum.therpc.io/YOUR_API_KEY',
6    request_kwargs={
7        'headers': {'Authorization': 'Bearer YOUR_API_KEY'}
8    }
9))
10 
11# Add retry middleware
12w3.middleware_onion.add(http_retry_request_middleware)

Available Methods

The All Methods page indexes every Ethereum JSON-RPC method TheRPC serves on chain 1, grouped by namespace. Each method has its own page with a description, the parameter and return tables, the error codes it can raise, a runnable request example, common use cases, and its CU cost. That is where you go once you move past eth_blockNumber into balances, logs, contract calls, or tracing.

Network Selection

Each network TheRPC supports has its own endpoint, distinguished by hostname. For Ethereum mainnet the URL is https://ethereum.therpc.io/YOUR_API_KEY over HTTP, with wss://ethereum.therpc.io/YOUR_API_KEY for WebSocket subscriptions. To target a different chain, you swap the host and keep everything else.

Next Steps

• All Methods — browse the full Ethereum method reference and find what you need next.
• Tools & SDKs — set up ethers.js, web3.js, web3.py, web3j, or another client for chain 1.
• Authentication — secure your key, rotate it, and read auth errors properly.
• Rate Limits — understand CU billing and how to stay within your plan's limits.
• Basic Operations — work through the everyday calls: balances, receipts, blocks, and contract reads.