Real-time Solana analytics with the Geyser plugin on Chainstack for Raydium and Bonk.fun tokens

Nikita Ilin

July 29, 2025 in Tutorials

Solana moves fast, and getting reliable, low-latency data out of it is harder than it should be. Polling RPC and basic WebSockets subscriptions often lag behind or require complex logic.
This guide walks through how to use the Geyser plugin, deployed on a Chainstack Global Node, to stream structured Solana data in real time using Rust or TypeScript. We’ll show how to track Raydium swaps, detect Bonk.fun token launches as they happen, and turn that into a live analytics pipeline.

Understanding the Geyser plugin in Solana’s architecture

Solana Geyser plugin is a plugin baked into Solana node software that streams blockchain data in real time. Instead of polling or parsing logs, it taps directly into validator memory and pushes updates as they happen on-chain.

Solana is fast. Geyser is faster. It pushes data the moment it’s produced, and avoids the usual RPC delay entirely. This means you can subscribe to accounts, transactions, blocks, or slots, and updates show up almost immediately.

How it fits in: RPC node with Geyser enabled emits structured updates for every slot, block, transaction, and account change. These updates are streamed over a gRPC interface, specifically the open-source Yellowstone gRPC implementation, which any client can connect to.

Whether you want the full transaction stream or only what touches specific programs or accounts, Geyser handles both. The output is Protobuf: structured, decoded, and usable without extra parsing.

Compared to Solana native WebSocket interface, which is limited to base64-encoded messages and coarse filters, Geyser offers structured payloads and fine-grained subscription logic. That makes it far better suited for real-time use cases like analytics pipelines, trading bots, dashboards, or any system that depends on sub-second visibility.

Key benefits of Geyser: It streams transaction data, account state changes, slot updates, and block information in real time, all over a stable gRPC connection. Each transaction comes with full context, logs, instructions, and execution data, giving you more detail than what logsSubscribe over WebSocket typically exposes.

Geyser gRPC interface works across languages: Rust, TypeScript, Python, Go… anything that supports gRPC. That makes it easy to drop into most existing stacks without custom tooling.

It also offers a real performance edge. In benchmarks, Geyser consistently detects on-chain events faster than RPC polling or WebSocket listeners.

For example, when monitoring new token mints, Geyser-based subscribers detect events significantly earlier than other methods, often by hundreds of milliseconds (Read our article comparing WebSockets and the Geyser Plugin).

If you’re tracking something time-sensitive, like a new Bonk.fun token launch or a large Raydium swap, Geyser is built to catch it first. It’s purpose-built for real-time blockchain analytics, and consistently delivers the lowest-latency data stream available on Solana.

Setting up Geyser with Chainstack’s Solana nodes (Global Node configuration)

Chainstack makes it easy to use the Geyser plugin without running your own validator. With managed Solana RPC nodes and a one-click Yellowstone gRPC Geyser plugin add-on, you can get set up in minutes.

Deploy a Solana node on Chainstack: In the Chainstack console, create a new Solana node. For best performance, select a Global Node deployment – this gives you a geo-distributed, load-balanced RPC endpoint that automatically routes traffic to the closest region for low latency and high availability.
Enable the Geyser plugin add-on: Once your Solana node is up, go to its detail page and enable the Yellowstone gRPC Geyser Plugin under the Add-ons section. Installation takes just a few moments. (Note: The Geyser plugin is available on Growth plans and above, so make sure your subscription includes it.)
Obtain the Geyser endpoint and credentials: After the plugin is installed, you’ll receive a gRPC endpoint URL and API token (e.g. yellowstone-solana-mainnet.core.chainstack.com:443). You’ll use these to connect your client and start streaming real-time data.

Once installed, the Geyser plugin runs automatically: no validator hardware, no plugin compilation. Chainstack handles all of it behind the scenes, giving you a production-ready Geyser endpoint by default. With Global Nodes, traffic is load-balanced across regions for low latency and built to scale under heavy load.

In short, using Chainstack Solana nodes with Geyser gives you a production-ready data pipeline with minimal fuss, plus the stability of a globally distributed network (no single point of failure) and the performance of direct memory streaming.

(For more details, see Chainstack documentation on enabling the Yellowstone Geyser plugin and the advantages of Global Nodes.)

Streaming real-time data for Raydium and Bonk.fun tokens

Once the Geyser plugin is running on your Chainstack node, you can start streaming real-time Solana data and filter it down to the programs you care about. In this case: the Raydium DEX and the Bonk.fun token launchpad.

Both are on-chain programs, so their actions — swaps, liquidity pool creation, token launches — all produce transactions that touch specific program IDs. Filtering the Geyser stream by those program IDs gives you a targeted feed, only events related to Raydium and Bonk.fun come through.

Raydium overview: Raydium runs one of the main AMMs on Solana, powering token swaps across the network. In 2025, it added a Launchpad for new token sales, often just called Raydium Launchpad.

If you’re tracking swap activity or the creation of new liquidity pools, you’ll want to follow the AMM program ID directly. The main ID for Raydium’s v4 AMM is:

LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj

Raydium also uses other program IDs for components like concentrated liquidity and staking, but for now, we’ll focus on the AMM.

Bonk.fun overview: Bonk.fun (previously LetsBonk.fun) is a meme-token launchpad launched on April 25, 2025 by the BONK community and Raydium. It blew up fast. Anyone can create a token, and it’s auto-listed on Raydium as part of the flow.

Every time someone launches a token via Bonk.fun, a Solana transaction is executed on the Bonk.fun program (which likely creates the token mint and initial liquidity provisioning). Bonk.fun quickly overtook the earlier Pump.fun platform – recording over 10,000 token creations and grabbing ~54% of the Solana token launch market by July 2025.

What this means for us is that new token events on Bonk.fun can be detected by watching the Bonk.fun program’s transactions in real time.

Identifying program IDs: To stream these events, you need the program IDs. Raydium’s AMM program ID is known (as above), and let’s assume we have Bonk.fun’s program ID

FfYek5vEz23cMkWsdJwG2oa6EphsvXSHrGpdALN4g6W1

We will configure our Geyser subscription to include these IDs as filters.

Example: Subscribing to program events (Python)

Chainstack’s Geyser endpoint speaks gRPC, so you’ll want a client library to handle the connection.

When it starts, the script reads GEYSER_ENDPOINT, GEYSER_API_TOKEN, and an optional AUTH_TYPE from the environment and opens a TLS-protected channel authenticated with either the default X-Token header or basic auth.

It hard-codes the program IDs for LaunchLab and the LetsBonk platform, along with the eight-byte discriminator that identifies LaunchLab’s initialize instruction. As each transaction arrives, the code skips failed or vote transactions, scans the instructions for that discriminator, and, when found, manually unpacks the nested MintParams, CurveParams, and VestingParams structures to pull out human-readable fields such as token name, symbol, decimals, metadata URI, curve type, vesting schedule, and all relevant account addresses.

Check the full code example in GitHub repo

def create_subscription_request():

"""Create a subscription request for LetsBonk transactions."""

request = geyser_pb2.SubscribeRequest()

# Monitor transactions that include both Raydium LaunchLab and LetsBonk Platform Config request.transactions["letsbonk_filter"].account_required.append(str(RAYDIUM_LAUNCHLAB_ID)) request.transactions["letsbonk_filter"].account_required.append(str(LETSBONK_PLATFORM_CONFIG_ID))

request.transactions["letsbonk_filter"].failed = False request.transactions["letsbonk_filter"].vote = False

request.commitment = geyser_pb2.CommitmentLevel.PROCESSED

return request

def print_token_info(token_info: Dict[str, Any], signature: str):

"""Print formatted token information in a compact format."""

print(f"\n🚀 NEW TOKEN: {token_info.get('name', 'N/A')} ({token_info.get('symbol', 'N/A')})")

print(f" Signature: {signature}")

print(f" Creator: {token_info.get('creator', 'N/A')}")

print(f" Base Mint: {token_info.get('base_mint', 'N/A')}")

print(f" Pool State: {token_info.get('pool_state', 'N/A')}")

print(f" Metadata: {token_info.get('metadata_account', 'N/A')}") if token_info.get('uri'):

print(f" Metadata URI: {token_info['uri']}")

print(" " + "="*60)

Here’s a step-by-step example showing how to wire up Geyser for real-time token tracking:

These details are assembled into a token_info dictionary and immediately logged to stdout. The implementation avoids heavyweight Solana SDKs, depending only on the standard library plus grpc-aio, python-dotenv, base58, and the generated Geyser protobuf stubs, and it keeps secrets outside source control via a .env file.

Integrating the streamed data into analytics pipelines

Once you’re streaming events from Geyser, you can wire them directly into dashboards, storage layers, or bot logic. Here are few ways teams process Raydium and Bonk.fun data in real time:

Real-time dashboard: You can push the incoming data to a WebSocket server or pub/sub system to update a live dashboard. For example, Track Bonk.fun token launches as they’re created, names, creators, metadata, or display swap activity on Raydium by token pair. With Geyser’s sub-second latency, updates appear nearly in real time.
Database and indexing: For more permanent analysis, pipe the data into an analytics database. Write each transaction to a document store or time-series DB. For example, log every Bonk.fun launch with a timestamp, then later query how often tokens are launched or how many hit a certain volume. Raydium swap data can be indexed the same way to track things like pool-level TVL or volume over time.
Alerting and bots: With real-time data, you could build alerting systems. Perhaps you want to be notified if a Bonk.fun token launch exceeds a certain initial liquidity (indicating a potentially serious project), or if a swap of an unusually large size happens on Raydium (could be someone dumping or a big buy). A small script could watch the Geyser stream and trigger alerts (send a message, email, or Telegram via a bot) when conditions are met. In fact, some trading bots use exactly this approach to snipe newly launched tokens – they subscribe to creation events and automatically buy tokens within seconds of launch, gaining an edge over slower methods.

Chainstack Global Node handles the Geyser stream behind the scenes, routing traffic across regions, failing over when a node lags, and scaling under load. Since the data comes structured over gRPC, you don’t need to write custom parsers or deal with missing fields.

Conclusion

The Solana Geyser plugin on Chainstack gives you real-time access to on-chain events. We demonstrated conceptually how Geyser fits into Solana’s architecture as a high-speed data firehose, and we walked through enabling it on Chainstack’s platform (just a few clicks). With a simple TypeScript or Rust client, we can then filter and stream live data for Raydium’s DEX and Bonk.fun’s token launches, among other use cases. This lets you track every new meme token launch as it happens or collect swap data for trend analysis with minimal delay and no extra load on Solana’s RPC servers.

Geyser runs on Chainstack Global Node setup with built-in failover and traffic distribution. It scales under load, and since the data comes through gRPC, it works with Rust, TypeScript, and other common stacks. No extra infra overhead, just stream and filter.