// Fundamentals
What is Solana Geyser? The data layer explained.
Every real-time Solana application — from sniper bots to analytics dashboards — depends on fast data. Geyser is the validator plugin framework that makes it possible. Instead of polling RPC endpoints for stale data, Geyser hooks directly into the validator runtime and pushes account updates, transactions, and slot notifications the moment they happen.
The Geyser architecture
Geyser is a plugin interface built into the Solana validator (agave-validator). It is not a separate service, a sidecar, or an indexer — it runs in-process with the validator itself. When the validator processes a slot, Geyser hooks fire synchronously with the validator's execution, giving plugins access to every piece of data the validator produces before it reaches disk or network.
The Geyser interface defines four callback types that plugins can implement. on_account_update fires whenever any account's data, lamport balance, or owner changes. on_transaction fires for every confirmed transaction with the full instruction set, signatures, log messages, and execution status. on_slot_status notifies when slots transition between processed, confirmed, and finalized states. on_block_metadata provides summary data for completed blocks including rewards, block time, and transaction counts.
Data goes directly from validator memory to the plugin — zero network hops, zero serialization delay. This is fundamentally different from JSON-RPC (which queries stored data after the fact) or WebSocket subscriptions (which push notifications with protocol overhead and limited data completeness). Geyser operates at the source of truth, giving plugins the same view of the chain that the validator itself has, at the exact moment it has it.
Validator processes a slot
The Solana validator executes a batch of transactions and produces a new slot. Each slot contains thousands of transactions across hundreds of programs, confirmed roughly every 400ms.
Geyser hooks fire in-process
The Geyser plugin interface intercepts on_account_update, on_transaction, on_slot_status, and on_block_metadata events directly from validator memory. No network hop — the plugin runs in the same process.
Plugin serializes and streams
The Geyser plugin (e.g. Yellowstone gRPC) takes the raw callback data, serializes it into Protocol Buffer messages, applies subscription-level filters, and pushes it over persistent gRPC streams.
Your client receives filtered data
Your client receives matching events in real time — no polling delay, no HTTP round trips, no missed slots. With Subglow, data arrives pre-parsed as clean JSON ready for your trading logic.
Available Geyser plugins
The Geyser interface is open — anyone can build a plugin in Rust by implementing the GeyserPlugin trait. But five plugins dominate the ecosystem today, each targeting a different data delivery pattern.
Yellowstone gRPC (Dragon's Mouth)
Streams data to clients via gRPC over HTTP/2. Maintained by Triton One under the rpcpool/yellowstone-grpc repository. The standard for real-time Solana data — used by QuickNode, Chainstack, Solana Tracker, and Subglow. Supports subscription-level filtering for transactions, accounts, slots, blocks, and entries.
Yellowstone gRPC deep dive →Yellowstone Kafka
Streams Geyser data to Apache Kafka topics. Designed for high-throughput data pipelines where multiple consumers need to process the same event stream independently. Ideal for teams running analytics, indexing, and alerting systems in parallel from a shared Kafka cluster.
Yellowstone PostgreSQL
Writes Geyser data directly to a PostgreSQL database. Built for historical queries and analytics — backtest trading strategies against past data, run SQL aggregations across millions of transactions, or build dashboards over time-series tables. Not real-time, but comprehensive.
Yellowstone Vixen
A framework for building custom parsers on top of Geyser data. Vixen provides a pipeline abstraction where you define program-specific decoders that transform raw account and transaction data into structured, typed output. Useful for teams building proprietary indexing logic.
Custom plugins
Anyone can build a Geyser plugin in Rust by implementing the GeyserPlugin trait from the solana-geyser-plugin-interface crate. The trait defines the four callback methods — you implement the ones you need, compile to a shared library, and configure the validator to load it. This is how Yellowstone gRPC, Kafka, and PostgreSQL plugins were all built.
Geyser vs RPC vs WebSocket
The three ways to get data from a Solana validator serve different needs. Understanding the trade-offs helps you choose the right approach for your application — and explains why most trading infrastructure has migrated to Geyser.
| Dimension | Geyser | JSON-RPC | WebSocket |
|---|---|---|---|
| Data path | Validator memory → plugin → client | Validator → storage → HTTP response | Validator → pubsub → notification |
| Latency | ~5ms | 200–800ms | 50–200ms |
| Data completeness | All data, full transactions | What you query | Notifications only, partial data |
| Filtering | Server-side, before transmission | None | Limited account subscriptions |
| CPU overhead on client | Minimal with pre-parsing | High — polling + JSON parsing | Medium — notification handling |
| Missed data | None — persistent stream | Common during congestion | Possible on disconnect |
The latency difference alone is decisive for trading. Geyser delivers data in roughly 5 milliseconds from the moment the validator processes it. JSON-RPC requires your client to poll — even with aggressive 200ms intervals, you're always behind, and during congestion that gap can stretch to 800ms or more. WebSocket subscriptions are faster than polling but still add 50–200ms of overhead from the pubsub layer and deliver only notification payloads, not the full transaction data you need for execution.
But latency is only half the story. Geyser gives you complete data — every transaction, every account update, every slot, with no gaps and no missed events. RPC misses data whenever your polling interval overlaps with a burst of activity. WebSocket subscriptions can drop events on disconnect, and the notification payload is a subset of the full transaction. For trading bots that need to see every swap, every liquidity event, and every token launch the moment it happens, only Geyser provides the reliability and completeness required. For a detailed technical comparison, see our Solana gRPC vs RPC guide.
Why traders choose Geyser
The Solana trading ecosystem has standardized on Geyser for a reason. Four properties make it the only viable data layer for competitive trading infrastructure.
5ms vs 800ms
The difference between sniping a token launch and arriving after the pump. Geyser delivers data directly from validator memory — no storage layer, no HTTP round trips, no polling intervals. Every millisecond of latency advantage compounds into better fills, earlier entries, and more profitable trades.
Every event, every time
Every transaction, every account update, every slot — nothing missed. RPC polling has gaps. WebSocket subscriptions can drop events. Geyser streams a continuous, ordered feed of all on-chain activity matching your filters, with built-in backpressure to handle bursts without data loss.
Server-side, before transmission
Only receive the programs and accounts you care about. Instead of downloading the full firehose and discarding 99% locally, Geyser plugins apply filters before the data leaves the server — reducing bandwidth, CPU load, and processing latency on your client.
Persistent stream with backpressure
A single gRPC connection with built-in flow control, multiplexing, and automatic backpressure. No polling gaps, no request timeouts, no rate limits on individual events. The stream stays open and data flows continuously as long as your client is connected.
These properties power the most demanding use cases in the Solana ecosystem: sniper bots that need to detect and execute on new token launches within milliseconds, copy traders that replicate wallet activity in real time, arbitrage scanners that monitor price discrepancies across DEXs, liquidation bots that watch collateral ratios across lending protocols, and MEV detection systems that analyze transaction ordering for extraction opportunities. All of them depend on Geyser-speed data to remain competitive.
Running Geyser vs using a provider
You have two paths to Geyser data: run your own infrastructure or connect to a managed provider. Both deliver the same underlying data — the difference is operational complexity, cost, and time to production.
Running your own Geyser setup requires a Solana validator or RPC node ($500–$2,000 per month in hardware alone), the Yellowstone gRPC plugin compiled and configured against your validator version, DevOps expertise for monitoring, failover, and upgrades, and ongoing maintenance as Solana releases new validator versions that may require plugin recompilation. This path makes sense for institutional traders with extreme latency requirements or teams that need custom plugin logic that no provider offers.
Using a provider gives you a managed endpoint with an API key, global regions for geographic latency optimization, uptime guarantees backed by SLAs, and — with Subglow — pre-parsed output that eliminates Borsh deserialization entirely. For most teams, a provider is the right choice: faster to start, lower total cost, and professionally managed so you can focus on trading logic instead of infrastructure.
| Dimension | Self-hosted | Provider (Subglow) |
|---|---|---|
| Monthly cost | $500–$2,000+ (hardware + bandwidth) | From $49/mo (usage-based tiers) |
| Setup time | Days to weeks (validator + plugin config) | Minutes (API key + endpoint URL) |
| Maintenance | Ongoing — validator upgrades, plugin recompilation, monitoring | Zero — fully managed by the provider |
| Latency | Lowest possible (co-located) | ~5ms (multiple global regions) |
| Filtering | Custom plugin logic possible | Pre-built server-side filters + pre-parsed JSON |
| Failover | You build and manage redundancy | Built-in with multi-region availability |
When to run your own
Institutional traders with extreme latency requirements who need co-located infrastructure. Teams that need custom Geyser plugin logic — proprietary parsing, custom data routing, or integration with internal systems that no provider supports.
When to use a provider
Most teams — faster to start, lower cost, professionally managed. You focus on your trading strategy, analytics pipeline, or application logic while the provider handles validator operations, plugin upgrades, monitoring, and failover.
Subglow: Geyser-powered, developer-friendly
Subglow is built on Yellowstone gRPC — the same Geyser plugin used by the largest Solana infrastructure providers. You connect with the standard @triton-one/yellowstone-grpc client, the yellowstone-grpc-client Rust crate, or any gRPC client in any language. The endpoint is Yellowstone-compatible — same protocol, same subscription format, same filter syntax.
What Subglow adds on top of raw Yellowstone is the infrastructure and intelligence layer that turns raw validator data into production-ready output. Server-side filtering by program — Pump.fun, Raydium, Jupiter, and more — means only relevant transactions reach your client. Pre-parsed JSON output eliminates Borsh decoding entirely: token amounts, buyer addresses, pool reserves, and instruction types arrive as labeled fields, not raw byte arrays. Multiple global regions minimize geographic latency regardless of where your infrastructure runs.
The result is Geyser-speed data without any of the Geyser operational burden. No validator to run, no plugin to compile, no Borsh schemas to maintain, no protobuf stubs to generate. You get the latency and completeness of a Geyser plugin with the developer experience of a managed API.
Documentation
API reference, endpoint configuration, and authentication.
Read the docs →Compare gRPC Providers
How Subglow compares to QuickNode, Chainstack, and others.
Provider comparison →Yellowstone gRPC Tutorial
Step-by-step guide to connecting and streaming with Yellowstone.
Start tutorial →Sniper Bot Use Case
How sniper bots use Geyser data to detect and execute on launches.
Read use case →Frequently asked questions
What is Solana Geyser?
Geyser is a plugin framework built into the Solana validator. It provides hooks that fire when accounts update, transactions confirm, and slots finalize — enabling real-time data streaming without polling.
Do I need to run my own validator to use Geyser?
No. Providers like Subglow, QuickNode, and Chainstack run Geyser-enabled validators and expose the data through Yellowstone gRPC endpoints that you connect to.
What Geyser plugins exist?
The main plugins are Yellowstone gRPC (real-time streaming), Yellowstone Kafka (data pipelines), Yellowstone PostgreSQL (historical storage), and Yellowstone Vixen (custom parsers).
How is Subglow related to Geyser?
Subglow runs Yellowstone gRPC (a Geyser plugin) on professionally managed validators and adds server-side filtering and pre-parsed JSON output. You get Geyser-speed data without running your own infrastructure.
Geyser-speed data. Zero infrastructure.
Subglow delivers Yellowstone gRPC with pre-parsed JSON, server-side filtering, and global regions. No validators to manage.