Battling MEV: Merkle’s Private Mempool Service Deep Dive

Merkle is a private mempool infrastructure provider that protects transactions their users are making by processing them via private mempools. As a result, the interactions with blockchain are more secure and shielded from malicious MEV bots.

That said, in today’s blockchain systems, Maximal Extractable Value (MEV) is one of the biggest threats to DeFi users and dApp developers. So in this blog post, we’ll focus on what MEV is exactly and why it isn’t just an occasional annoyance for crypto users.

We’ll then explore Merkle’s design, how it helps to neutralize the negative impact of MEV, and show our users how to plug Merkle into their workflow to start protecting their transactions.

What is Merkle? Key takeaways

MEV is a side‑effect of how public blockchains work. While some MEV (like arbitrage or liquidations) can be economically neutral or even beneficial, most MEV extraction occurs at the expense of other users, directly worsening their onchain experience.

Therefore, when designing MEV protection, the core focus is on blocking toxic MEV and allowing beneficial value extraction strategies.

Merkle, a private mempool service, does exactly that by (a) hiding users’ raw transactions in a private pool – so no bot can see and front‑run them – and (b) running a back‑run‑only auction, where only post‑trade arbitrages or liquidations can compete to capture value.

The service is multichain, currently supporting Ethereum, BSC, Base, Solana, and Unichain, offering developers on these chains a plug-and-play MEV shield.

RPC infrastructure providers are also adopting Merkle. Starting May 2025, GetBlock also routes RPC requests submitted to its shared-node infrastructure through Merkle’s backend via the free MEV-protected RPC endpoints service.

The MEV problem

Before we learn how MEV issues can be solved with Merkle, we need to understand what MEV is exactly.

What is MEV?

MEV, the Maximal Extractable Value, is the additional profit that can be captured from the blockchains in a way that blockchain engineers didn’t explicitly intend – via reordering transactions in the block or inserting new transactions into the block.

It involves watching onchain activity for opportunities, typically:

Large pending trades that will move prices,

Price differences (arbitrage) across exchanges,

Slippage in large swaps,

Liquidation events on lending platforms about to trigger,

— and then submitting transactions in the right sequence and timing to capture profit.

Historically, it was miners (hence “Miner Extractable Value”) who ordered, included, or censored transactions in blocks to capture those gains. In Proof‑of‑Stake, that role transfers to validators or, more recently, to block builders.

Today, we often talk about searchers, usually bots that detect opportunities algorithmically, simulate various strategies, and submit profitable transactions at machine speed.

Popular MEV strategies in crypto

The table below describes the most common types of MEV with examples.

MEV Type	Description	Example
Arbitrage	Exploiting price differences for the same asset across different DEXes or liquidity pools	Token X trades for $100 on DEX  A but $150 on DEX B. Buy on A and sell on B, locking in the $50 difference
Front‑running	Inserting a transaction before a pending trade	Placing the buy order before a pending large buy order (pushing the price up), then selling tokens for profit
Back‑running	Submitting a transaction after a profitable trade	Submitting a buy right after the large trade to capture the dip before price rebounds
Sandwich Attacks	Combination of front- and back-running	Placing a buy order just before a large trade (to push the price up), and selling immediately after (to capture gap as profit)
Liquidations	Triggering under‑collateralized loans for a bonus	A borrower’s collateral becomes under‑collateralized on a lending protocol. The Searcher transaction repays the bad debt and seizes the collateral

Typical MEV searchers turn these strategies into real profit via different complex mechanisms. The simpler one is paying extra gas to the validator so that their transaction jumps to the front of the block. Another method is to package target transactions with their own (e.g., buy-then-sell sandwich legs) into an atomic bundle.

The bad and the good: benefits and harmful effects of MEV

As we see, MEV takes many different forms in crypto. Yet, there are strategies that, in the big picture, help the health of the system, e.g.:

Arbitrage: Buying low on one exchange while selling high on the other aligns prices across DEXs and CEXs.

Liquidations: If nobody steps in to liquidate an under-collateralised position, the pool’s remaining depositors would have to absorb the loss.

Both arbitrage and liquidation bots compete via backrunning, so they don’t usually hurt other users.

On the far less bright side, most of the MEV “in the wild” today is toxic, meaning it takes value away directly from ordinary users. The consequences are unfavourable:

Front‑running: The trader ends up buying at a worse price because the front‑runner’s trade shifts the price before this.

Sandwich attacks: A DEX user will pay extra slippage because the bot has artificially inflated the price just before their swap; then it’s the bot that profits from selling into that same swap order.

Priority gas wars: Bots flood the chain with high‑fee bids – especially on low‑cost chains – crowding out normal users. As a result, other transactions either fail or end up paying far more in fees.

The chart below shows where trades actually land (“realised price”) versus where users think they’ll land (“quoted price”) on an AMM – both with and without active MEV bots. With aggressive MEV searchers, users are almost guaranteed to pay the worst price, because bots will exploit the slippage buffer to skim value.

Chart showing MEV impact on quoted vs realized AMM prices, illustrating slippage and worst-acceptable price

Source: 0x

These examples primarily cover DeFi scenarios, as MEV hunters tend to follow large trades. However, any on‑chain action that affects price or state can be exploited if it’s visible to MEV bots. Think NFT mints and sales, bridge deposits, etc.

What is a mempool, and why you should care

For a successful MEV attempt, the MEV hunter needs to know that there's a trade in the first place; and currently, this is what public, transparent, permissionless chains allow.

Malicious bots spot pending transactions in the public mempool, short for “memory pool”. This is the holding area where nodes store transactions before they’re packed into blocks.

Because blockchain nodes broadcast transactions here first, anyone running a watcher bot can inspect every detail of each transaction in real time. This includes:

Metadata: e.g. sender, fee parameters, value, destination;

Payload: calldata / instruction data, with signatures, smart contract identifier, encoded parameters (slippage tolerances, order prices, routes, etc).

Etherscan-style pending transaction details (gas, nonce, calldata) illustrating public mempool visibility used by MEV bots

Source: Etherscan pending transactions

All of that gives MEV searchers full visibility to reorder or sandwich any unprotected transaction. One powerful defense is to bypass the public mempool entirely. And this is the solution that Merkle offers.

Merkle’s MEV solutions: Private mempools and fast block inclusion

Merkle is an MEV infrastructure platform. It operates a private transaction pool across multiple chains, currently supporting major EVM and non-EVM networks like Ethereum, BSC (BNB Smart Chain), Base, Unichain, and Solana.

In Merkle’s model, a user’s signed transaction is submitted via a protected endpoint and fed into a private queue, where it stays invisible to the rest of the network until it’s actually included in a newly produced block.

This approach helps fully protect users from malicious MEV, but provides an environment where user‑benefitting mechanisms can be allowed.

Merkle has grown rapidly since its February 2023 launch. According to its website, Merkle’s private pool processes on the order of 15 million transactions per day, over 4 billion total so far.

Looking forward, Merkle’s roadmap hints at expanding chain support and product features. On Ethereum-land, the company has announced projects like an MEV-protected DEX called MEVSwap. They also work on niche infrastructure: e.g., multi-builder bundle payment for BSC and RETH node snapshots support.

How Merkle works

When a user sends a signed transaction to Merkle:

The transaction occurs in its private pool: It is never broadcast to the public mempool.

Broadcast to builders: Merkle forwards the user’s transaction to multiple block builders.

In effect, Merkle’s pool becomes the de facto transaction ordering engine for its users with several benefits:

Because transactions never broadcast publicly, bots in the outside world cannot get any information to attack – sandwich or front-running attempts fail.

By feeding transactions to multiple builders, Merkle maximizes its inclusion chances, too.

On each supported chain, Merkle runs its own full-node clusters and a custom RPC load balancer to ensure high throughput, availability, and low latency.

MEV opportunities with Merkle

Merkle‘s system allows types of MEV that are beneficial to everyone via transparent auctions that permit backruns only. This means searchers can add a transaction after the user’s in the block, but never before it – i.e., insert an arbitrage or liquidation trade.

Merkle provides APIs and WebSocket endpoints for bidding on live transactions, so bots can choose to bid on a Merkle. In practice:

If bids arrive, the highest bid wins.

Merkle then creates the user+backrun bundle and immediately pushes it to builders.

The user transaction is also sent directly in the event of bundle failure, so it will still be mined.

Diagram of Merkle private mempool auction flow

Image source: Merkle

Merkle’s auctions are designed to return value to the user in the form of better execution, arbitrage rebates, or a share of revenue.

How to start using Merkle for MEV protection

Merkle provides RPC endpoints with usage limits that wallets and dApps can plug into:

eth.merkle.io for Ethereum

bsc.merkle.io for BNB Smart Chain

To the client application, transaction submission works the same way – Merkle’s endpoint simply guarantees better ordering and privacy under the hood.

Thanks to its architecture, Merkle can add MEV protection to any compatible RPC service. GetBlock, a major RPC-as-a-service provider, announced in May 2025 that its endpoints for Ethereum, BNB Smart Chain, Base, and Solana now have built-in MEV protection via Merkle.

GetBlock’s clients – Web3 dApps, exchanges, NFT platforms, traders – can now have out-of-the-box MEV defense by simply switching a regular GetBlock endpoint to a protected JSON-RPC endpoint.

Here’s how protected endpoints are easily created via GetBlock’s user account:

Open the “Shared nodes” tab and click on “Get”.

In the pop-up that opens, choose a supported chain (Ethereum, Base, BSC, or Solana) in the mainnet.

Make sure to select “MEV protected (JSON-RPC)” under the API interface.

Creating MEV-protected JSON-RPC Ethereum RPC endpoint using GetBlock

Source: GetBlock

Finish the endpoint setup by choosing the node cluster region, and get a ready-to-use RPC URL. Every transaction posted via this URL will be proxied straight into Merkle’s private pool, safeguarded against MEV, plus get a better inclusion priority.

Only a month after integration, GetBlock has processed over 8 million user RPC calls via Merkle‑powered JSON‑RPC endpoints.

Note: No extra cost or setup is required – the option is included in any paid shared infrastructure plan.

Sending protected transactions via GetBlock

Behind the scenes, Merkle’s endpoint still proxies standard Ethereum and Solana JSON‑RPC calls.

These three methods give you everything you need to submit and track transactions across supported EVM chains:

Submit: eth_sendRawTransaction

Track: eth_getTransactionByHash

Manage nonce: eth_getTransactionCount

Below is an example of sending an Ethereum transaction via the GetBlock RPC endpoint with Merkle’s protection under the hood:

curl -X POST "https://go.getblock.us/<YOUR_ACCESS_TOKEN>" \
   -H "Content-Type: application/json" \
   --data '{"jsonrpc":"2.0","id":"getblock","method":"eth_sendRawTransaction","params":["0xSIGNED_TX_HEX"]}'

Notably, GetBlock’s Ethereum endpoints support Merkle’s Boost API that helps transactions land in the next available block faster.

Next, you might want to track the transaction status in a pool:

curl -X POST "https://go.getblock.us/<YOUR_ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","id":"getblock","method":"eth_getTransactionByHash","params":["0xYourTxHash"]}'

For Solana endpoints, use the sendTransaction method:

curl https://go.getblock.us/<YOUR_ACCESS_TOKEN> \
  -X POST -H "Content-Type: application/json" \
  --data '{
    "jsonrpc":"2.0",
    "Id": "getblock",
    "method":"sendTransaction",
    "params":["BASE64_TX"]
  }'

That’s it – just swap the RPC URL and your users immediately gain MEV protection and faster, more reliable inclusion with zero client‑side changes.

Pro tip: MEV-protected endpoints can be added as custom RPC URLs in Web3 wallets like MetaMask to get the same level of protection from front-running and sandwich attacks. Find the instructions in our custom MetaMask network setup guide.

Conclusion: Who benefits from using Merkle the most?

Merkle’s private mempools reshape how transactions hit the blockchain – bypassing the public gossip network to deliver enhanced speed, privacy, and fairness.

The service brings the most benefit to these groups of blockchain users:

Wallet providers and their end‑users interacting with on‑chain protocols.

DeFi tools & traders running swaps, arbitrages, liquidations, etc..

MEV searchers to get fair access to MEV auctions.

With GetBlock supporting Merkle, RPC infrastructure users can also enjoy safer on-chain interactions with minimal effort, trusting Merkle’s architecture to handle the privacy protection.

Now, dApp developers relying on our service can tap into these benefits instantly without having to build custom MEV defences. Sign up for GetBlock and explore MEV‑protected RPC endpoints today.