Managed Solana Geyser plugin hosting for $65 a month, per plugin
Geyser is the only place on Solana where your code runs in the validator process itself. No RPC hop, no JSON parsing tax, no missed events between polls. Every account write, every transaction, every slot transition lands in your callback the moment the validator processes it. The catch: to run a plugin, you have to run a validator. A real one. 256 GB of RAM, 4 TB of NVMe, 10 Gbps unmetered, and a person who actually knows what an Agave snapshot is. That stack runs $5,000 to $15,000 a month before anyone writes a line of plugin code. We've done that part. You ship a compiled .so and a config file. We load it on a production mainnet validator, restart through every Solana upgrade, stream logs back to your dashboard, and bill you $65 a month per plugin. That's it.
- Vote Program (validator participation)Vote111111111111111111111111111111111111111, Our validators vote on every slot. Your plugin sees the same stream of accounts and transactions a voting node sees
- System Program (every transfer your plugin sees)11111111111111111111111111111111, Geyser callbacks fire for System transfers, account creations, allocations, and assigns at the validator level
- BPF Loader Upgradeable (plugin host context)BPFLoaderUpgradeab1e11111111111111111111111, Your plugin watches every program upgrade on mainnet, useful for security and indexing
Geyser callbacks your plugin can hook
every entry point the solana-geyser-plugin-interface trait exposes
| Event | Type | Description | Frequency | Latency |
|---|---|---|---|---|
| on_update_account | event | Fires on every account write. You receive AccountInfo with owner, lamports, data, executable flag, and rent epoch in the same slot the validator commits it. | Very high | 0ms |
| on_update_transaction | event | Every confirmed transaction with full TransactionStatusMeta: logs, pre/post balances, inner instructions, return data, compute units consumed. | Very high | 0ms |
| on_update_slot_status | event | Slot transitions across processed, confirmed, and rooted. Drives reorg-safe indexing and finality alerts. | High | 0ms |
| notify_block_metadata | event | Once per block. Leader identity, parent slot, block height, rewards array, and block time in epoch seconds. | Medium | 0ms |
| notify_entry | event | Per entry inside a block. Useful for ordering analysis and tx-batch parallelism research. | High | 0ms |
| notify_transaction_status | event | Final transaction status as the validator records it. Use this to confirm settlement before downstream effects fire. | High | 0ms |
| on_load (lifecycle) | event | Called once when the validator loads your .so. Parse config, open database connections, prepare worker threads here. | Low | — |
| on_unload (lifecycle) | event | Called on plugin shutdown. Flush buffers, close sockets, drain queues so you don't lose the last 200ms of data on restart. | Low | — |
What it costs and what you get
last reviewed 2026-04-29
The unit economics of a validator (and why we charge $65)
A Solana mainnet validator that can actually run plugins isn't a $200 droplet. It's a 256 GB box with 4 TB of NVMe, sitting on a 10 Gbps unmetered uplink, in a colo that won't cut you when the chain has a bad day. Hardware lease alone runs $800 to $2,000 a month if you go through Latitude, Equinix Metal, or Hetzner's server-auction tier. Bandwidth lands somewhere between $300 and $800. Colo or instance overhead adds another $200 to $500.
Then there's the person. A real on-call rotation that understands Agave snapshots, gossip churn, and how to triage a turbine retransmit storm at 2am isn't a contractor. It's $1,000 to $3,000 a month of senior infra-engineer time, even if the cluster is well-behaved. The all-in for a plugin-capable validator is $2,300 on the cheap end and $6,300 if you don't cut corners.
We run that stack already. Adding your plugin to one of our validators is a marginal cost, not a fixed one. We can charge $65 a month and still have unit economics that work, because the validator is shared across plugins and the validator was going to run regardless. You pay for the slot in our process table, not for a brand new server.
| Line item | Self-host | NLN |
|---|---|---|
| Hardware lease (256 GB / 4 TB NVMe) | $800-$2,000 | included |
| Bandwidth (10 Gbps unmetered) | $300-$800 | included |
| Colocation or cloud surcharge | $200-$500 | included |
| On-call validator engineer | $1,000-$3,000 | included |
| Effective monthly cost per plugin | $2,300-$6,300 | $65 |
The first plugin pays back the “why are we doing this” conversation in week one. The fifth plugin is what makes this an actual product instead of a deal.
Geyser vs RPC, WebSocket, and shared gRPC
People use plugin hosting because the alternatives are wrong for the workload. It's worth being explicit about which alternative is wrong in which way.
RPC polling means you call getAccountInfo or getSignaturesForAddress on a loop. Even on a dedicated node you're paying network round-trip plus JSON serialization. A 200 ms loop misses every intra-slot change. Fine for a portfolio dashboard, fatal for a liquidator that needs to see a margin event the moment it happens.
WebSocket logsSubscribe is closer. You get a push channel and base64-encoded program logs. The logs aren't the accounts though, and the JSON framing caps out around 200-400 messages per second per connection in practice. Teams ship with logsSubscribe and migrate off it about six weeks later, every time.
Shared gRPC (Yellowstone, LaserStream, our own gRPC nodes) is what most teams should run by default. It's parsed, fast, multi-tenant, and you don't have to deploy code into someone else's validator process. Pick it unless you have a specific reason not to.
Plugin hosting is the right answer when shared gRPC isn't. Custom decoders for a program nobody else has ABI for. Wallet-PDA filters that would saturate a multi-tenant stream. Joins between accounts and transactions inside a single slot. Anything where the hot loop is “callback fires, write to local Postgres, ack the slot.” You can't do that with a shared stream because the network is in the middle. With a plugin, the network is gone.
Plugin patterns customers actually run
Postgres-backed indexer
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 Bitquery bill for most single-program queries.
Kafka fan-out
One plugin, N downstream consumers. Producer config in the JSON, partition by slot, key by signature. Useful when half your team wants the data in Snowflake and the other half wants it in Flink.
Redis pub/sub firehose
Cache hot pool state with a 60s TTL and publish updates so front-ends update in real time. The simplest way to feed a React dashboard with sub-second freshness without a streaming framework.
Embedded gRPC server
Run tonic inside the plugin and stream to your own clients. You become a private LaserStream for whichever filters you care about, with no shared-tenancy noise.
Wallet PDA tracker
Filter on a list of wallet PDAs and write only the matched accounts to durable storage. Volume drops by four orders of magnitude vs ingesting everything, which is the whole point of running the filter at the validator instead of after it.
Liquidation watcher
Cross-reference Marginfi, Kamino, and Drift account state in the same callback. Send a webhook the slot a position crosses its liquidation threshold and let your bot submit the liquidation tx without waiting for the next RPC poll.
These aren't hypothetical. We see all six in production right now. The thing every customer learns inside week one is that the latency budget is mostly your code, not ours. The validator callback fires at zero milliseconds; what you do next is what determines whether you're fast.
From `cargo build --release` to running on mainnet
The deployment loop is intentionally short. Most plugins go from uploaded to running on a mainnet validator inside 30 minutes. Here's the actual sequence.
- 1Build against the right ABI. We pin to
solana-geyser-plugin-interfacev1.18+. The crate version has to match what the validator is running, which we publish in the dashboard.cargo build --releaseproduces a single .so intarget/release. - 2Upload .so plus config.json. The config is a small JSON:
libpath, your filters, your output destinations, any secrets. We support secrets via env-var indirection so you're not shipping API keys in plain text. - 3ABI & load check. We run an automated
dlopen()and symbol resolution on a staging validator. Catches the 90% case of “wrong toolchain version” before it hits mainnet. If your symbol list is missing_create_plugin, you find out in seconds, not in a 4am page. - 4Smoke run on staging mainnet. We attach the plugin to a non-voting mainnet validator first. You watch your output land. If something looks off, roll back is one button.
- 5Promote to production. Plugin attaches to a voting validator. You get a logs websocket, health metrics, and an alerting channel scoped to your plugin. Updates re-enter the same loop.
When Solana ships a new Agave version, your plugin doesn't break silently. We test against staging first, notify you if anything in the trait changed, and only restart your plugin on the new validator binary once it loads cleanly. We've carried customers through every release since 1.16.
Pricing, sales motion, and what's included
One number: $65 a month per plugin. No event meter, no compute tier, no bandwidth bill. The price covers the validator, the upgrade work, the log streaming, and an on-call engineer who will actually look at your plugin if it fails to load.
For five or more plugins we move to volume pricing, usually a flat retainer plus a discounted per-plugin rate. Common at firms running a Postgres indexer per program family plus a dedicated MEV plugin and a wallet-watch plugin. Hit talk to sales and we'll size it.
Enterprise tier exists when you need a dedicated validator (no neighbors, full IOPS), a contractual SLA with credits, and named engineering support. Different price point, same product, fewer neighbors.
Don't want to write the plugin yourself? Our engineering team builds Geyser plugins, custom indexers, and full ingestion pipelines on contract. The same engineers who run the validators write the plugins, which removes most of the deployment surprise.
Frequently asked questions
Related products
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 don't 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.
Dedicated physical hardware if you want to run the whole validator yourself.
Ship a plugin to mainnet this week
$65/mo per plugin, billed monthly. Volume pricing kicks in at five plugins. Upload .so + config and we handle the rest.