Quick Start

TheRPC is a managed JSON-RPC provider that gives you fast, reliable access to the Avalanche C-Chain without running your own node. Developers building on Avalanche use it to ship quickly against ecosystem protocols like Trader Joe, Aave, and GMX while relying on the C-Chain's roughly one-to-two-second finality under Snowman consensus. This guide takes you from zero to a working call in a few minutes: get a key, point your code at the endpoint, and read the latest block height with eth_blockNumber.

Step 1: Get an API Key

Sign up for a free account at TheRPC.io, then open the Dashboard. Navigate to the API Keys section and either create a new key or copy an existing one. The key is a unique secret string tied to your account and plan. You will append it to the Avalanche C-Chain endpoint — https://avalanche.therpc.io/YOUR_API_KEY — and send it in the Authorization header on every request.

Step 2: Choose Your Network

TheRPC supports many networks, each at its own endpoint, and switching between them is just a matter of changing the URL. For the Avalanche C-Chain, set your endpoint to https://avalanche.therpc.io/YOUR_API_KEY and keep your API key alongside it. The snippet below stores both in environment variables so the rest of your code can reference them without hardcoding secrets.

Step 2: Choose Your Network

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

Step 3: Make Your First Call

Now make your first call to the Avalanche C-Chain. Below are three ways to fetch the latest block number — with curl, JavaScript, and Python — each pointed at your endpoint and key. Pick the one that matches your stack; for the full set of languages and SDKs, see the All Methods reference.

Using Curl

1curl --request POST https://avalanche.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://avalanche.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://avalanche.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

For anything beyond simple reads, Web3 libraries are the better choice over raw HTTP calls. They handle ABI encoding and decoding, transaction signing, gas estimation, and event parsing for you, which is essential when interacting with C-Chain contracts like Trader Joe or Aave. They also manage retries and connection reuse out of the box. See the All Methods reference for full language-specific coverage.

Web3.js (JavaScript)

1const Web3 = require('web3');
2const web3 = new Web3('https://avalanche.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://avalanche.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 complete list of methods supported on the Avalanche C-Chain lives on the All Methods page. Each entry includes a description of what the method does, its request and response formats, copy-paste code examples, and the common use cases it serves — so you can move from this quick start to building real features without guessing at parameters.

Network Selection

Each network TheRPC hosts has its own dedicated endpoint, and you select a network simply by choosing the right URL. For the Avalanche C-Chain, that URL is https://avalanche.therpc.io/YOUR_API_KEY for HTTP and wss://avalanche.therpc.io/YOUR_API_KEY for WebSocket. Swap in your key and you are connected to chain ID 43114.

Next Steps

• All Methods — browse every JSON-RPC call available on the Avalanche C-Chain.
• Basic Operations — common reads like balances, transactions, and contract calls.
• Authentication — secure your API key and learn the Bearer header in depth.
• Rate Limits — understand quotas and how to stay within them.
• API Overview — the architecture, formats, and method categories at a glance.