Solana RPC
What is Solana?
Solana is a high-performance L1 blockchain that combines Proof of History (PoH) with Proof of Stake (PoS) to achieve high throughput, low latency, and low transaction cost. It operates as a single global state machine, where all accounts and programs live on one shared ledger with consistent execution rules.
As of December 2025, blocks are produced approximately every 400 milliseconds with single-slot finality, and the network can process thousands of transactions per second under typical load.
Solana will be migrating to a next-generation consensus protocol named Alpenglow in early 2026. This protocol redesigns validator voting and data propagation to achieve deterministic, sub-second finality (targeting ~150ms).
Solana’s Sealevel runtime enables true parallel transaction execution by analyzing which accounts each transaction reads and writes. This parallelism keeps base transaction fees low (typically a fraction of a cent). When many transactions compete for the same account, users can optionally include a priority fee to have validators process their transactions first.
➡️ Solana Fundamentals Reference Guide
Building on Solana
Solana runs with one shared state for all programs and accounts. Every program you deploy can directly read, write, and coordinate with any other program through cross-program invocation (CPI) in a single atomic transaction. This makes it straightforward to plug into core on-chain services and the rest of the ecosystem using the same set of primitives.
Solana on-chain programs are typically written in Rust using frameworks built for Solana (C, C++, and other LLVM-compatible languages can also be used). Anchor offers helpers for accounts and instructions so you write less boilerplate while Pinocchio is a lean, no_std framework designed to optimize Solana programs and keep their size as small as possible.
For front-end development, libraries like Solana Kit, Kite, Gill, Umi, and Wallet Adapter provide higher-level APIs for managing accounts, building and sending transactions, and integrating with wallets.
Official and community SDKs exist for TypeScript/JavaScript, Rust, Python, Go, and other languages as well.
Core Concepts for Developers
Accounts
On Solana, everything is an account. Each account has:
- Owner: The program allowed to change its data
- Data: Serialized bytes your program defines
- Lamports: The account's balance of SOL
- Executable Flag: Executable accounts hold program code where non-executable accounts hold state.
➡️ An Introduction to the Solana Account Model
Accounts must hold a minimum lamport (the smallest unit of SOL) balance to stay "rent-exempt" and kept on-chain. Previously, Solana accounts could have rent deducted and eventually be reclaimed, but now all new accounts must be created with enough lamports to be rent-exempt from the start).
➡️ What is Rent on Solana and How to Calculate it
Programs (Smart Contracts)
Programs on Solana are deployed as stateless code stored in executable accounts. They do not keep data between calls. All state data lives in separate accounts that the program owns or receives as inputs.
Most programs are deployed with the BPF Upgradeable Loader, which lets you update a program after deployment as long as you control the upgrade authority. You can also make programs immutable by deploying them that way or revoking the upgrade authority later making the code permanent.
Solana ships with several native programs that handle core tasks like creating accounts and transferring SOL, staking SOL, and validator voting. Any custom programs you deploy for your application logic are invoked in a similar way from transactions and can be composed together.
Transactions
Transactions include an explicit list of all accounts they will read or write. The runtime uses this list to check permissions and to schedule work. Because it knows which accounts are read or written to, it can run transactions in parallel when their account sets do not overlap.
Solana organizes time into short windows called slots, and each slot has a chosen leader (a validator) from a rotating schedule. When your app sends a transaction, it connects to an RPC endpoint, which checks the transaction and forwards it into Solana’s Gulf Stream pipeline instead of a shared "mempool".
Because of this, RPC quality really matters. A good RPC setup forwards transactions quickly, handles load and retries, and stays well connected to the network, which leads to faster confirmations and more reliable behavior when the network is busy.
➡️ Maximizing Performance - A Guide to Efficient RPC Calls with Quicknode
Infrastructure
For Devnet and Mainnet-beta, Quicknode RPC and WebSocket endpoints enable sending transactions, subscribing to account or log changes, and tuning requests for performance and reliability.
For local development, you run a local validator to test programs and clients without real funds or network latency. Tools like LiteSVM, Surfpool, and Mollusk provide faster local runtimes, simulation, and fuzz-style testing utilities that plug into your normal test workflow and help catch issues before you deploy.
Supported Networks
Solana has several clusters, each with a different role in your workflow. Here’s what you need to when deciding where to develop, test, and deploy your program:
- Localnet
- Devnet
- Testnet
- Mainnet-beta
A local validator is for writing program logic, defining account layouts, or writing tests. It lets you airdrop SOL freely, reset the chain, and script deterministic scenarios. The tradeoff is that it doesn’t mirror Mainnet-beta data by default, so you'll need to export and deploy those programs into your local setup if you need them.
Devnet is Solana’s public testing cluster designed for builders. You get free (rate-limited) airdrops of SOL, most ecosystem programs eventually deploy there, and it’s treated as a playground for apps, tutorials, and demos.
Testnet is primarily for validator and protocol testing, not for application deployment. Its purpose is to trial new validator client releases, stress-test consensus changes, and simulate network load.
Mainnet-beta is where you deploy your program so anyone on Solana can use it. When you deploy here, you pay real costs to fund the program and any related state accounts with enough SOL to be rent-exempt, and transaction fees to write that code on-chain.
Quicknode provides access to the following Solana networks:
Ecosystem and Use Cases
Solana’s fast transactions and low fees enable a wide range of applications that may not be practical on other blockchains.
This shows up in DeFi protocols with frequent trades, games that update onchain state in real time, NFT platforms that support large collections, and payment or consumer apps where users expect quick confirmations without worrying about fees.
Projects often combine standard building blocks rather than building everything from the ground up. SPL Token and Token-2022 handle fungible assets, Metaplex covers NFTs and collections, and other on-chain protocols provide swaps, lending, order books, identity, and more.
Programs can call into these directly, so it’s straightforward to wire up features like on-chain markets, reward systems, or in-app currencies.
For large-scale use cases, compressed assets make it possible to store and update large numbers of objects at low cost. On the off-chain side, RPC and indexing infrastructure transform raw onchain account data into usable APIs and dashboards for feeds, leaderboards, analytics, and monitoring. This lets applications remain responsive while working with substantial amounts of on chain data.
Check out some of our sample applications built on Solana for practical examples.
Learn More
Complete reference for developers building on Solana with Quicknode:
QuickStart
Get started with Solana quickly. Follow our step-by-step quickstart to set up your endpoint and make your first API request.
Provider Endpoints
Learn how to configure and manage your Solana endpoints for optimal performance and reliability.
API Overview
Explore supported APIs, networks, Quicknode products, and enhanced API features for building powerful applications.
Marketplace
Discover and integrate powerful add-ons and tools from the Quicknode Marketplace to enhance your web3 applications.
Endpoint Security
Secure your endpoints with authentication, whitelisting, and best security practices.
Error Codes
Understand common error codes and troubleshooting steps for Solana API requests.