Using the Solana Geyser Plugin for Real-Time Account Updates in Bots

Public RPC nodes are a shared resource, and that shows in the numbers — 50–200 ms poll intervals, aggressive rate limits, and a queue that puts you behind every other bot that bothered to read the same docs. If your Solana trading bot is calling getAccountInfo on a polling loop, you are not competing; you are waiting. The Geyser plugin interface exists to solve exactly this: it lets a validator push account and transaction updates to an external process the instant they are processed, before confirmation, with sub-millisecond internal latency.

What Geyser Actually Is

Geyser is a dynamic plugin interface baked into the agave (formerly solana-labs) validator. At startup, the validator dlopens a shared library you provide. That library registers callbacks for four event streams: account updates, slot updates, transaction updates, and block metadata. Every time the validator writes a new account state or processes a transaction, it calls your callbacks synchronously on the banking thread.

The production-grade implementation everyone uses is Yellowstone gRPC (maintained by Triton One). It wraps those callbacks in a gRPC server so you can subscribe from any process — including one running on a separate machine — without writing C or Rust. The wire format is protobuf, which means typed, compact, and fast to deserialize in any language with a generated client.

Setting Up a Yellowstone Stream

You have two paths: run your own validator with the plugin loaded, or subscribe to a hosted Yellowstone endpoint (Triton, Helius, QuickNode all offer these). For most teams, a hosted endpoint is the right starting point — validator ops is a separate discipline and the monthly cost of a hosted stream is a rounding error compared to a collocated bare-metal box.

Connecting is straightforward once you have an endpoint and token:

let mut client = GeyserGrpcClient::connect(endpoint, Some(token), None).await?;
let (mut tx, rx) = client.subscribe().await?;

tx.send(SubscribeRequest {
    accounts: HashMap::from([(
        "my_filter".to_string(),
        SubscribeRequestFilterAccounts {
            account: vec![target_pubkey.to_string()],
            owner: vec![],
            filters: vec![],
        },
    )]),
    ..Default::default()
}).await?;

You send one SubscribeRequest with your filters, and the server pushes SubscribeUpdate messages back on the same bidirectional stream. Filter by individual account addresses, by program owner, or by a combination of both. For an AMM bot watching a handful of pool accounts, filter by address. For a liquidation bot that needs every position account under a lending program, filter by owner.

Latency Profile and What to Expect

On a hosted Yellowstone endpoint collocated in the same datacenter as a stake-weighted validator cluster, you should see account updates arriving 5–15 ms after a transaction lands in a block. Compare that to polling getAccountInfo on a public RPC: even at a 100 ms poll interval you are statistically 50 ms behind on average, and that assumes your request does not queue.

The more important number is jitter. Polling adds unbounded jitter because your poll fires at a fixed wall-clock interval regardless of when the chain produces a slot. A Geyser stream fires on the validator's schedule. For strategies where the signal degrades quickly — oracle price updates, order book changes on a clob, liquidation thresholds crossing — consistent low-jitter delivery is worth more than raw median latency.

One caveat: Geyser delivers updates at the processed commitment level. The account state you receive has not been confirmed or finalized. For most bot strategies this is exactly what you want — you see the state as early as possible. But your execution logic must handle the case where a slot is rolled back and the account state reverts. In practice, rollbacks are rare on Solana's current validator set, but you need to track slot lineage and be prepared to discard stale state.

Filtering Efficiently

Every account update you receive costs CPU to deserialize and process. On a busy program like Raydium or Jupiter, naively subscribing by owner will flood your consumer with thousands of updates per second. Use the filters field in SubscribeRequestFilterAccounts to apply memcmp filters on the account data — same semantics as getProgramAccounts filters but applied server-side before the update leaves the validator.

A well-filtered subscription for a specific pool type might look like:

• Owner filter: the AMM program ID
• Memcmp filter at offset 0: the account discriminator for pool state accounts
• Memcmp filter at offset 8: a specific market identifier if you only care about one pair

This pushes the work onto the Geyser server and keeps your consumer processing only what it needs to act on.

Reconnection and Operational Concerns

gRPC streams drop. Validators restart. Endpoints rotate. Your consumer must implement exponential-backoff reconnection and, critically, must re-request the current account state via a normal RPC call on reconnect before processing the stream. The Geyser stream gives you a delta feed, not a snapshot — if you miss updates during a disconnection window, your in-memory state is stale until you reseed it.

Track the slot field on every SubscribeUpdate. If you receive an update on slot N and your last update was on slot N-5, you missed four slots and need to decide whether to resync or halt execution until you confirm your state is current. For high-frequency strategies, halting is usually the safer choice.

One operational detail that bites teams: the Geyser stream sends updates for every write to the account, including internal CPI calls that touch it. If a program modifies an account multiple times within a single transaction, you will receive multiple updates for the same transaction. Deduplicate on transaction signature before taking action, not on account state alone.

---

If you want this infrastructure running under a production strategy without spending three months on validator ops and stream plumbing, talk to us — building and operating low-latency Solana data pipelines is a core part of what we do at TierZero.