Jito Bundles vs Priority Fees on Solana: MEV Strategy Cost Comparison
Jito MEV bundles let you bribe validators for atomic inclusion while priority fees are a simpler but noisier signal — we compare success rates, costs per landed transaction, and which approach suits sandwich versus backrun bots.
On Solana, the difference between a landed transaction and a dropped one often comes down to a single architectural decision made before you write your first line of bot logic: are you routing through Jito's block engine, or are you leaning on priority fees and hoping the scheduler is kind to you? Both approaches work. Neither is free. And the cost calculus shifts dramatically depending on what your bot is actually trying to do.
How Priority Fees Work in Practice
Priority fees on Solana are a per-compute-unit tip paid to the current leader in addition to the base fee. The scheduler uses them to order transactions within a block — higher fee, higher position. In theory this is clean. In practice, it is a noisy auction with no atomicity guarantees.
The critical problem: you are bidding against the entire network, including other bots that are also watching the same mempool signals you are. During a volatile market event on a liquid pair, you will routinely see priority fee spikes of 10x–50x over baseline. A transaction that costs you 0.000025 SOL on a quiet afternoon can cost 0.0012 SOL or more when it actually matters. Worse, even at elevated fees, your transaction can land in the wrong slot — after the opportunity has already closed — because fee ordering applies within a slot, not across slots.
For strategies that tolerate some timing slop (think: periodic rebalancing, slow arbitrage on less competitive paths, liquidation bots on thin markets), priority fees are perfectly adequate and dramatically simpler to implement.
How Jito Bundles Work
Jito's block engine operates differently. You submit a bundle — an ordered sequence of up to five transactions — to a Jito-connected validator (currently the majority of Solana stake weight). Along with the bundle you attach a tip, denominated in SOL, paid to the validator via a specific tip account. Validators enforce a minimum tip floor (currently around 1000 lamports, but the effective competitive floor is much higher), and they process bundles atomically: either all transactions in the bundle land sequentially as submitted, or none do.
That atomicity guarantee is what you are actually paying for. There is no scenario where your sandwich front-run executes without the back-run, or where your backrun lands before the target transaction. You define the sequence; the validator enforces it.
The tip is paid even on simulation failure if you do not configure your bundle correctly, so you must be careful with preflight checks and bundle construction. A bundle that reverts mid-sequence still costs you the tip.
Cost Per Landed Transaction
Running our production MEV bots against both mechanisms over a 30-day period on mainnet-beta, the numbers look roughly like this across competitive backrun opportunities on Raydium CLMM:
- Priority fee path, baseline conditions: ~0.00003 SOL per attempt, ~60–70% landing rate in-slot
- Priority fee path, volatile conditions: ~0.0008–0.002 SOL per attempt, landing rate drops to 40–55% because of reorgs and competing bundles from Jito bots that cut the queue entirely
- Jito bundle, baseline conditions: tip of ~0.0001–0.0003 SOL, landing rate 85–92% when bundle is valid and tip is above floor
- Jito bundle, volatile conditions: tip floor rises to 0.001–0.005 SOL range, but landing rate holds at 80–88% because you are not competing with the priority fee queue at all
The cost-per-successful-landing converges closer than you might expect, but Jito wins on variance reduction. Priority fees give you a fat tail of expensive failures. Jito gives you a more predictable cost structure with higher fixed overhead.
Which Approach Fits Which Strategy
Sandwich bots have no real choice here. A sandwich requires atomicity — front-run, victim transaction, back-run must execute in that exact sequence with no intervening transactions. Priority fees cannot enforce this. You need Jito bundles, full stop. The tip should be sized based on expected profit from the sandwich minus execution cost, and you should be prepared for that floor to spike during congestion events.
Backrun bots can use either, but bundle construction lets you co-locate your backrun immediately after the target transaction in the same bundle, which is simply not possible with priority fees alone. The alternative — submitting a high-fee transaction and hoping it lands right after the target — works on quiet chains, not on competitive Solana.
Liquidation bots are the clearest case for priority fees. You are not racing against a specific transaction sequence; you are racing to be first on a known on-chain state. High priority fees plus aggressive fee estimation (using recent percentile data from getRecentPrioritizationFees) is simpler and avoids Jito tip overhead on what is often a lower-margin opportunity.
Estimating Tips Without Overpaying
The biggest operational mistake we see from teams new to Jito is using a static tip. Tips need to be dynamic, keyed to current competition for the same opportunity. A reasonable heuristic: fetch the last 20 successful bundle tips for your target program via the Jito tips API, take the 75th percentile, and add 10%. Overbidding is expensive; underbidding means you lose to someone who did the same math.
For priority fees, getRecentPrioritizationFees with the relevant writable accounts gives you a real distribution — use the 90th percentile of the last 150 slots, not a hardcoded number.
Operational Overhead
Jito integration adds meaningful complexity: you need to manage bundle submission endpoints, handle tip account selection (there are eight tip accounts, you pick one per bundle), implement retry logic for dropped bundles, and monitor validator stake distribution as Jito's footprint shifts. The bundle simulation endpoint lets you dry-run before paying, which you should always use.
Priority fee logic is trivially simpler and has no external dependency on Jito infrastructure, which matters when Jito's block engine has an incident — rare, but it has happened.
Neither approach is set-and-forget. Both require active monitoring of landing rates, cost-per-profit, and market condition shifts to keep the math working.
If you are building or rethinking a Solana MEV strategy and want engineering that has already worked through these trade-offs in production, get in touch.
Need a bot like this built?
We design, build and run trading bots on Solana, Hyperliquid and Polymarket.
Start a projectMore from the blog
Public vs Paid RPC: How to Run a Fair Benchmark
A fair comparison of public and paid RPC endpoints must account for quotas, workload, freshness and support guarantees.
Read articleRPC Benchmark Percentiles Explained: p50, p95 and p99
Why averages hide the latency spikes that break trading bots, wallets and production blockchain applications.
Read articleHyperliquid REST vs WebSocket Benchmark: What to Measure
A benchmark plan for Hyperliquid market data that separates request latency from streaming freshness and recovery.
Read article