How to Build a DEX Arbitrage Bot: Gas, MEV, and Profitability Guide
On Uniswap V3 ETH/USDC, the price is $3,201.50; on SushiSwap, it's $3,199.80. The difference is $1.70 per ETH. To make a profit, you need to account for gas: 21,000 + 150,000 (two swaps) ≈ 170,000 gas × 30 gwei × $3,200 / 1e9 ETH = ~$16 on gas. So, for a $1,000 trade, the difference must be at least 1.6%, while for $100,000, 0.016% is enough. DEX arbitrage only works with sufficient position size or price discrepancy — flash loans make this business accessible without own capital. A typical trade yields between $200 and $500 in net profit.
With 5+ years in DeFi and 10+ projects delivered, we ensure reliable bot development. Our clients typically see ROI within 3 months. Gas optimization can save up to $15 per transaction, and development cost starts at $5,000 for a basic bot.
Why DEX Arbitrage Bots Often Fail to Generate Profit
Mempool Competition and MEV
The toughest adversary for a DEX arbitrageur is MEV bots with direct access to block builders. Through Flashbots eth_sendBundle, a transaction goes directly to the builder, bypassing the public mempool. Flashbots provides a private submission mechanism that is 3 times better than public mempool for transaction success rate: the success rate of transactions increases by 2–3 times.
If your bot sends transactions to the public mempool, you're in a losing position. The usual gas auction means other bots see your transaction, assess profitability, and outbid you with higher gas. The solution: send all transactions through Flashbots or MEV Blocker (an aggregator of multiple private relays). Additionally, include multiple transactions in a single bundle with atomic execution.
Our Solidity-based arbitrage bot development incorporates MEV protection through Flashbots, enabling efficient cross-chain arbitrage and smart contract arbitrage. Transaction optimization is critical, and we achieve it through careful gas profiling. Arbitrage between DEXs like Uniswap and SushiSwap is the most common strategy.
Slippage and Real Price Calculation
The problem with most beginner implementations: calculating arbitrage opportunity based on the pool's spot price without accounting for price impact. The actual price after a swap depends on the current liquidity in the active range (Uniswap V3), transaction size, and spread across several tick ranges. For V3, correct calculation requires simulating the swap via the Quoter contract or off-chain via @uniswap/v3-sdk. The difference between spot price and actual execution price for a $100k swap on a medium-liquidity pool is 0.3–1.5%. Without accounting for this, profitability estimates will be wrong.
Gas Optimization: The Difference Between Profit and Loss
On Ethereum mainnet, arbitrage only works with optimized gas usage. A typical mistake: two separate ERC-20 approve + swap adds +43,000 gas overhead. The solution — use permit (EIP-2612) for supported tokens, or pre-approve the maximum amount and avoid re-approving. Even more savings come from atomic arbitrage via flash loan in a single contract: no multiple transfer calls between EOA and DEX, no separate transactions. The entire arbitrage is one transaction: flash loan → swap A → swap B → repay loan → profit. Gas for such a transaction: 200,000 – 400,000 depending on protocols. Optimal gas settings save up to 30% in fees.
How to Build a Reliable DEX Arbitrage Bot
What Technology Stack Is Used?
- On-chain contract in Solidity 0.8.x executes the trade atomically, implements a flash loan callback (Aave
IFlashLoanReceiveror Uniswap V3IUniswapV3FlashCallback), performs swaps, and checks for profit. - Off-chain executor in Rust monitors pools via WebSocket subscriptions to our own Ethereum nodes, calculates paths using the Bellman-Ford algorithm (see Wikipedia), and submits transactions via Flashbots.
Example contract:
Example Contract Code
function executeArbitrage( address tokenIn, uint256 amountIn, SwapPath[] calldata path, uint256 minProfit ) external { // Flash loan from Aave // Execute swaps along path // Assert profit >= minProfit, else revert // Repay flash loan // Transfer profit to owner } Reverting on insufficient profit is a key protection: if the market moves, the contract rolls back, spending only base gas (~21,000), not the full gas of swap execution.
Comparison of Arbitrage Strategies
| Strategy | Risks | Profitability | Implementation Complexity |
|---|---|---|---|
| Simple two-sided | Low | Medium | Low |
| Multi-hop (3+ paths) | Medium | High | Medium |
| Cross-chain via bridge | High | High | High |
| Flash loan + MEV protection | Medium | Very High | High |
Multi-hop arbitrage can be 2 times more profitable than simple two-sided arbitrage. In practice, the flash loan with Flashbots bundle strategy shows 1.5–2 times more profitable transactions compared to regular mempool submission.
Optimal Path Finding: Bellman-Ford
For multi-hop arbitrage (A→B→C→A), finding a profitable path is equivalent to finding a negative cycle in a price graph. The classic algorithm is Bellman-Ford on a graph where nodes = tokens, edges = pools, weights = log(exchange_rate). In practice, for 5–10 DEXes and 50–100 tokens, the graph is small, and Bellman-Ford runs in milliseconds.
Development Process
- Analytics (2–3 days). Identify target DEXes, networks, token pairs. Analyze the competitive environment — how many bots are already operating in the chosen segment.
- Contract development (1 week). Flash loan integration, multi-hop swap logic, profit assertion. Test on a mainnet fork using Foundry.
- Executor development (1–2 weeks). WebSocket pool monitoring, Bellman-Ford / path finding, Flashbots bundle submission.
- Optimization and deployment (3–5 days). Gas profiling, fine-tuning minProfit thresholds, deployment to production.
Monitoring and Risk Management
An arbitrage bot in production requires monitoring several metrics: transaction win rate (if > 30% revert, executor is too slow), gas efficiency, capital utilization, competitive environment. We use Grafana + Prometheus for metrics and alerts via a Telegram bot.
What's Included in the Work
We provide: source code of the contract and executor, deployment documentation, access to monitoring (Grafana dashboard), team training, technical support for 30 days after launch.
Contact us for a detailed discussion of your project. Order bot development with guaranteed support — get a consultation from experts with 5 years of DeFi experience.
Timeline Estimates
Basic bot (2 DEXes, one network, flash loan) — 1–2 weeks. Multi-DEX, multi-path with Flashbots integration — 2–4 weeks. Cross-chain or advanced MEV strategies — from 6 weeks. Cost is calculated individually.







