On this page
- Protocol
- JSON-RPC 2.0 over HTTPS (requests) and WebSocket (subscriptions)
- Public endpoint
https://api.mainnet-beta.solana.com, rate-limited, not for production- Reads
- Accounts, balances, token accounts, transactions, blocks, slots
- Writes
- sendTransaction and simulateTransaction
- Freshness
- You choose: processed, confirmed or finalized
- History
- Limited on ordinary nodes; old data needs an archive node
What an RPC node is
Solana validators produce blocks. An RPC node is a machine that follows the chain without voting, keeps the current state in memory, and answers questions about it over the network. "RPC" means remote procedure call: you send the name of a method and its parameters, the node runs it and sends back the result. An RPC endpoint is just the URL of such a node, usually with your API key in it.
Nothing about an RPC is special to one app. Your wallet uses one to show your balance; an explorer uses one (plus its own database) to show a transaction; a bot uses one to send a trade. When an app "is down" while the chain is fine, the app's RPC provider is usually what failed.
Your first call
Every request is an HTTP POST with a JSON body. This one reads the SOL balance of an address from the public endpoint, with no key and nothing to install:
curl https://api.mainnet-beta.solana.com -H 'content-type: application/json' -d '{
"jsonrpc": "2.0", "id": 1,
"method": "getBalance",
"params": ["<a wallet address>"]
}'The answer has the same shape for every method: a context.slot saying how fresh the answer is, and a value.
{"jsonrpc":"2.0","result":{"context":{"slot":470672956},"value":2500000000},"id":1}Balances are in lamports: 1 SOL is 1,000,000,000 lamports, so the value above is 2.5 SOL. Several requests can be sent as one JSON array (a batch), which saves round trips; providers count each item in the batch against your limit.
The methods that matter
| Method | What it answers | Worth knowing |
|---|---|---|
getBalance | SOL held by an address | Lamports. Does not include tokens. |
getAccountInfo | The raw contents of one account | Ask for jsonParsed encoding and token mints and token accounts come back readable. |
getMultipleAccounts | Up to 100 accounts in one call | The cheapest way to refresh many balances or pools. |
getTokenAccountsByOwner | Every token a wallet holds | Heavy. Several free plans refuse it. |
getTokenSupply | Total supply of a token | Use with the mint address. |
getTokenLargestAccounts | The 20 largest holders of a token | Only 20. A full holder list needs an indexer. |
getSignaturesForAddress | Transactions that touched an address, newest first | At most 1,000 per call; page backwards with before. |
getTransaction | One transaction in full | Pass maxSupportedTransactionVersion: 0 or modern transactions are refused. |
getProgramAccounts | Every account owned by a program, filtered | The heaviest read there is. Often blocked or priced high. |
getLatestBlockhash | A recent blockhash to put in a transaction | A transaction built on it expires after about 150 blocks. |
simulateTransaction | What a transaction would do, without sending it | Returns logs and compute units used. |
sendTransaction | Submits a signed transaction | Returns the signature at once; that is not confirmation. |
The full list is in the Solana RPC reference.
Commitment: how sure do you need to be?
Almost every method takes a commitment. It trades speed for certainty:
| Level | Meaning | Use it for |
|---|---|---|
processed | The node has seen the block. It can still be dropped. | Live prices and feeds where a rare correction is fine |
confirmed | Two thirds of stake voted on the block. Reverting is very unlikely. | Most apps; showing a trade as done |
finalized | 31 or more confirmed blocks sit on top. It will not change. | Deposits, withdrawals, accounting |
The gap between processed and finalized is roughly thirteen seconds. Reading at finalized and wondering why your own transaction "is not there yet" is the most common beginner confusion.
Rate limits on the public endpoint
The public mainnet endpoint is run for testing, and its limits are per IP address. Solana's cluster page lists them, and they can change:
| Limit | Value |
|---|---|
| Requests per 10 seconds, all methods | 100 |
| Requests per 10 seconds, one method | 40 |
| Concurrent connections | 40 |
| New connections per 10 seconds | 40 |
| Data per 30 seconds | 100 MB |
Heavy methods are throttled much harder than that table suggests. While writing this page, one getTokenLargestAccounts call on the public endpoint came straight back as 429 Too many requests for a specific RPC call. For anything beyond a script, use a provider key: the free Solana RPC comparison lists what each free plan really serves.
Errors you will meet
| You see | It means | Do this |
|---|---|---|
| HTTP 429 | Rate limit: too many requests, or one heavy method | Slow down, batch, cache, or spread reads over providers |
| Transaction version (0) is not supported | You asked for a versioned transaction the old way | Add maxSupportedTransactionVersion: 0 |
| Node is behind / minimum context slot not reached | This node has not caught up to the slot you need | Retry, or try another endpoint |
| Blockhash not found / expired | The transaction was built on a blockhash that is too old | Fetch a new blockhash, sign again, resend |
null from getTransaction | Not confirmed at your commitment yet, or older than the node keeps | Retry at confirmed; for old history use an archive-capable provider |
| Method not available / requires a paid plan | The provider blocks that method on your plan | Route that method to a provider that serves it |
What an RPC cannot tell you
An RPC node answers questions about one account or one transaction quickly. It does not answer questions across the chain: "every wallet that bought this token in its first minute", "this wallet's profit on every coin", "all holders, sorted". Those need someone to have read every transaction as it happened and stored the result in a database. That job is called indexing, and it is the difference between an RPC provider and an analytics product. On-chain analytics explained walks through it.
HTTP or WebSocket
HTTP is ask-and-answer. To be told the moment something changes (an account's balance, a program's logs, a transaction's confirmation), open a WebSocket to the same host and subscribe. The Solana WebSocket tutorial has a complete working example.
Where BLIX fits
BLIX is not an RPC provider. It is a trading terminal that does the indexing for Solana memecoins and gives the result back as screens, and as JSON to accounts that want it: the BLIX API has 69 endpoints for launches, trades, holders, candles and wallets, which are exactly the across-the-chain questions a raw RPC cannot answer. If you need raw chain access, use an RPC. If you need "who holds this coin and who sold", that is a different tool.
More on Solana and on-chain data
This page is education about how the technology works. It is not financial advice, and nothing here recommends buying or selling anything.
Frequently asked questions
What is an RPC in crypto?
A remote procedure call endpoint: a server that follows a blockchain and answers requests about it. Wallets and apps use it to read balances and send transactions. On Solana it speaks JSON-RPC over HTTPS and WebSocket.
Is there a free Solana RPC?
Yes. The public endpoint needs no key but is tightly rate-limited, and several providers have free plans with a monthly allowance. The free Solana RPC comparison lists them with their real limits.
What is the Solana RPC URL for mainnet?
The public one is https://api.mainnet-beta.solana.com. Providers give you your own URL with a key in it, which is what an app should use.
Why does getTransaction return null?
Usually the transaction is not confirmed at the commitment you asked for yet, or the node no longer keeps a transaction that old. Retry at confirmed, and use an archive-capable provider for old history.
Do I need my own Solana node?
Almost never. Running one needs serious hardware and upkeep. A provider plan is cheaper until you are sending a very large number of requests or need custom streaming.

