Sub-Millisecond Solana Account Queries, Served.
The Hyperion turns the slowest calls in the Solana RPC spec into the fastest. Purpose-built for teams that need program account data at the speed of their trading logic.
The Problem
Account query methods like getProgramAccounts, getTokenAccountsByOwner, and getTokenLargestAccounts are among the most expensive calls in the Solana RPC spec. Every DeFi dashboard, portfolio tracker, and trading bot depends on them — yet standard RPC nodes treat them as full table scans. Queries against popular programs routinely take 1–20 seconds, and some are too large to return at all — even leading RPC providers outright block certain methods or reject queries that touch too many accounts.
Rate limits force teams into batching, caching, and polling loops that add latency and complexity. When your arbitrage window is 400ms and your data source takes 8 seconds to respond, you're not competing — you're spectating.
The Hyperion eliminates this bottleneck entirely. It's a dedicated, fully managed service that ingests all Solana account state in real-time and serves queries from purpose-built in-memory indexes. The result: responses in under 1 millisecond for indexed queries — including methods that other providers don't support at all.
Real-World Performance
Head-to-head benchmarks against a leading Solana RPC provider, measured on live mainnet data. All tests ran consecutively with identical parameters and verified data correctness — every response was compared at the pubkey-set level to ensure identical results. Hyperion times are median of 3 runs.
Full Benchmark Summary
All tests ran on live Solana mainnet, April 2026. Responses verified for data correctness.
| Method | Accounts | Hyperion | RPC Provider | Speedup | Notes |
|---|---|---|---|---|---|
| getTokenAccountsByOwner | 8 | 0.5ms | 137ms | 251x | |
| getProgramAccounts (token holders) | 58,020 | 61ms | 1,134ms | 19x | ~9.6 MB response |
| getProgramAccounts (Orca pools) | 92,746 | 171ms | 1,090ms | 6x | ~78 MB response |
| getProgramAccounts (stake) | 0 | 1.9ms | 136ms | 71x | |
| getTokenSupply (USDC) | — | 0.3ms | 115ms | 398x | <$1 supply diff (live data) |
| getTokenAccountBalance | — | 0.3ms | 174ms | 521x | |
| getSupply | — | 0.4ms | 6,120ms | 16,106x | <0.002% diff (cache timing) |
| getTokenLargestAccounts ($WIF) | 20 | 130ms | 1,654ms | 13x | 20/20 address overlap |
| getLargestAccounts | 20 | 0.4ms | — | — | Provider blocked |
| getTokenAccountsByDelegate | 0 | 0.3ms | — | — | Provider rejected |
| getTokenLargestAccounts (USDC) | 20 | 2,737ms | — | — | Provider rejected (too many accounts) |
How It Works
Hyperion runs as a dedicated service alongside your infrastructure. It streams every account update from a Yellowstone gRPC source in real-time, maintains optimized in-memory indexes, and serves queries through a Solana-compatible JSON-RPC endpoint. Your existing code works without changes — just point it at a new URL.
Pre-flight Protection
Every query goes through a pre-flight size estimation before touching account data. Queries that would produce responses larger than your configured threshold are rejected instantly — no wasted compute, no timeouts, no surprise OOM conditions.
Request arrives <0.01ms
JSON-RPC request is parsed, filters and encoding are validated.
Pre-flight metadata scan <1ms
Lightweight index lookup counts matching accounts and estimates response size from metadata alone. No account data is read.
Decision gate
If estimated size exceeds the configured limit, return an immediate error with the estimate. Otherwise proceed.
Parallel data fetch & serialize ~1–100ms
Account data is fetched and JSON-serialized in parallel across multiple cores. Response streams back to the client.
Indexed Programs in Production
Hyperion uses a flexible, per-program indexing schema that determines exactly which account fields are indexed for each program — turning expensive full-table scans into instant bucket lookups. The following programs are indexed in the Solana Vibe Station production deployment today:
| Program | Indexed Fields | Use Case |
|---|---|---|
| SPL Token | mint, owner, delegate | Token holders, wallet balances, delegations |
| SPL Token-2022 | mint, owner, delegate | Extension tokens, transfer-fee accounts |
| Metaplex Metadata | update_authority, mint | NFT collections, metadata lookups |
| Stake Program | staker, withdrawer, voter | Validator delegation tracking |
| Vote Program | node_pubkey, withdrawer | Validator identity lookups |
| Orca Whirlpools | config, mint_a, mint_b | Pool discovery by token |
| Meteora DLMM | token_x, token_y | Liquidity bin pair lookups |
| Raydium CLMM | token_0, token_1 | Concentrated liquidity pools |
| Pump.fun / PumpSwap | discriminator, mint/creator | Bonding curves, AMM pools |
| All Anchor programs | discriminator (8 bytes) | Account type filtering (automatic) |
Need a program indexed that isn't listed? The indexing schema is fully customizable. If your application queries specific programs or account fields that aren't covered above, we can add custom indexes for your deployment. Just tell us the program ID and the byte offsets your queries filter on — we handle the rest.
Every Anchor-based program automatically gets an 8-byte discriminator index at offset 0, so account-type queries hit the fast path even without a custom configuration.
Built for Production
Hyperion isn't a proof of concept. It's built to run 24/7 on mainnet with the reliability your trading infrastructure demands.
Real-Time Ingestion
Streams account updates via Yellowstone gRPC with automatic reconnection and slot-level replay to guarantee zero missed updates.
Commitment Level Support
Full support for processed, confirmed, and finalized commitment levels. Each query returns data at the exact consistency level you request.
Fast Bootstrap
Boots from a Solana snapshot and bridges the gap with incremental updates. Full mainnet state loaded and indexed in minutes, not hours.
Drop-in RPC Compatibility
Solana JSON-RPC compatible endpoint. Supports all major account query methods, jsonParsed encoding, dataSlice, and withContext. Change one URL.
Overload Protection
Pre-flight size estimation rejects queries that would produce oversized responses before any data is read. No timeouts, no surprises.
Thread Isolation
Ingestion and query serving run on isolated thread pools. A storm of heavy queries never starves account updates, and vice versa.
Supported RPC Methods
Full Solana JSON-RPC compatibility for account query methods. Every method supports commitment levels, encoding options (base64, base58, base64+zstd, jsonParsed), and the standard withContext response wrapper.
Available as a Dedicated Service
Hyperion already powers the account query layer for the Solana Vibe Station shared RPC service in production. For teams that need guaranteed performance without sharing capacity, we offer Hyperion as a standalone dedicated deployment — your own instance, configured for your programs, running in a location of your choice.
Dedicated Instance
Your own Hyperion instance on high-memory infrastructure. No shared capacity, no noisy neighbors, no rate limits — all resources are yours.
Deploy Where You Need It
Choose the region and provider that makes sense for your latency requirements. We deploy and manage the infrastructure — you just consume the endpoint.
Custom Index Schema
We configure Hyperion to match your query patterns. Tell us which programs and fields you need — we'll have them indexed and running within hours.
Stop Waiting for Your Data
If your application is bottlenecked by account query latency — or blocked entirely by provider limitations — Hyperion can eliminate that constraint. Let's talk about your use case.
Join our Discord