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.
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.
The Solana Transaction Lifecycle: Where Observation Happens
To understand where monitoring is possible, it helps to trace a transaction through its full lifecycle on Solana:
- User signs transaction. The wallet creates and signs a transaction locally.
- RPC receives transaction. The wallet sends the signed transaction to an RPC node via sendTransaction.
- RPC forwards to leader. The RPC node identifies the current and next slot leaders from the leader schedule, then forwards the transaction via QUIC to their TPU ports.
- Leader queues transaction. The leader receives the transaction and places it in its processing queue alongside thousands of others.
- Leader executes and confirms. During its slot, the leader executes transactions, produces a block, and broadcasts shreds to the network.
- Validators confirm. Other validators receive shreds, replay the block, and vote on it. After sufficient votes, the transaction reaches finalized status.
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.
Use Cases for Solana Mempool Monitoring
MEV Detection and Analysis
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:
- Use private transaction submission via Jito or bloXroute
- Set tight slippage tolerances so sandwich attacks become unprofitable
- Submit transactions with Jito tips to ensure priority ordering
- Avoid public RPC nodes that may leak your transaction to searchers
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:
- Cross-DEX price divergence when a large swap on Raydium moves the price but Orca has not yet adjusted
- Lending protocol health factors approaching liquidation thresholds on platforms like MarginFi or Kamino
- Oracle update transactions that trigger cascading liquidations across multiple positions
- New pool creation events that present early arbitrage windows before prices stabilize
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.
Trading Latency Optimization
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:
- Detect new token listings the moment liquidity is added
- React to large trades that will move prices
- Identify liquidation opportunities before other bots
- Confirm your own transactions landed and adjust strategy accordingly
The difference between gRPC streaming and polling RPC endpoints can be 500ms or more — an eternity in competitive Solana trading.
Protocol Health Monitoring
DeFi protocols use transaction monitoring to track:
- Unusual trading patterns that may indicate an exploit
- Liquidity removal events that could signal rug pulls
- Oracle update transactions that affect lending liquidations
- Governance proposal executions
Comparing Monitoring Approaches
| 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 |
Choosing the Right Tool
Your choice depends on what you are building:
- Trading bots that need speed: gRPC via Helius or Triton for confirmed data, plus Jito bundle submission for execution priority.
- MEV research and analytics: Jito block engine API for bundle data, combined with gRPC for on-chain confirmation analysis.
- Frontrun protection for dApps: Private transaction routes via Jito or bloXroute, plus education for your users on slippage settings.
- Infrastructure monitoring: gRPC subscriptions filtered by program ID, with alerting on anomalous patterns.
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.
Limitations and Realistic Expectations
Before investing in mempool monitoring infrastructure, understand what it cannot do on Solana:
- You cannot see every pending transaction. Unlike Ethereum, there is no way to observe all transactions before they land on-chain. The best you can do is observe subsets — through your own RPC, Jito bundles, or co-located infrastructure.
- Latency floors are real. Even with the fastest gRPC provider, you are seeing confirmed transactions, not pending ones. The 100-400ms post-slot window is a physical constraint of the network.
- Infrastructure costs scale quickly. Running co-located validators, maintaining ShredStream access, and operating high-throughput gRPC consumers requires significant investment. Most teams should start with managed RPC providers before building custom infrastructure.
- Competition is intense. Professional MEV searchers have spent years optimizing their infrastructure. A new entrant using basic gRPC monitoring will not outcompete established operations on pure speed alone.
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.
Frequently Asked Questions
Can you see pending transactions on Solana like on Ethereum?
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.
What is the fastest way to detect new transactions on Solana?
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.
Does Solana mempool monitoring work for detecting new token launches?
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.
How do MEV bots on Solana find transactions to front-run?
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.
Is Solana mempool monitoring legal?
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.
