Public Solana RPC URL: Everything You Need to Know

If you’re trying Solana for the first time, you can poke around using free public nodes to see how fast transactions confirm, how programming works, and what data lives on-chain.

In this article, we’ll break down Solana Public RPC. We’ll make a list of Solana Network RPC URLs for each cluster – Mainnet, Devnet, Testnet – and walk through real examples.

By the end, you’ll have an understanding of how to use public Solana endpoints, common pitfalls while using them, and when to switch to private RPC.

Public Solana RPC URLs list

1. Mainnet: https://api.mainnet-beta.solana.com
2. Devnet: https://api.devnet.solana.com
3. Testnet: https://api.testnet.solana.com

What is a public Solana RPC URL?

First, we need to understand RPC nodes – then we can discuss what an RPC URL in Solana is and what makes it public.

Solana blockchain is made up of many computers – nodes – working together. RPC node is a type of node that exposes interfaces, HTTP/S and WebSocket, so that external software can query it.

Any application (a wallet, a block explorer, or a DeFi app) needs a way to “ask” RPC servers for on-chain data like balances and to send transactions. Some of those nodes are publicly reachable; as long as you know their URL, you can send requests straight away.

So, a public Solana RPC URL is simply the network address (endpoint) of this accessible node that anyone with only an internet connection can use. What makes them public is:

• Using them doesn’t require any API token, whitelisting, or other credentials.
• Many of these endpoints are offered for free as a community good.
• They have fairly strict usage limits, slowing down or rejecting heavy users to keep access fair.

Solana Foundation, community projects, and RPC providers list these endpoints in their documentation. Anyone can look up “Solana public RPC” and find a published URL.

Purpose of Public RPC Nodes

Running a blockchain node requires significant disk space, bandwidth, and ongoing maintenance. We listed these requirements in our guide to full SOL nodes.

Public Solana RPC lets you skip all of that. This zero‐setup experience is hugely motivating for newcomers and beginner developers when learning how to:

• interact with Solana RPC endpoints,
• inspect accounts and transactions,
• deploy a simple program.

All Solana public RPC nodes are rate‐limited, since they are intended for experimentation and light usage. For production workloads, dedicated or private RPC servers are recommended.

Difference between Public and Private RPC URLs

The public RPC servers have to spread their computational resources among everyone who connects. Consequently, this translates into slower responses and unpredictable delays. By contrast, a private RPC URL is dedicated to you or your project.

Private vs public RPC latencies for Solana Mainnet as of June 9, 2025 / Source: CompareNodes

To illustrate, the chart above shows the median (p50) latency measured by our tests on the Solana’s public RPC, compared to private RPC providers’ results reported by CompareNodes (Europe region, getBalance method). As you can see, private RPCs can be significantly faster: GetBlock trimmed latency by roughly 50 % compared to the public endpoint.

In practice, you obtain a private RPC URL in one of two ways:

1. By running your own Solana node;
2. By using a dedicated RPC service.

For example, if you sign up for a Solana Mainnet RPC on GetBlock, you might receive an endpoint like:

https://go.getblock.io/<Access-Token>

Below is the table outlining the main differences between Solana public RPC vs private endpoints offered by providers like GetBlock.

Aspects	Public RPC URL	Private RPC URL
Access	Unauthenticated (anyone can connect)	Restricted (via API key or access token)
Maintenance	Handled by the Solana Foundation or the community	Fully managed by the provider
Rate Limits (RPS)	Strict	Configurable or unlimited
Cost	Free to use	Requires a subscription, free plan available
Performance	No uptime guarantee, higher latencies	Consistently low latency and higher throughput, often backed by SLA
Use Cases	Hobby projects, testing, early-stage development, low-volume scripts	Production-grade dApps, high-frequency trading, real-time analytics, enterprise systems

In summary, public RPCs are free but come with hard caps that can block you at inconvenient times. Private RPCs typically cost money, but that cost buys you guaranteed throughput, cushion for spikes, and configurable scaling – important for production or latency‐sensitive dApps.

List of available public Solana RPC URLs

Below are the “official” public RPC endpoints curated by the Solana Labs and the Solana Foundation. The teams run these purely for public use, with specific usage limits that we list as well.

Solana Mainnet RPC URL

Solana mainnet, while officially in beta state, is a fully functional production Solana blockchain where applications run and SOL tokens circulate. It is publicly accessible under the following URL:

https://api.mainnet-beta.solana.com

Here is the current set of limits for public mainnet nodes (Note that all limits are defined over a 10-second window, not per second):

• Total number of HTTP requests you can make: 100
• Max calls to the same RPC method: 40
• How many TCP/HTTP connections you may keep open simultaneously: 40
• Simultaneous subscriptions using the WebSocket “pubsub” interface: 5

All of the above numbers show limitations for Solana’s public endpoint users only. If you switch to private, enterprise-grade RPC, these numbers will be higher. For example, GetBlock’s most accessible Starter Plan ($39/mo) allows 25 RPS, equivalent to 250 requests per 10s, while private dedicated nodes have no caps.

Solana Devnet RPC URL

Solana’s Devnet is the testing environment that closely resembles the actual production network. It’s used for nearly every development- and testing-related scenario before you go live. SOL on Devnet is test SOL, completely separate from Mainnet, that can be requested via airdrops.

Access the Devnet network via its public JSON-RPC endpoint here:

https://api.devnet.solana.com

The current caps for public Devnet users, as queried directly from the node:

• RPS limit: 300
• Per-method limit: 200
• Connection limit: 200
• Pubsub limit: 50
• Airdrop limit: 1

Please note that these limits are also defined per 10 seconds and can change without notice.

Solana Testnet RPC URL

The Testnet of Solana is designed for network‐scale and validator testing in a production‐like environment. It helps validator operators and tooling developers see how new features or patches behave before they hit Mainnet. Test tokens used here also have no value outside the network.

The free RPC URL for Solana Testnet is:

https://api.testnet.solana.com

The nodes at this URL are currently configured with these limits (per 10 seconds):

• RPS: 50
• Per-method limit: 40
• Connection limit: 40
• Pubsub limit: 50
• Airdrop limit: 1

If “official” Solana’s public RPC servers are overloaded or offline, developers have alternative URLs. One example is CompareNodes’ list of free RPC endpoints backed by infrastructure providers and community projects.

How to use a Solana Public RPC URL

How you actually use a public RPC URL is by pointing your client at one of the endpoints from the list above. Below are the simplest methods to start using a public Solana RPC URL, including MetaMask integration.

Connecting to Solana RPC in development

Here are three common ways to connect to a public Solana RPC endpoint when you’re working in development (e.g., on Devnet).

Making a direct JSON-RPC call with cURL:

curl -X POST https://api.devnet.solana.com \
  -H "Content-Type: application/json" \
  -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "getLatestBlockhash",
        "params": []
      }'

With the Solana command-line tool (CLI), you have two options:

// 1. Apply an RPC endpoint globally:
solana config set --url https://api.devnet.solana.com
 
// 2. Specify it on the fly for a single command:
solana  --url 

Using Devnet in JavaScript (using @solana/web3.js):

const { Connection, clusterApiUrl } = require("@solana/web3.js");
 
const connectionDev = new Connection(clusterApiUrl("devnet"));
 
(async () => {
  const latestBlockhash = await connectionDev.getLatestBlockhash();
  console.log("Latest hash:", latestBlockhash);
})();

Once you’re comfortable here, you can move to Mainnet: just change "devnet" to "mainnet-beta" or use the provider’s private URL as in this example:

const { Connection } = require("@solana/web3.js");
  
const rpcUrl = "https://go.getblock.io/";
const connection = new Connection(rpcUrl);

Adding Solana RPC URL to MetaMask

MetaMask officially added native Solana support to its browser extension on May 27, 2025. Below are the steps to configure and use Solana within MetaMask.

Before starting, make sure you’re running v12.18 of the extension or newer; only the latest versions support the integration. Consider updating manually if needed.

To create a SOL account in MetaMask:

1. Open your wallet extension.
2. Open the account menu by clicking on your active account.
3. Select “Add account or hardware wallet”.

4. Under “Create”, choose “+ Solana account”. Give your new SOL account a name.
5. If prompted, pick one of your existing Secret Recovery Phrases (SRP).
6. Click “Create,” and there you have it – your new Solana address will show in the account selector.

As of now, MetaMask does not allow users to override the default public Solana RPC endpoint. If you need a higher-performance private RPC (for example, GetBlock’s), this feature is available for EVM chains.

Refer to our guide on switching an EVM network to GetBlock’s endpoints. Note: GetBlock’s free plan may be sufficient for this use case.

Best practices for using Public Solana RPCs

Below are several points to keep in mind when relying on Solana’s public RPC endpoints.

• Mind the rate limits: If you exceed limits, the endpoint returns a 429 status; best practice is to implement exponential backoff.
• Be conservative with heavy queries: All of the Foundation endpoints also impose data-transfer caps (100 MB/30s).
• Watch for increased latency: If you notice average response times creeping above 200 ms, the public nodes are under high load. Consider alternative URLs or upgrading to a private RPC.

Good practice is not to hard-code a single public RPC URL but maintain a list so that if one endpoint times out, the script fails over to the next URL.

Conclusion: When to move from public to private?

Public RPCs are what make Solana accessible because they let developers “magically” talk to the blockchain. As a beginner or one‐person project, you can immediately start reading chain data, sending transactions, and experimenting with smart contracts without devoting resources to infrastructure.

However, they are simply not designed for sustained, high-volume, or latency-sensitive scenarios.

Here are some signs your usage has outgrown public endpoints, and it’s time to switch to private RPC:

1. You’re hitting rate limits too often.
2. You need better stability: If your app needs < 50 ms latency, a private node is ideal.
3. You require archive data: If you need to fetch historical block data, public endpoints are not suitable. A private archive plan is required.

Overall, if you’re building a production-scale backend – an exchange, a big NFT marketplace, or a blockchain analytics service – you need guaranteed throughput, priority support, and advanced failover mechanisms. Private or dedicated RPC nodes can meet those requirements.

If any of the above sounds familiar, it’s time to upgrade. Don’t let performance bottlenecks hold you back – sign up for GetBlock now and get your custom, high-availability endpoint in minutes. Our Solana endpoints are also MEV-protected.