Validator-level
execution.
Without the validator.
Geyser is the deepest data surface Solana exposes: your code runs at the source, catching every account write and every transaction the instant it happens. The price of admission used to be operating a mainnet validator. We removed it. You ship a .so. We run the hard part.
Start free. No card to look around the dashboard. Live on mainnet in under 30 minutes.
There are two ways to read Solana.
Only one of them is the source.
RPC and WebSockets stand outside the chain and ask for data. Geyser is inside, holding it as it forms. That difference is the whole reason every serious team eventually goes looking for it.
- ✕A network round trip on every single read
- ✕A JSON encode and decode on every payload
- ✕Polling gaps that silently drop intra-slot writes
- ✓An in-process callback, no network in the path
- ✓Raw Rust structs, nothing to serialize
- ✓Every account write, every slot, nothing skipped
It is why Yellowstone gRPC, Helius LaserStream, and Bitquery all run Geyser under the hood. The question was never whether you want this. It was whether you could afford to run it.
Running the plugin was never the hard part.
Running the validator under it was.
The hardware is the easy line item. The hard one is the person who can triage a stuck snapshot or a turbine retransmit storm at 2am, every month, even when the cluster behaves.
error: snapshot for slot 0 not found, rebuilding…
this is your weekend now▌
Now the whole job
is two files.
You hand us a compiled plugin and a config. We verify the ABI, smoke test it, and put it live on mainnet. No server to provision, no snapshot to rebuild, no pager to carry. The hard part is already running. You deploy into it.
No Dockerfile, no Terraform, no kubernetes manifest, no PagerDuty schedule. Two files.
One callback. Then the whole product is yours.
The function fires the instant the chain moves. What you do inside it, decode, filter, fan out, is the entire business. Six patterns teams run today.
Filter by program owner, decode account data with a Borsh schema, upsert into a relational table keyed by pubkey. The classic. Replaces a five-figure data-vendor bill for most single-program queries.
fn on_update_account(&self, acc: ReplicaAccountInfoVersions, slot: u64, _startup: bool) -> Result<()> {
let info = match acc { ReplicaAccountInfoVersions::V0_0_3(a) => a, _ => return Ok(()) };
if info.owner != &self.target_program { return Ok(()); }
self.db.execute(
"INSERT INTO accounts (pubkey, owner, lamports, data, slot)
VALUES ($1,$2,$3,$4,$5)
ON CONFLICT (pubkey) DO UPDATE SET lamports=$3, data=$4, slot=$5",
&[&b58(info.pubkey), &b58(info.owner),
&(info.lamports as i64), &info.data, &(slot as i64)],
)?;
Ok(())
}Two ways to run. One flat bill.
Start shared and pay per plugin. Move to a dedicated host the moment you outgrow it. No event meters, no compute tiers, no bandwidth surprises on either path.
per plugin
One plugin, one price. Add more as you need them.
- ✓One compiled plugin, live on mainnet
- ✓Every Geyser callback, every output target
- ✓Upgrades, logs, health metrics, on-call
- ✓Live in under 30 minutes
- ○Runs on shared, pooled hosting
Best for 1 to 3 plugins.
unlimited
Your own host. Run as many plugins as you want, no neighbors.
- ★Unlimited plugins on one flat bill
- ★Your own host. Zero noisy neighbors.
- ✓Full IOPS, full isolation, no contention
- ✓Everything in Shared, plus priority upgrades
- ✓Live in under 30 minutes
Best for teams at scale and anything production-critical.
Dedicated saves you $60/mo at 4 plugins, with unlimited room and no one sharing your host.
Either path skips the $5,000 to $15,000 a month it costs to stand up and operate this yourself.
Every callback Geyser fires. None of the operations.
Your plugin gets the complete interface. We carry the upgrades, the patching, and the 2am pages that come with keeping it live.
Fires on every account write. You receive AccountInfo with owner, lamports, data, executable flag, and rent epoch in the same slot it is committed on mainnet.
Every confirmed transaction with full TransactionStatusMeta: logs, pre/post balances, inner instructions, return data, compute units consumed.
Slot transitions across processed, confirmed, and rooted. Drives reorg-safe indexing and finality alerts.
Once per block. Leader identity, parent slot, block height, rewards array, and block time in epoch seconds.
Per entry inside a block. Useful for ordering analysis and tx-batch parallelism research.
Final transaction status as it is recorded on chain. Confirm settlement before downstream effects fire.
Called once when your .so is loaded. Parse config, open database connections, prepare worker threads here.
Called on plugin shutdown. Flush buffers, close sockets, drain queues so you do not lose data on restart.
Your plugin does not break silently. We test against staging first, flag any change in the GeyserPlugin trait, and only move you to the new version once your binary loads cleanly. That coordination is the difference between hosting and a folder of upload scripts.
The things teams ask before they ship.
Where Geyser plugins fit in the stack
The streaming layer most Geyser plugins eventually feed into. If your output is a gRPC stream, run it on top.
Pre-built, decoded feeds for Pump.fun, Raydium, Orca, Meteora, and more. Use these when you do not need a custom plugin.
The complementary side of the same fleet, with shared health metrics and the same uptime SLO.
Backfill your plugin output from any historical slot range without running a snapshot rebuild yourself.
Browse every decoded instruction the major Solana programs emit before deciding which ones to plug into.
Why run a validator
just to host a plugin?
Ship a compiled .so and a config. We verify it, smoke test it, and put it live on mainnet. Validator-level execution, none of the validator.