Quick Start

TheRPC gives you managed access to Solana's high-throughput cluster through a single authenticated endpoint, so you can query accounts, submit transactions, and stream real-time notifications without running your own validator or worrying about ~400ms slot cadence. Solana developers reach for it because the same JSON-RPC 2.0 surface they already know is served reliably over both HTTP and WebSocket PubSub, with commitment levels, SPL token reads, and base64/jsonParsed encodings fully supported. This guide takes you from zero to a working call in a few minutes: you'll grab an API key, point your client at the Solana endpoint, and read the current slot with getSlot using curl, JavaScript, or Python.

Step 1: Get an API Key

Head to TheRPC.io and create a free account. Once you're signed in, open your dashboard (your personal account cabinet) and go to the API Keys section, where you can generate a new key or copy an existing one. The key is an opaque token string — treat it like a password. You'll drop it straight into the Solana endpoint path, replacing the YOUR_API_KEY placeholder so every request is authenticated as soon as it reaches https://solana.therpc.io.

Step 2: Choose Your Network

TheRPC serves Solana mainnet-beta alongside the devnet and testnet clusters, so you can build and test against the same JSON-RPC surface before going live. To wire up your environment, store the Solana endpoint URL and your key as variables; the endpoint host stays the same while your key fills the path. For the rest of this guide we use the mainnet endpoint below, but you can swap in your devnet or testnet endpoint the same way.

Step 2: Choose Your Network

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

Step 3: Make Your First Call

Now make the call. Below you'll find the same request in three flavors — curl, JavaScript, and Python — so you can use whichever fits your stack; for the complete language and SDK coverage see the Tools & SDKs reference. Each example invokes getSlot, the simplest possible read, which returns the slot the cluster is currently processing. A numeric result back means your key works and you're talking to Solana.

Using Curl

1curl --request POST https://solana.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    "id": 1,
7    "method": "getSlot",
8    "params": []
9  }'

Using JavaScript

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

Using Python

1import requests
2 
3config = {
4    'url': 'https://solana.therpc.io/YOUR_API_KEY',
5    'api_key': 'YOUR_API_KEY'
6}
7 
8def get_slot():
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            'id': 1,
18            'method': 'getSlot',
19            'params': []
20        }
21    )
22    return response.json()['result']

Step 4: Using Solana Libraries

For anything beyond a one-off read, the official Solana libraries save you a lot of boilerplate. The @solana/web3.js Connection class and the Python solana-py Client handle request shaping, commitment defaults, lamports-to-SOL math, PublicKey parsing, transaction signing, and retries for you, so you don't hand-build JSON-RPC envelopes or juggle base64 encoding by hand. Point the client at your Solana endpoint once and call typed methods. See the Tools & SDKs documentation for full coverage across JavaScript, Python, Rust, and Go.

@solana/web3.js (JavaScript)

1import { Connection, PublicKey, LAMPORTS_PER_SOL } from '@solana/web3.js';
2 
3const connection = new Connection('https://solana.therpc.io/YOUR_API_KEY', 'confirmed');
4 
5async function getBalance(address) {
6  const lamports = await connection.getBalance(new PublicKey(address));
7  return lamports / LAMPORTS_PER_SOL;
8}

solana-py (Python)

1from solana.rpc.api import Client
2from solders.pubkey import Pubkey
3 
4client = Client('https://solana.therpc.io/YOUR_API_KEY')
5 
6def get_balance(address: str) -> float:
7    resp = client.get_balance(Pubkey.from_string(address))
8    return resp.value / 1_000_000_000  # lamports to SOL

Available Methods

When you're ready to go past getSlot, the All Methods page lists every Solana JSON-RPC method TheRPC supports — account and balance reads, SPL token queries, transaction submission and lookup, block and slot data, cluster and economics calls, and the WebSocket PubSub subscriptions. Each method's reference page carries a plain-language description, the exact request and response formats, runnable code examples, and typical use cases so you can copy a working call straight into your project.

Network Selection

Each Solana cluster — mainnet, devnet, and testnet — is reached through its own endpoint, so switching networks is just a matter of changing the URL while keeping the same key and request format. The HTTP endpoint follows the pattern https://solana.therpc.io/YOUR_API_KEY, and for real-time streaming the WebSocket PubSub endpoint uses the wss:// scheme at wss://solana.therpc.io/YOUR_API_KEY.

Next Steps

• All Methods — browse the full Solana JSON-RPC surface, from getAccountInfo to sendTransaction and the PubSub subscriptions.
• Tools & SDKs — set up @solana/web3.js, solana-py, solana-client (Rust), or solana-go for your language.
• Authentication — learn how to place and secure your API key in the endpoint path or Bearer header.
• Rate Limits — understand request weighting, backoff, and how heavy methods like getProgramAccounts are counted.
• Basic Operations — work through the everyday reads and writes: balances, transactions, blocks, and SPL tokens.