What Is an MEV Searcher? What They Do and How They Get Paid

By Merunas Grincalaitis, founder of MEV DAO and a developer who builds MEV, sniping and trading bots on Ethereum. Last updated: Oct 30, 2026.

TL;DR: An MEV searcher is a person or team that runs bots to find profitable transaction orderings on Ethereum, like arbitrage between DEXes or liquidations on lending protocols, and then sends those transactions to block builders as bundles. Searchers don't produce blocks. They compete to get included, and they pay builders (and through them, validators) a share of the profit, usually with a direct ETH transfer to block.coinbase. Most of the money a searcher finds ends up paid to the builder, which is why the job is about speed, accuracy and a small edge, not about luck.

People ask me what I actually do when I say I build MEV bots. The short answer is that I'm a searcher, and I write software for other searchers. "Searcher" is the job title Flashbots uses in its documentation: the bot operators who look for opportunities like arbitrage and liquidations. This article explains the role from the inside: what a searcher does all day, how searchers fit into the block supply chain, how they get paid and how people get started.

What does an MEV searcher do?

A searcher watches the chain for moments where the order of transactions creates profit, then builds and sends the transactions that capture it before anyone else does. MEV stands for maximal extractable value: the value that can be taken by including, excluding or reordering transactions in a block (ethereum.org overview).

In practice a searcher's day looks like software engineering plus monitoring:

Ingest data. New blocks, pending transactions from the public mempool, and hints from order flow auctions such as MEV-Share.
Keep state. Pool reserves, tick data, lending positions and token balances, updated every block.
Search. Run a strategy over that state to find a profitable trade, for example a price difference between two pools.
Simulate. Execute the candidate trade against the latest state to make sure it really pays after gas.
Submit. Package it as a bundle and send it to one or more block builders.
Review. Check what landed, what lost, and why. Then fix the bot.

The term itself goes back to the 2019 paper "Flash Boys 2.0" by Daian and others, which documented bots fighting over arbitrage in public "priority gas auctions" by raising their gas prices again and again. Flashbots and private bundles came later, partly to move that competition off the public mempool.

Which strategies do MEV searchers run?

Most searchers specialize in one or two strategies, because each one needs its own data, contracts and tuning. These are the common ones on Ethereum:

Strategy	What the bot does	Main skill needed
DEX arbitrage	Buys on one pool and sells on another in one transaction	Fast pricing across many pools and fee tiers
Backrunning	Trades right after a large swap that moved a price	Reading pending transactions or MEV-Share hints
Liquidations	Repays unhealthy loans on Aave, Compound and similar protocols for a bonus	Tracking positions and oracle updates
Sniping	Buys a token in the first block it can be traded	Detecting launches and filtering scams
Sandwiching	Trades before and after a victim's swap	Same as backrunning, but it harms users

I don't build sandwich bots and I don't recommend them. They take money directly from the user being sandwiched. The other strategies either keep prices in line across markets or clean up bad debt, and those are the ones worth building a business on. If you want the money side, I broke it down in how MEV bots make money on Ethereum and who keeps the profit.

How is a searcher different from a builder and a validator?

Searchers find opportunities, builders assemble blocks from many searchers' bundles, and validators propose the block that pays them the most. Since the Merge, most Ethereum blocks are produced through MEV-Boost, which separates these roles. I covered the mechanics in what is MEV-Boost: builders, relays and proposers explained.

Role	What they do	How they get paid
Searcher	Finds MEV and sends bundles	Keeps whatever profit is left after paying the builder
Builder	Merges bundles and transactions into the most valuable block	Keeps the difference between what it receives and what it bids
Relay	Passes blocks from builders to validators and checks them	Usually not paid per block
Validator (proposer)	Picks the highest bid and proposes the block	The winning builder's bid

You can see which builders win the most blocks on public dashboards like mevboost.pics. That matters for a searcher, because sending a bundle to a builder that rarely wins blocks means it rarely lands.

How do MEV searchers get paid?

A searcher keeps the profit from its own trade, minus gas and minus the payment it makes to the builder to win inclusion. The standard pattern is a smart contract that does the trade, checks that it made money, and then sends part of it to block.coinbase, the address receiving fees for that block. Flashbots' coinbase payment docs show an example contract that requires its WETH balance to grow by more than the coinbase payment, so the whole transaction reverts if it doesn't make money.

That design is the heart of the business:

No profit, no cost (mostly). If the trade fails inside a bundle, the bundle isn't included and you don't pay gas for it.
Competition sets your margin. When two searchers see the same arbitrage, the one that pays the builder more usually wins. On popular opportunities, most of the profit ends up with the builder and the validator.
Edge comes from being different. Searchers who earn consistently tend to find opportunities others miss, price them more accurately, or have lower costs.

One detail from the same docs catches people out: sometimes block.coinbase is a smart contract instead of a normal wallet, which makes the transfer cost more gas than many searchers expect.

How do searchers send bundles to builders?

Searchers sign their bundles and send them over JSON-RPC to builder endpoints, such as the Flashbots relay at https://relay.flashbots.net. Per the Flashbots quick start, every request is signed with a separate authentication key. That key doesn't hold funds. It identifies you, builds reputation over time, and that reputation can help your bundles get handled during congestion. For testing, Flashbots runs a Sepolia endpoint at https://relay-sepolia.flashbots.net.

Most serious searchers send the same bundle to several builders, since no single one wins every block. Before sending, they simulate with eth_callBundle to catch reverts and check profit. I wrote practical guides on sending bundles with eth_sendBundle and why they don't land and on simulating a bundle with eth_callBundle.

How do you become an MEV searcher?

Start with one simple strategy, run it on a mainnet fork until it's correct, then go live with small size and study every loss. This is the path I'd follow if I were starting today:

Learn the basics of the EVM and DEX math. You need to read Solidity and calculate Uniswap V2 and V3 swap outputs without calling the chain.
Read open-source bots. Flashbots' simple-arbitrage is an old but clear TypeScript example of cross-DEX arbitrage. Paradigm's Artemis is a Rust framework built around collectors, strategies and executors.
Pick one strategy. Two-pool arbitrage or MEV-Share backrunning is a good first choice. I explained the second in backrunning bot on Ethereum: a first MEV-Share strategy.
Test on a fork. Replay real blocks with Anvil so mistakes cost nothing. See how to test an MEV bot on a mainnet fork with Anvil.
Go live small. Use a fresh executor wallet, keep little ETH in the contract, and log everything.
Measure. Track how many opportunities you saw, how many you sent, how many landed and what you paid the builder. Analytics sites like EigenPhi show what competing bots earned on the same kinds of trades.
Join the community. Flashbots points searchers to its Discord and a searcher self-support forum in the quick start docs.

Language choice matters less than people think at the start. Rust is common for speed-critical bots, which I covered in Rust MEV bot in 2026: the Alloy, Reth and Artemis stack, but a correct TypeScript bot beats a buggy Rust one.

Is being an MEV searcher still worth it?

It can be, but the easy opportunities are gone and most new searchers don't make money at first. The obvious trades are taken by teams with fast infrastructure, so new searchers do better in niches: new protocols, long-tail tokens, other chains or order-flow sources. I went through the numbers and trade-offs in is MEV bot arbitrage still profitable in 2026?

Frequently asked questions

Is an MEV searcher the same as an MEV bot?

Mostly. The searcher is the person or team, and the MEV bot is the software they run. Flashbots uses "searcher" for the bot operator.

Do MEV searchers need to run a validator?

No. Searchers send bundles to builders, and builders deal with validators through MEV-Boost relays. You only need reliable node access and builder endpoints.

What programming languages do MEV searchers use?

Rust, Go and TypeScript are the most common for the bot, with Solidity (sometimes hand-optimized) for the on-chain executor contract.

Do searchers pay gas when their bundle fails?

Not when the bundle simply isn't included. Builders drop bundles that revert, unless you mark a transaction as allowed to revert.

How do MEV searchers find opportunities?

They keep a live copy of pool and protocol state, read new blocks, pending transactions and MEV-Share hints, and run strategies that search for profitable trades on every update.

Being a searcher is mostly patient engineering: better data, better simulation, and honest review of every lost bundle. If you'd rather have a bot built for a specific strategy, that's what I do through custom MEV bot development at MEV DAO.