Solana has no traditional mempool, but pending transactions are still observable. Learn how Solana mempool monitoring works with Jito bundles, gRPC streams, leader TPU forwarding, and ShredStream — plus practical tools and use cases for MEV detection, frontrun protection, and latency optimization.
Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.
If you come from Ethereum, you know the mempool as the public waiting room where unconfirmed transactions sit before miners pick them up. Searchers scan it, bots front-run it, and entire MEV strategies revolve around it. On Solana, that waiting room does not exist — yet pending transactions are still observable if you know where to look.
This guide explains what "mempool monitoring" actually means on Solana, the architectural reasons it works differently, and the concrete tools and techniques you can use today to observe, analyze, and react to transactions before they land on-chain.
Ethereum nodes maintain a public transaction pool. Every pending transaction is broadcast to every node, and anyone running a node can inspect the full queue. This is what makes Ethereum MEV so accessible — and so brutal for regular users.
Solana uses a fundamentally different model called Gulf Stream. Instead of broadcasting transactions to every validator, wallets and RPC nodes forward transactions directly to the current and upcoming block leaders. The leader schedule is known in advance (roughly 1.5 slots ahead), so transactions flow toward the validators who will actually produce the next blocks.
This means:
The result is that Solana mempool monitoring is harder, more fragmented, and requires specialized infrastructure — but it is not impossible.
When people say "Solana mempool monitoring," they typically mean one or more of the following:
None of these give you Ethereum-style full mempool visibility. But combined, they provide meaningful insight into transaction flow on Solana.
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
Telegram trading bot for Solana — snipe new tokens, set limit orders, auto-sell, and copy trade with built-in MEV protection
MCP server powered by Solana Agent Kit for on-chain actions
Browser-based IDE for developing and deploying Solana programs
Native Solana support inside the MetaMask browser wallet
Community-driven developer resource with code recipes for building on Solana
Build your own trading bot
KOL copy-trading, deployer sniping, and DEX trade streaming — all via API.
Pro & Ultra include a 5-day free trial — by card, cancel anytime.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: "msk_your_key" });
// Mirror KOL trades in real-time
const { trades } = await client.kol.feed({ action: "buy" });
// Set up webhooks for instant alerts
const webhook = await client.webhooks.create({
url: "https://your-bot.com/hook",
events: ["kol:trade", "deployer:alert"],
});Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Trading
Understand how Solana transaction bundling works, why token launches use bundle buys on Pump.fun, and how to detect bundled tokens as a trader.
Developer Tools
How Solana gRPC streaming really works with Yellowstone Geyser — setup, subscription filters, and the connection-leak, memory, and reconnection gotchas we hit running a dual-region firehose in production. Written from a live pipeline, not a docs page.
Trading
Learn how MEV works on Solana, what sandwich attacks and front-running actually cost you, and practical strategies to protect your trades using Jito tips, priority fees, private transactions, and slippage settings.
Guides
Jito block engine lets searchers submit 5-tx bundles with tips. How MEV works on Solana, why bundles cap at 5, and how to send your first via REST.
Guides
Everything you need to know about Solana transaction fees in 2026. Understand base fees, priority fees, Jito tips, compute units, and practical strategies to reduce costs without sacrificing speed.
Guides
Learn what MEV bots are, how sandwich attacks work on Solana, how much money they've stolen from traders, and the exact steps you can take to protect yourself.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.
Open the KOL TrackerJito operates a modified validator client that processes transaction bundles — ordered groups of transactions that execute atomically. The Jito block engine is the closest thing Solana has to a structured pre-confirmation layer.
When a searcher submits a bundle to Jito block engine, the bundle goes through an auction process. Bundles with higher tips get priority. If you have access to the Jito bundle stream (via their Block Engine API), you can observe:
This is valuable for MEV detection. If you see a bundle containing a swap on the same token pair you are trading, you know someone is likely attempting to extract value from that market. For a deeper dive into how Jito bundles work, see our Jito and MEV explainer.
Jito ShredStream gives validators and infrastructure operators access to shreds (the smallest unit of block data on Solana) with lower latency than the standard gossip network. While this is not mempool monitoring in the traditional sense, it allows you to:
ShredStream access is gated and typically requires running Jito-compatible infrastructure.
Beyond observing individual bundles, monitoring Jito tip patterns reveals broader market dynamics. By tracking tip amounts over time, you can identify:
This intelligence helps traders calibrate their own Jito tips. If you know the current tip floor for your target market, you can set tips that guarantee priority without overpaying. On the other side of the trade, these tips are a meaningful revenue line for the validators producing the blocks — our breakdown of Solana validator economics quantifies how much MEV actually adds to validator earnings.
Even without a public mempool, there are several points in the Solana transaction lifecycle where pending transactions become partially observable.
Every Solana leader exposes TPU ports (UDP and QUIC) that accept incoming transactions. If you run infrastructure close to a leader node, you can potentially observe transactions as they arrive at the TPU. This requires:
In practice, TPU monitoring is used by sophisticated MEV operations and high-frequency trading firms. It is not accessible to casual developers, but understanding it helps explain how front-running occurs on Solana despite the absence of a public mempool.
When you send a transaction through an RPC provider like Helius or Triton, the RPC node forwards your transaction to the current leader. If you control or operate an RPC node, you can observe the transactions passing through it. This gives visibility into:
This is more useful for analytics and protection than for active mempool monitoring, but it forms part of the broader observation toolkit.
Solana migrated from UDP to QUIC for transaction forwarding in 2023, which has significant implications for mempool monitoring. QUIC provides:
This means that observing raw transaction forwarding traffic is harder than it was in the UDP era. Passive network monitoring approaches that worked before QUIC are now largely ineffective, pushing monitoring further toward gRPC subscriptions and Jito bundle observation as the primary data sources.
The most practical approach to near-real-time transaction monitoring on Solana is gRPC streaming via Yellowstone (Geyser) plugins. Providers like Helius and Triton offer gRPC endpoints that stream:
While gRPC streams show confirmed transactions (not pending ones), the latency is low enough — typically 100-400ms after slot confirmation — that they serve as the primary monitoring layer for most Solana trading infrastructure.
A typical gRPC monitoring setup for transaction observation looks like this:
For a hands-on walkthrough, see our Solana gRPC streaming guide. The latency difference between gRPC and WebSocket RPC methods is significant — gRPC typically delivers data 200-500ms faster than onLogs or onAccountChange subscriptions.
bloXroute provides a transaction distribution network that offers both speed advantages and MEV protection. Their Solana infrastructure includes:
bloXroute maintains direct connections to a large percentage of Solana validators, giving them faster transaction propagation and the ability to offer partial mempool-like visibility into transaction flow.
To understand where monitoring is possible, it helps to trace a transaction through its full lifecycle on Solana:
Observation is theoretically possible at steps 2, 3, 4, and 5. In practice, steps 2-3 require operating or tapping into RPC infrastructure, step 4 requires proximity to the leader node, and step 5 is where gRPC and ShredStream monitoring operate. Each step offers a different tradeoff between latency, accessibility, and reliability.
Monitoring transaction flow helps identify MEV activity in real-time. By watching for patterns — multiple transactions on the same token pair within a single slot, unusually high Jito tips, or rapid sequential swaps from known MEV wallets — you can quantify how much MEV is being extracted from a given market.
This data is valuable for researchers, protocol developers building MEV-resistant systems, and traders who want to understand the true cost of their executions. For strategies on protecting yourself, read our MEV protection guide.
Understanding how transaction observation works on Solana is the first step to protecting against it. If you know that MEV bots monitor leader TPU traffic and Jito bundles, you can take countermeasures:
Our sandwich attack explainer covers the mechanics in detail.
Arbitrage bots rely on detecting price discrepancies across DEX pools faster than competitors. By monitoring transaction streams, you can observe:
The key advantage of gRPC monitoring over polling is that you receive these events as they happen rather than discovering them on your next poll cycle. For arbitrage, the difference between 100ms and 600ms detection time can be the difference between capturing a spread and missing it entirely.
For trading bots and automated strategies, the speed at which you observe and react to on-chain events directly impacts profitability. Mempool monitoring techniques help you:
The difference between gRPC streaming and polling RPC endpoints can be 500ms or more — an eternity in competitive Solana trading.
DeFi protocols use transaction monitoring to track:
| Approach | Latency | Accessibility | What You See |
|---|---|---|---|
| Jito Bundle Stream | Pre-confirmation | Gated API access | Bundle submissions, tips, landing status |
| Jito ShredStream | Sub-gossip | Validator/infra operators | Confirmed shreds before gossip propagation |
| Leader TPU Monitoring | Pre-confirmation | Co-location required | Raw incoming transactions |
| gRPC (Yellowstone) | 100-400ms post-slot | Public via RPC providers | Confirmed transactions, account updates |
| RPC WebSocket | 300-800ms post-slot | Public | Confirmed transactions (higher latency) |
| bloXroute Stream | Near-confirmation | Paid API | Transaction flow through their network |
Your choice depends on what you are building:
For most developers, gRPC streaming through a reliable provider is the right starting point. It gives you confirmed transaction data with low enough latency to build useful monitoring, alerting, and trading systems without the complexity of TPU-level infrastructure.
Before investing in mempool monitoring infrastructure, understand what it cannot do on Solana:
The most practical approach for most teams is to use mempool monitoring defensively — protecting your own transactions and users rather than trying to extract MEV from others.
No, Solana does not have a public mempool where all pending transactions are visible before confirmation. Solana uses Gulf Stream, which forwards transactions directly to the current and next slot leaders via their TPU ports. This means pending transactions are distributed across leader nodes rather than sitting in a shared pool. The closest equivalent is observing Jito bundle submissions or monitoring leader TPU traffic, both of which require specialized access and infrastructure.
gRPC streaming via Yellowstone (Geyser) plugins is the most practical high-speed option for most developers. Providers like Helius and Triton offer gRPC endpoints that deliver confirmed transaction data within 100-400ms of slot confirmation. For even lower latency, Jito ShredStream provides shred-level data before gossip propagation, but requires validator-grade infrastructure. Leader TPU monitoring offers pre-confirmation visibility but demands co-location with validators. For most trading applications, gRPC provides the best balance of speed, cost, and accessibility.
Yes, and this is one of its most popular applications. By subscribing to gRPC transaction streams filtered for pool creation events on Raydium, Meteora, or Pump.fun, you can detect new token launches within seconds of liquidity being added. However, the fastest detection methods — those that give you a meaningful edge for sniping — require optimized infrastructure and pre-built transaction templates. Most public gRPC providers deliver launch data fast enough for analysis but not fast enough to compete with dedicated sniping bots.
MEV bots on Solana use several techniques to identify profitable transactions. They monitor gRPC streams for large swaps, watch Jito bundle auctions for arbitrage opportunities, and in some cases operate infrastructure close to leader nodes to observe TPU traffic. Because Solana slot time is 400ms, bots must operate with extremely low latency. Many use Jito bundles to submit atomic front-run and back-run transactions together, guaranteeing execution order within a slot. See our Jito bundles explained and Solana priority fees guide for the mechanics behind both.
Observing public blockchain data — including transaction streams and confirmed block contents — is legal. Solana is a public, permissionless network, and anyone can run a validator or subscribe to gRPC streams. However, actively front-running other users’ transactions raises ethical questions, and some jurisdictions may classify certain MEV extraction strategies as market manipulation. The tools and techniques described in this guide are primarily useful for defense, analytics, and infrastructure optimization rather than predatory MEV extraction.