How to Detect MEV in Your Trades 2026: A Practical Guide

Answer first — To detect MEV against your own trades in 2026, follow a four-step forensic process: (1) pull the transaction receipt and identify the block; (2) inspect adjacent transactions in the same block for matching pool/matching tokens; (3) compare your effective price to the pool's pre-trade quote; (4) attribute the slippage to MEV (sandwich/back-run) vs natural price impact vs ordering luck. Tools that make this fast: EigenPhi, MEV-Inspect-py, Etherscan's MEV labels, and Libmev. For Solana: Eclipse and Jito-Explorer. Most retail traders discover they're being sandwiched on 5–20% of their swaps once they actually look.

Why Bother Detecting

Three reasons:

1. 
   Routing changes. If Aggregator A leaks 12 bps per swap on average and Aggregator B leaks 3 bps, you switch.


2. 
   Behavioral changes. If you're being sandwiched mostly on trades > $5,000, you split orders or use a private mempool.


3. 
   Real loss accounting. MEV is a real, quantifiable trading cost. Most people underestimate it because they never measure it.

Step 1: Pull The Transaction Receipt

Find your trade's transaction hash. From the receipt, you need:

• The block number
  


• The transaction index within the block (your position in the ordering)


• The pool address you swapped against


• The token amounts you swapped (in and out)


• The gas paid and the priority fee paid
  

On Etherscan, all of this is on the transaction detail page. Programmatically: eth_getTransactionByHash + eth_getTransactionReceipt.

Step 2: Inspect Adjacent Transactions

Look at the transactions in the same block, ordered by index. Two patterns indicate MEV:

Pattern A: Sandwich (Front-Run / Back-Run)

If you see:

• 
  Transaction (your index - 1): A swap on the same pool in the same direction as yours


• 
  Transaction (your index + 1): A swap on the same pool in the opposite direction
  

That's a classic sandwich. The front-run pushed the price up before your fill, your trade filled at the worse price, and the back-run captured the imbalance.

Pattern B: Back-Run (No Front-Run)

If you see no front-run, but a same-pool opposite-direction swap immediately after yours — that's a pure back-run. Less damaging to you (doesn't change your fill price), but indicates your trade was visible in the mempool.

Pattern C: JIT Liquidity

If you see IncreaseLiquidity then DecreaseLiquidity on the same pool with very small intervening swap count — that's JIT (just-in-time) liquidity. A searcher added liquidity, captured your trade's fee, and removed it.

Step 3: Compare Effective Price To Pool Quote

Independent of pattern detection, do a price comparison:

1. Note the pool reserves (or tick state for V3) at block N-1


2. Compute the expected output of your trade against those reserves


3. Compare to your actual output from the receipt

Formula:

mev_loss_bps = (expected_output - actual_output) / expected_output * 10000 - expected_price_impact_bps

If mev_loss_bps > 5–10 and you can match the front-run/back-run pattern, you've been sandwiched.

Step 4: Attribute The Slippage

Most real-world slippage on retail swaps is a mix. The MEV component is typically 3–25 bps for small public-mempool swaps, larger for big swaps and long-tail tokens.

Tools That Do The Heavy Lifting

EigenPhi

Best-in-class MEV analytics. Paste a transaction hash → labeled breakdown: sandwich front-run, victim, back-run, profit captured. Works for Ethereum mainnet, several L2s, and BNB Chain.

MEV-Inspect-py (Flashbots)

Open-source library that classifies MEV-extraction patterns from block data. Best for running your own analysis on your trading history. Requires a full node or archive RPC.

Etherscan's MEV labels

Etherscan tags known MEV bot addresses and shows MEV-extracted value in the block detail view. Quick and accessible.

Libmev

Open-source library and dashboard. Good for self-hosted analysts who want a Web UI without paying for EigenPhi's enterprise tier.

Solana-specific: Jito-Explorer + Eclipse

For Solana trades, Jito's bundle explorer shows tipped transactions and bundle composition. Eclipse offers MEV analytics with sandwich detection on major DEX programs.

Quick-Look Workflow (5 minutes)

1. Copy your transaction hash


2. Paste into EigenPhi (free tier covers most retail-size trades)


3. Look at the "Victim Loss" field — that's your MEV cost in USD


4. If significant, check whether the trade went through a public mempool. If yes, your routing leaked.

What Detection Tells You About Routing

Patterns you'll see repeatedly:

• 
  Public-mempool swaps on long-tail tokens: MEV leakage ranges 15–80 bps. Routing through aggregators with private orderflow (1inch Fusion, CoW, Paraswap Delta) typically cuts this to <3 bps.


• 
  Large swaps on blue-chip pairs: Even on major pairs, swaps above ~$50k consistently leak 5–20 bps to back-running.


• 
  Small swaps: For <$500 trades, gas costs dominate and MEV loss is usually <$0.50.

What To Do With The Data

Action 1: Change Routing

Switch to a private-orderflow aggregator (1inch Fusion, CoW, Paraswap Delta) or submit through a private relay.

Action 2: Use Private Mempool

For sniper-style trades, submit through Flashbots Protect, MEV-Share, or your chain's equivalent.

Action 3: Split And Time Trades

For large trades, split into chunks below the threshold where MEV becomes cost-effective for searchers (~$5,000-$10,000 on mainnet).

Bottom Line

If you've never measured MEV against your own trades, you're almost certainly losing more than you think. The tools take 5 minutes to learn. Most retail traders cut their MEV exposure by 60–90% within a month of starting to measure — the act of looking changes the routing decisions.

Full post + FAQ at .