Jito on Solana: Bundles, Tips, and MEV Explained

What MEV actually is on Solana

MEV - maximal extractable value - is the profit available to whoever decides what goes into a block and in what order. If a swap is about to move a price, the actor who lands a transaction just before and just after it captures the difference. The value isn't created by the trade; it's extracted from the ordering of trades.

On a single-leader-per-slot chain like Solana, ordering power sits with the current leader. Left unmanaged, that turns into a chaotic spam race: everyone fires duplicate transactions at the leader and hopes theirs lands in the right spot. Jito exists to replace that race with an auction - a cleaner, more efficient way to decide who gets the ordering they're willing to pay for.

MEV is not about sending more transactions. It's about deciding what lands and in what order - and being willing to pay for that decision.

The Jito Block Engine and the bundle auction

The Jito Block Engine is a piece of infrastructure that sits between searchers and leaders. It accepts bundles from searchers, runs a sealed-bid auction on the tips attached to them, and forwards the winning bundles to the current leader for inclusion in the block.

The flow is straightforward:

1. A searcher spots an opportunity and constructs a bundle that captures it.
2. The bundle is submitted to the Block Engine with a tip - the bid.
3. The Block Engine runs a short auction across competing bundles for the upcoming slots.
4. The highest-value bundles win, and are forwarded to the leader in the order and bid they committed to.

Because the auction is sealed-bid and time-boxed to the leader's slots, the searcher's whole job collapses into two questions: did I see the opportunity early enough to build a bundle, and did I bid enough to win it? The first question is upstream of Jito entirely - we'll come back to it.

Bundles: atomic, ordered, all-or-nothing

A bundle is an ordered list of up to five transactions with three guarantees that a loose pile of transactions can never offer:

• Atomic. Either the whole bundle lands or none of it does.
• Ordered. The transactions execute in the exact sequence you specified, with nothing interleaved between them.
• All-or-nothing. If any transaction in the bundle would fail, the entire bundle is dropped - you don't land a half-finished strategy.

That guarantee is the whole point. An arbitrage that buys on one venue and sells on another is only safe if both legs land together, in order, with no hostile transaction wedged in the middle. As two separate transactions you're exposed; as a bundle you're not.

// atomic, ordered, tip-bid execution via the Jito Block Engine
const result = await rpcedge.sendBundle({
  transactions: [setupTx, arbTx, cleanupTx], // all-or-nothing, in this order
  tipLamports: estimateTip(),                 // your bid in the auction
});
 
// the bundle lands whole, in order, or not at all

The tip is paid inside the bundle to a Jito tip account, so it only leaves your wallet if the bundle actually wins and lands. You don't burn the bid on a loss.

Tips vs priority fees: not the same thing

This trips up a lot of teams. A priority fee and a Jito tip both cost lamports and both improve your odds, but they act on different mechanisms and you should think about them separately.

Searchers and the strategies they run

A searcher is whoever builds bundles to capture MEV. The strategies cluster into a few recognizable shapes:

• Arbitrage. A price diverges across two venues for a moment. The searcher buys on the cheap one and sells on the expensive one in a single atomic bundle, capturing the spread with no inventory risk.
• Liquidations. A lending position crosses its threshold. The searcher races to be the one who liquidates it and collects the bonus, which is pure ordering: first valid liquidation wins.
• Sniping. A new pool launches or liquidity is added. The searcher wants to land in the very first transactions against it, before the crowd reprices the asset.

Every one of these is a contest decided at the millisecond level, and every one of them is won in two stages: see it first, then bid to land it. Jito handles the bidding stage cleanly. The seeing stage is where most of the real edge lives, and Jito doesn't give you that.

The upstream edge: seeing the opportunity first

A perfectly tuned tip on a bundle you built too late is a losing bundle. By the time an opportunity shows up in a confirmed RPC response, the network has already received, replayed, voted on, and settled the transaction that created it - and so has every competitor. You're all bidding on yesterday's news.

The opportunity exists much earlier, at the moment data is propagating across the cluster - the shred layer. Decoding transactions directly from decoded shreds gives you a first-seen, pre-confirmation view of the swap that's about to move a price, milliseconds before a confirmed RPC call would surface it. That head start is what lets you build the bundle while the opportunity is still live. We went deep on this in reading decoded transactions before confirmation.

So the real searcher pipeline has two halves: an upstream data edge that surfaces the opportunity early, and a downstream delivery edge that gets the bundle to the Block Engine and the leader fast. Jito is the second half. It only pays off if the first half is feeding it opportunities your competition hasn't seen yet.

When you need Jito - and when you don't

Jito is the right tool, and the wrong tool, in clearly different situations.

Reach for Jito when:

• You need atomic, ordered execution of multiple transactions - arbitrage legs, a setup plus an action, a multi-step strategy that's unsafe split apart.
• You're competing for inclusion against other searchers and want to bid for ordering rather than spam-race for it.
• The strategy is fundamentally about what lands and in what order, not just speed.

Skip Jito and send directly when:

• You have a single transaction you just want to land fast and cheap.
• You don't need ordering guarantees or atomicity across multiple transactions.
• You're not bidding against anyone for a specific slot position.

For that second case the right tool is direct delivery to the current and upcoming leaders' TPUs with a sensible priority fee - exactly what a purpose-built transaction sender does, and what we covered in landing transactions on Solana. The strongest trading stacks use both paths and pick per strategy.

Location is still half the race

Every part of this is a delivery race, and delivery races are won by proximity. A searcher a region away from the Block Engine is paying network distance on every bundle submission and every opportunity it ingests. rpc edge runs its infrastructure beside Solana stake clusters and the Jito Block Engine, and for teams that want to colocate their own logic, on dedicated nodes next to the cluster. The path from your bundle to the auction is as short as physics allows.

The takeaway

Jito turns Solana's ordering contest into an auction: build a bundle, attach a tip, and the highest bids win inclusion and ordering. Bundles give you atomicity that loose transactions never can, and tips are a separate lever from priority fees. But the auction is only the second half of the job. The first half - seeing the opportunity before anyone else - is a data problem solved upstream at the shred layer. Win that, feed it into Jito, and put it all next to the cluster. That's how MEV is actually contested on Solana.