Summary
Solana validator APIs are not a single endpoint. They fall into several categories: core JSON-RPC methods for raw network state, specialized vote-account and epoch-data APIs, and monitoring or analytics APIs that aggregate validator performance. For validator operations, start with Solana JSON-RPC methods such as getVoteAccounts, getEpochInfo, getBlockProduction, and getLeaderSchedule to query vote accounts, identity, commission, stake, and epoch progress. Use specialized APIs when you need normalized historical credit performance, skip rate, vote distance, or alerting. Public clusters like https://api.mainnet-beta.solana.com and https://api.devnet.solana.com are useful for development, but production validator workflows often need a dedicated or high-availability RPC endpoint with WebSocket support and predictable rate limits. Check current plan terms because public limits can change. Developer teams should separate raw RPC methods from specialized data APIs to avoid integration friction. OnFinality offers a Solana RPC endpoint with HTTPS/WebSocket access and archive support on mainnet; current coverage and regional availability are listed on /networks/solana.
Key Takeaways
- Start with core Solana JSON-RPC methods like getVoteAccounts and getEpochInfo for raw validator state.
- Use specialized validator data APIs when historical credit performance, skip rate, or vote distance analysis is required.
- Verify WebSocket support, data freshness, rate limits, and regional endpoint availability before building alerts.
- Test on devnet with the official faucet, then move production workloads to a dedicated or high-availability plan such as OnFinality's Solana RPC.
Validator API categories
Solana validator APIs serve different operational needs. Before choosing endpoints, separate the problem you are solving into categories: raw network queries, stake management, historical performance analysis, and real-time alerting.
Most validator teams combine core Solana JSON-RPC methods with one or more specialized data APIs. This reduces the risk of building brittle integrations around a single endpoint type.
- RPC APIs provide raw cluster state through methods like getVoteAccounts, getEpochInfo, and getBlockProduction. Use these for direct integration with the Solana network.
- Vote-account and identity APIs expose validator pubkeys, commission, stake, and voting activity. Some are available through core RPC; others are part of specialized services.
- Epoch and performance monitoring APIs aggregate credit history, skip rate, vote distance, and block production trends. They usually store historical data for comparison.
- Staking APIs handle stake lifecycle operations such as delegate, undelegate, and claim rewards. If you manage stake programmatically, review /rpc-assistant/key-apis-for-solana-staking-integration.
- Data and analytics APIs provide decoded transactions, market data, or validator rankings, but they may not be designed for real-time operational alerting.
Vote accounts and validator identity
A vote account is the on-chain record that connects a validator's identity keypair to its voting keypair and delegation state. Understanding the distinction between vote account pubkey and identity pubkey is critical when querying validator data.
Use the getVoteAccounts JSON-RPC method to retrieve the current validator set, including both current and delinquent validators. The response includes vote account pubkey, identity pubkey, authorized voter, commission, last vote slot, root slot, and epoch credits.
For a deeper guide to Solana JSON-RPC calls and cluster endpoints, see /rpc-assistant/solana-api-guide.
- Vote account pubkey is the account stake delegations target.
- Identity pubkey is the validator node key that signs votes.
- Commission is the percentage of staking rewards taken by the validator.
- Epoch credits track validator vote history and are used to calculate skip rate and earned rewards.
- Use getVoteAccounts with filters to query specific vote accounts or identities instead of retrieving the full set every time.
Epoch data and performance monitoring
Solana epoch boundaries drive many validator metrics. Core RPC methods give raw epoch state; specialized APIs add historical performance context such as credit trends and vote distance.
Use getEpochInfo for current epoch, slot, and transaction counts. Use getBlockProduction to see block production by leader, and getInflationReward to query staking rewards for a given epoch and validator.
For real-time performance monitoring, subscribe to slot and vote updates over WebSocket. If your provider supports it, this reduces the need for frequent polling.
- getEpochInfo returns epoch number, slot index, and transaction count.
- getBlockProduction returns block production by leader slot range.
- getInflationReward returns reward amounts for a list of vote accounts.
- Specialized validator data APIs often calculate skip rate, credit propagation, and voting gaps across many epochs, which can be difficult to assemble from raw RPC calls alone.
RPC methods versus specialized validator data APIs
Core Solana JSON-RPC returns live network state and raw validator fields. Specialized validator data APIs usually store, normalize, and aggregate historical data, making it easier to compare validators over time or build dashboards and alerts.
The two approaches are complementary. Use raw RPC for transaction submission and exact on-chain state; use specialized APIs when you need historical trends, enriched metadata, or webhook-based alerting.
| Criterion | What to check | Why it matters |
|---|---|---|
| Current vote accounts | getVoteAccounts via JSON-RPC | Returns live vote account pubkeys, identity, commission, stake, and credits for current and delinquent validators. |
| Epoch summary | getEpochInfo | Provides current epoch, slot, and transaction count for timing-aware operations. |
| Validator credit and performance | getVoteAccounts credits field or specialized performance API | Credits feed skip-rate and vote-distance calculations. Specialized APIs normalize this across epochs. |
| Historical comparisons | Specialized data API with epoch history | Raw RPC does not store unlimited history. A data API can return credit trends, stake changes, and commission changes over time. |
| Real-time alerts | WebSocket subscriptions or specialized streams | Polling REST endpoints may miss fast state changes. WebSocket or push alerts provide near-real-time monitoring. |
Operational alerts and data freshness
Alerts should be built on fresh data, but freshness varies by source. A raw RPC endpoint may return the latest finalized slot, while a specialized data API may batch updates or have propagation lag.
Set explicit thresholds for vote distance, skip rate, delinquent status, and balance changes. For critical alerts, use WebSocket subscriptions or push notifications, then confirm with a follow-up RPC read before taking action.
- WebSocket subscriptions for slots and vote accounts enable near-real-time monitoring.
- REST polling adds latency and can miss brief state changes during network congestion.
- Specialized data APIs may have a documented freshness lag; check the provider's data ingestion and update frequency.
- Public endpoints can throttle requests and delay data. For production alerting, consider a dedicated endpoint like /rpc-assistant/dedicated-solana-node.
- Always include an alert deduplication and threshold hysteresis to avoid false positive storms during network instability.
Validator API selection checklist
Before committing to a Solana validator API stack, work through the checklist below. It maps evaluation criteria to the infrastructure and data needs of validator operations.
Current plan details such as rate limits, regional availability, and archive support can change, so verify them against the provider's latest documentation. For OnFinality's Solana endpoint details, check /networks/solana.
| Criterion | What to check | Why it matters |
|---|---|---|
| Method coverage | Does the endpoint support getVoteAccounts, getEpochInfo, getBlockProduction, getInflationReward, and WebSocket subscriptions? | Missing methods force workarounds and increase integration complexity. |
| Vote-account data scope | Can you filter by identity, vote pubkey, or delinquent state? | Filtering reduces overhead and enables targeted monitoring of your validators. |
| Epoch history depth | How many epochs of credit and block production history are available? | Longer history helps identify performance drift and commission changes. |
| Data freshness and lag | What is the expected update latency for slots, vote accounts, and rewards? | Stale data can cause false alerts or missed operational issues. |
| WebSocket support | Can you subscribe to account, program, or slot updates? | Real-time dashboards and alerting depend on push updates rather than polling. |
| Rate limits and throttling | Are request limits documented? Do they scale with plan tier? | Monitor self-inflicted throttling during high-frequency sampling. |
| Regional endpoints | Are endpoints available near your validator infrastructure? | Lower network latency improves data freshness and transaction submission. |
| Archive access | Does the plan include archive calls for historical slot and block data? | Useful for research and audit, but not required for all validator alerting. |
| Dedicated versus shared | Is a dedicated endpoint available if you need isolation from other traffic? | Dedicated nodes reduce noisy-neighbor risk for high-throughput validator operations. |
Using OnFinality for validator RPC work
OnFinality's Solana network page lists HTTPS and WebSocket endpoints, archive support for mainnet, and regions in N. Virginia and Hong Kong. Use /networks/solana to confirm current plan details, including whether those regions and archive support match your requirements.
If you need a private endpoint for sustained validator monitoring or transaction submission, review /rpc-assistant/dedicated-solana-node. For general JSON-RPC method coverage and connection setup, start with /rpc-assistant/solana-api-guide.
Staking integrations can pair OnFinality's RPC layer with a staking API that fits your custody model; see /rpc-assistant/key-apis-for-solana-staking-integration for evaluation points.
- Check the Solana network page for current HTTPS and WebSocket endpoint details.
- Verify archive support is available on your chosen plan before storing historical data queries.
- Use devnet public endpoint https://api.devnet.solana.com and faucet https://faucet.solana.com for development testing; do not use devnet for production state.
- Consider a dedicated node if shared endpoint rate limits or noisy neighbors could affect your alerting.
Frequently Asked Questions
What Solana RPC methods are most useful for validator monitoring?
getVoteAccounts, getEpochInfo, getBlockProduction, getLeaderSchedule, and getInflationReward are key methods. They provide raw data for stake, commission, credits, block production, and rewards. See /rpc-assistant/solana-api-guide for connection details.
Can I use public Solana RPC endpoints for validator API workloads?
Public endpoints like https://api.mainnet-beta.solana.com and https://api.devnet.solana.com are useful for development and testing, but rate limits and reliability are not guaranteed for production monitoring. Use a dedicated or high-availability plan.
What is the difference between a vote account and validator identity?
Vote account pubkey is the account that receives stake delegations and records voting activity. Identity pubkey is the validator node key that signs votes. getVoteAccounts returns both.
How can I get real-time alerts for my validator?
Use WebSocket subscriptions for slots and vote account updates, or use specialized monitoring APIs that support webhooks/streams. Ensure your alerting layer checks data freshness to avoid false positives.
Does OnFinality support archive data for Solana validator research?
The OnFinality Solana network page lists archive support for mainnet. Check /networks/solana for current capabilities and endpoints.
What should I check before choosing a validator API plan?
Review method coverage, WebSocket support, rate limits, data freshness, regional endpoints, archive support, and whether you need dedicated infrastructure. See the selection checklist above.
Ethereum
Solana
Polygon
Base
Arbitrum
BNB Chain
Polkadot
Optimism
