How to choose an RPC provider for a high-performance Solana wallet
TL;DR
- Wallets have specific RPC demands: fast token and asset retrieval, real-time updates, transaction history fetching, and smart transaction routing during congestion.
- DAS API and custom gPA indexes are essential for fetching fungible tokens, NFTs, program, and staking accounts without scanning the whole chain state.
- Real-time updates require gRPC for browser extensions and backend pipelines, and WebSockets for frontend UI.
- For most wallets, shared infrastructure wins on global distribution, cost, and auto-scaling over dedicated nodes.
- When choosing a provider, focus on global coverage, asset and program accounts indexes, gRPC streaming, SWQoS routes, MEV protection, support, and predictable pricing.
What do users expect from wallets?
Perceived speed is speed
Users expect you to display their holdings quickly and accurately. If data is “loading” for more than a second, they will assume you are slow across the board.
Real-time updates
Balance changes, incoming transfers, and confirmations should appear instantly.
Protection from bad actors
Your users might not need to be the fastest into a trade, but they do not want to be sandwiched by a malicious validator.
Complete transaction history on request
Users want to see every swap they did in the last month. They do not want to wait 10 seconds for it to load.
Congestion tolerance
During latency spikes or NFT mints, transactions that would normally land can time out. Users hate it when transactions just disappear.
To meet these requirements, you need a stack that goes beyond standard JSON-RPC. You want asset APIs, streaming feeds for different use cases, accessible Solana history, and optimised and protected transaction routing during congestion.
What should wallets expect from an RPC provider?
Fetching data: DAS API and Steamboat vs raw RPC
For most wallets, the majority of the workload is “simple” data retrieval. However, this “simple” task can quickly turn into massive payloads, high compute consumption, and timeouts—especially for popular mints, large programs, wallet NFT inventories, or heavy getProgramAccounts reads.
In practice, wallets solve this with indexing solutions: DAS (digital asset standard) API for unified asset and balance retrieval, and custom indexes (like Steamboat) for making repeated gPA queries faster and cheaper.
DAS helps wallets deliver fast, responsive UX at all times with:
- Near-instant token-account lookups
- Simplified Solana asset querying
- Accurate, up-to-date state across all token accounts
Custom indexes help you serve results from a purpose-built index instead of scanning the chain for every request. For example, with Steamboat, you get:
- Direct pre-indexed DB reads
- Predictable performance at scale
- Fast metadata, portfolio, and staking lookups
Real-time updates: gRPC and WebSockets streaming
Polling is slow and gets expensive at scale because you keep asking for state that has not changed. Streaming flips the model. You receive only the updates as soon as they happen on-chain, which typically cuts read calls by 80% or more, and improves confirmation latency.
The Yellowstone tools (authored by Triton) let you consume raw slot, block, and account updates with minimal latency, keeping your wallet perfectly synced with the network.
- Dragon’s Mouth (Yellowstone gRPC). The core stream for backend pipelines and browser-extension clients.
- Whirligig. A Rust-based proxy that bridges gRPC to WebSockets, enabling the same ultra-low latency data and real-time UI updates in browser frontends.
Transaction sending: priority fees, MEV protection, and SWQoS
For a wallet, transaction sending comes down to 3 requirements: minimum transaction drops, reliable inclusion even when the network is busy, and protection against harmful validator behaviour.
Priority fee calculation
Solana’s getRecentPrioritizationFees RPC often returns zero as the recent “minimum” priority fee. Use custom priority fee APIs that support percentile-style logic, so your transactions get included without overbidding.
SWQoS lane
Stake-weighted quality of service gives you reserved transaction bandwidth, increasing the transaction’s chance to reach the leader under congestion. This lets your users’ transfers, swaps, deposits, and staking actions land predictably, even during network latency spikes.
MEV protection
Some validators engage in harmful MEV strategies like sandwiching or frontrunning. To prevent this, you can use open-source tools, like Yellowstone Shield (authored by Triton), that let you attach a custom allowlist or blocklist policy to every sendTransaction.
Reliability and performance: what matters more
People often see latency as the number 1 enemy. For wallets, however, it’s often downtime, jitter, stale data, and ineffective support.
Uptime and global distribution
You want globally distributed infrastructure with 99.99% uptime, smart routing, continuous health checks, and automatic failover. This reduces the risk of degraded performance, stale responses, and wallet downtime.
Low and consistent latency
Sub-second responses are non-negotiable for Solana wallets, but it’s not just about a low median. Jitter and tail latency must stay stable under load, so performance does not fall apart when volume spikes.
Direct engineering support
Know who you’ll speak to when something breaks. Support should be a direct channel to engineers for integration debugging, configuration guidance, and urgent troubleshooting—not a generic ticket loop.
Shared vs dedicated: how to choose
Shared RPC pools are great for most wallet use cases. Shared infrastructure routes each user to the nearest region with smart routing, which keeps latency low across locations, and absorbs spikes when thousands of users open the app at once—without you doing capacity planning.
Dedicated infrastructure is a good fit for streaming when millisecond-level differences matter. It offers predictable performance and greater control, but typically does not match the global distribution benefits of a shared fleet.
Pricing and scaling
Pricing predictability
40 million “credits” looks like a lot until you factor in the cost of heavy operations like DAS queries, historical access, or getProgramAccounts. With these calls costing 3, 5, or even 100 credits per request, that balance evaporates quickly. You should be able to estimate spend upfront, not 2 weeks in when you hit an overage cliff.
Bloated tiers
Plans often force you to upgrade to the higher tier just to lift a limit (like getting a higher throughput ceiling), even if you do not need all the included credits or features. Make sure you are not paying for bundled resources you don’t use, subsidising other users and the provider.
Vendor lock-in is a hidden cost
Closed-source tools and enhanced APIs can be convenient, but if too much of your backend depends on them, migrating later means rewriting the whole stack. If you value long-term control and plan to scale, use open-source standards wherever possible.
RPC provider checklist for Solana wallets
Use this to compare providers against your wallet’s actual workload.
| RPC feature | What you’d want to confirm |
|---|---|
| Coverage and performance | Test latency, tail latency from your key regions, uptime, and success rate for Solana JSON-RPC and the methods you use most. |
| Asset APIs and indexing | Confirm Metaplex DAS API support, and gPA reliability and latency under load. |
| Transaction history retrieval | Look for complete Solana history access from genesis. |
| Real-time feeds | Ensure Yellowstone support and low latency for gRPC and WebSockets streaming subscriptions. |
| Fee estimation and SWQoS routing | Check for availability of staked paths for transaction sending, and integration with an enhanced priority fee API. |
| Developer experience and observability | Confirm docs include all the information you need to get started, and dashboards have per-method visibility into latency, errors, compute, as well as streaming health, and send success rates. |
| Pricing and scale | Prioritise transparent and predictable pricing for tools you’ll use most—DAS, streaming, history, and SWQoS—with overages billed at the base rate. |
| Vendor lock-in | Make sure you can migrate without rewriting your entire codebase: prefer open standards and software you can run elsewhere if needed. |
Bottom line
A high-performance Solana wallet in 2026 can’t be built only with standard JSON-RPC access.
Pick the provider whose strengths match the user experiences you refuse to compromise on. Users won’t thank you for great RPC infrastructure, but they will keep using your wallet because it feels instant and reliable.