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.
Why Solana Has No Traditional Mempool
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:
- No global transaction pool. There is no single place where all pending transactions are visible.
- Transactions travel point-to-point. They are forwarded via UDP/QUIC to leader TPU (Transaction Processing Unit) ports.
- The "mempool" is distributed. Each leader holds its own queue of incoming transactions, and that queue is not publicly shared.
- Slot times are fast. At 400ms per slot, the window to observe and react to pending transactions is extremely narrow.
The result is that Solana mempool monitoring is harder, more fragmented, and requires specialized infrastructure — but it is not impossible.
What "Mempool Monitoring" Means on Solana
When people say "Solana mempool monitoring," they typically mean one or more of the following:
- Observing transactions in the leader pipeline before they are confirmed in a block
- Detecting pending bundles submitted through Jito block engine
- Watching for transaction landing via gRPC slot and transaction subscriptions with minimal latency
- Monitoring TPU traffic to see what transactions are being forwarded to upcoming leaders
None of these give you Ethereum-style full mempool visibility. But combined, they provide meaningful insight into transaction flow on Solana.
Jito Block Engine and Bundle Streams
Jito 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.
How Jito Bundle Monitoring Works
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:
- Bundle submissions as they enter the auction
- Bundle tips indicating how much searchers are willing to pay for priority
- Landing status showing whether bundles were included in a block
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
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:
- Detect confirmed transactions faster than nodes relying on gossip propagation
- React to on-chain state changes with sub-second latency
- Build trading strategies that depend on knowing block contents before the wider network
ShredStream access is gated and typically requires running Jito-compatible infrastructure.
Jito Tip Distribution and Priority Analysis
Beyond observing individual bundles, monitoring Jito tip patterns reveals broader market dynamics. By tracking tip amounts over time, you can identify:
- High-competition periods where tips spike, indicating heavy MEV activity on popular token pairs
- Tip floor trends showing the minimum cost to guarantee inclusion via Jito
- Searcher behavior patterns — which wallets are consistently bidding, how aggressively, and on which markets
- Bundle success rates that indicate how saturated the MEV landscape is for specific trading pairs
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.
Transaction Pre-Confirmation Detection
Even without a public mempool, there are several points in the Solana transaction lifecycle where pending transactions become partially observable.
Leader TPU Port Monitoring
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:
- Proximity to validators. You need network-level access or co-location with major validators.
- Packet inspection capability. Transactions arrive as raw packets that need parsing.
- Fast processing. The 400ms slot time means you have a fraction of a second to observe and react.
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.
RPC Transaction Forwarding Observation
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:
- Transactions submitted by your own users
- The volume and type of transactions flowing through your infrastructure
- Patterns that indicate MEV activity (e.g., rapid-fire swaps on the same pair)
This is more useful for analytics and protection than for active mempool monitoring, but it forms part of the broader observation toolkit.
QUIC Protocol and Transaction Forwarding
Solana migrated from UDP to QUIC for transaction forwarding in 2023, which has significant implications for mempool monitoring. QUIC provides:
- Encrypted transport that makes passive packet sniffing more difficult
- Connection-based flow control that limits how many transactions a single client can forward
- Stake-weighted prioritization where validators allocate more QUIC bandwidth to staked connections
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.
gRPC Slot and Transaction Subscriptions
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:
- Slot updates as new slots are confirmed
- Transaction notifications as transactions land in blocks
- Account updates when on-chain state changes
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.
Practical gRPC Monitoring Setup
A typical gRPC monitoring setup for transaction observation looks like this:
- Subscribe to slot updates to know when new blocks are produced
- Filter transactions by program ID (e.g., Raydium, Jupiter, Orca) to isolate DEX activity
- Parse transaction data to extract swap details, amounts, and signers
- Compare timestamps to detect patterns like sandwiching (front-run + back-run within the same slot)
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 and Private Transaction Infrastructure
bloXroute provides a transaction distribution network that offers both speed advantages and MEV protection. Their Solana infrastructure includes:
- Trader API for submitting transactions with optimized routing to leaders
- Transaction stream for observing transactions with low latency
- Private transaction submission that bypasses the public forwarding layer
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.
