CEX to DEX Arbitrage Guide: Manual & Code Setup

Anatomy of a Spread: Where Does the Imbalance Come From?

Markets are inefficient, especially during peak hype or panic. On CEXs (Binance, Bybit, OKX), price action is driven by market makers and order books, where everything is decided by split-second order book imbalances. On DEXs, price discovery follows AMM (Automated Market Maker) mechanics, hard-coded into pool math (like the constant product formula $x \times y = k$).

When a whale dumps a massive bag into a CEX order book, the CEX price tanks instantly. But on a DEX? It’s completely quiet until the first arbitrageur or retail user steps in. That exact time lag between a CEX order book update and the shifting token ratios in a DEX pool is where we make our money.

But watch out for something crypto influencers rarely talk about: spreads are often pure bait. You spot a juicy 3% gap, get excited, and jump in, only to realize the pool is completely dry. There's zero liquidity. The moment you hit Swap, the price moves against you, turning a projected profit into a fat loss. That’s Price Impact for you.

Risk Matrix: What Will Wipe Out Your Deposit

Before you start writing code and building scanners, map out your threat checklist. Arbitrage is a speed game with negative expected value if you don't factor in hidden costs.

Manual Hunting vs. Automation

Scouting setups completely by hand in 2026 is pure masochism. But you absolutely have to understand the underlying mechanics.

The play is simple. Fire up CoinMarketCap or CoinGecko. Filter for low-cap tokens (legit shitcoins with decent volume). Open the "Markets" tab and look for pricing discrepancies. If you catch a delta between Gate.io and a Uniswap/PancakeSwap pool on Arbitrum or Base (where gas costs pennies), start digging.

Step-by-Step Manual Checklist:

• Check token deposit/withdrawal status on the CEX. If withdrawals are wallet-blocked, the spread is fake. Skip it.
• Verify the network. The token on the CEX must be on the exact same chain as the DEX pool. Bridges will bleed your time and your margin.
• Check the slippage. Type your target buy/sell size directly into the DEX UI. Look at the final Price Impact. If it eats the spread, the setup is dead.

Monitoring Script: Calculating Spreads Like a Pro

Enough theory. Let's talk dev. We need a script that pulls prices from a CEX (via CCXT) and parses the pool price directly from the DEX smart contract (via Web3.py), completely bypassing laggy front-ends.

Below is a production-ready script for a Bybit (CEX) and Uniswap v2 pool on Arbitrum (DEX) setup. This code is live.

import time
from web3 import Web3
import ccxt
# Connect to node. Use fast private RPCs; public ones lag constantly
RPC_URL = "https://arb1.alpharc.io/v1/your-api-key" # replace with your working RPC
w3 = Web3(Web3.HTTPProvider(RPC_URL))
if not w3.is_connected():
    raise Exception("Node down, fix it")
# Initialize exchange via CCXT
exchange = ccxt.bybit({
    'enableRateLimit': True,
})
# Uniswap V2 (or Sushi) pool contract on Arbitrum for this example (WETH/USDC)
# You can plug any shitcoin here, just get the token pair pool address
POOL_ADDRESS = "0x905dfCD56492171426f30a7d11d68E1da87ab64B" 
# V2 pool ABI. We only need the getReserves function, ignore the rest
POOL_ABI = [
    {
        "constant": True,
        "inputs": [],
        "name": "getReserves",
        "outputs": [
            {"name": "_reserve0", "type": "uint112"},
            {"name": "_reserve1", "type": "uint112"},
            {"name": "_blockTimestampLast", "type": "uint32"}
        ],
        "payable": False,
        "stateMutability": "view",
        "type": "function"
    }
]
pool_contract = w3.eth.contract(address=w3.to_checksum_address(POOL_ADDRESS), abi=POOL_ABI)
def get_dex_price():
    # Pull reserves directly from the contract
    reserves = pool_contract.functions.getReserves().call()
    
    # Pool has token0 and token1. Let's assume: token0 = USDC (6 decimals), token1 = WETH (18 decimals)
    # Warning: always double-check token ordering (0 vs 1) in the contract!
    reserve_usdc = reserves[0] / 10**6
    reserve_weth = reserves[1] / 10**18
    
    # WETH price in USDC based on pool formula
    price_dex = reserve_usdc / reserve_weth
    return price_dex
def get_cex_price():
    # Fetch Bybit spot order book
    orderbook = exchange.fetch_order_book('ETH/USDC')
    bid = orderbook['bids'][0][0] if len(orderbook['bids']) > 0 else 0
    ask = orderbook['asks'][0][0] if len(orderbook['asks']) > 0 else 0
    return bid, ask
def monitor():
    print("Launching inefficiency monitor...")
    while True:
        try:
            dex_p = get_dex_price()
            cex_bid, cex_ask = get_cex_price()
            
            if dex_p == 0 or cex_bid == 0:
                continue
                
            # Scenario 1: Cheaper on DEX, more expensive on CEX. Buy DEX, dump on CEX.
            spread_to_cex = ((cex_bid - dex_p) / dex_p) * 100
            
            # Scenario 2: Cheaper on CEX, more expensive on DEX. Buy CEX, dump on DEX.
            spread_to_dex = ((dex_p - cex_ask) / cex_ask) * 100
            
            if spread_to_cex > 0.5: # 0.5% threshold to cover fees
                print(f"[!] Signal! DEX is CHEAPER. DEX: {dex_p:.2f} | CEX Bid: {cex_bid:.2f} | Spread: {spread_to_cex:.2f}%")
                
            if spread_to_dex > 0.5:
                print(f"[!] Signal! CEX is CHEAPER. CEX Ask: {cex_ask:.2f} | DEX: {dex_p:.2f} | Spread: {spread_to_dex:.2f}%")
                
            time.sleep(2) # Don't spam the node and exchange, or you'll get IP banned
            
        except Exception as e:
            print(f"Loop error: {e}")
            time.sleep(5)
if __name__ == "__main__":
    monitor()

Advanced Play: Offsetting Volumes (Hedging)

Physically moving tokens around is old school. By the time the TX confirms and the exchange credits your deposit (requiring 15–30 network confirmations), the market has moved. The spread evaporates. Pros exploit inefficiencies differently.

We keep balances pre-positioned on both platforms.

Example: You have $1,000 and 1 ETH sitting in your CEX balance. You have the exact same amounts in your Metamask on Arbitrum.

The script pings: ETH price on DEX dipped to $2,900, while on CEX it’s holding at $2,950.

Your play: You simultaneously hit Swap on the DEX (buying ETH with stablecoins at $2,900) and sell 1 ETH on the CEX at $2,950. Same exact second. Your total asset value just grew by the spread delta. Zero cross-chain transfers. Balances rebalanced, profit locked in stables. Later, when the market calms down, you just re-align your positions with a standard transfer.

And most importantly: watch out for the "toxic flow." If the CEX price is nuking straight down, do not try to manually buy that asset on a DEX. The spread will look massive, but the pool just hasn’t rebalanced yet. You’ll be catching a falling knife, and 5 seconds later, arbitrage bots will nuke that pool even lower, leaving you holding a bag of depreciating tokens.

Sniping v3 Pools: How Not to Get Rekt by Concentrated Liquidity

If you think Uniswap v2 is still the peak of DeFi, you're stuck in 2021. Nowadays, all the main volume and fat spreads live on Uniswap v3 and its forks (PancakeSwap v3, QuickSwap v3). Here, the AMM mechanics change completely. Unlike v2, where liquidity is spread thin from zero to infinity, v3 concentrates liquidity within specific price ranges called ticks.

What does this mean for us? Brutal Price Impact the second the price pushes outside the liquid range.

If a token is pumping on a CEX and the v3 pool runs out of liquidity in the current tick, the DEX price takes a massive leap—a hard squeeze. You spot a 15% spread, ape into the pool, and the contract fills your transaction at the absolute worst price because there were literally zero orders inside that narrow range.

Uniswap v2 Liquidity Formula:  x * y = k (Smooth price curves)
Uniswap v3 Formula:            (x + L / √P_b) * (y + L * √P_a) = L^2 (Step-by-step price jumps)

To manually calculate the real spread in a v3 pool, just looking at the reserves won't cut it. You need to parse slot0 directly from the pool's smart contract.

Pre-flight Checklist for v3 Pools:

• Pull sqrtPriceX96 from the slot0 function. This is the current price encoded in its specific format.
• Check the current tick.
• Look at the liquidity depth in that specific tick. If it's close to zero, the spread is completely artificial, and you'll get trapped into a position at a terrible entry price.

Transaction Routing: Outrunning MEV Bots at the Turn

Let's say you found a juicy spread on Ethereum or Base. You fire off the transaction via a standard MetaMask wallet. What happens next? Your tx lands in the mempool (the public queue). MEV (Maximum Extractable Value) bots scan the mempool 24/7. They spot your tx, realize it's a free $100 profit, and generate an exact copy of your trade, but bump their gas price by 1 gwei.

The blockchain validator picks up their transaction first. The bot steals your spread. Your tx executes right after, but it either hits a loss or reverts entirely, burning your gas for nothing. You just got front-run. It sucks, but that's the game.

How to Protect Yourself:

• Use a private RPC. Forget the default wallet settings. On Ethereum Mainnet, set up Flashbots RPC (https://rpc.flashbots.net). On networks like BNB Chain or Polygon, look for specialized private endpoints (like MEV-Share or MevBlocker). This routes your transaction directly to the validators, completely bypassing the public mempool. Bots won't even know it exists.
• Set tight Slippage Tolerance. In the DEX settings, cap your slippage at 0.5% for liquid pairs and a max of 1-1.5% for shitcoins. If a bot tries to push the price against you, the tx will simply revert, keeping your principal safe (even if you lose a few cents on gas).

Practical Example: Breaking Down a Real-World Loop

Let's dissect what a perfect loop looks like. No fluff. Token X (a typical decentralized gaming asset).

• Monitoring: On Bybit, the token's price suddenly tanks from $1.00 to $0.90 because an early investor dumped a large bag. The buy side of the order book is still thick.
• DEX Analysis: On PancakeSwap (BNB Chain), the token is still lagging at $0.98. The liquidity pool sits at $200,000.
• Sizing the Trade: We want to run $2,000 through the loop. We check the Price Impact on PancakeSwap. Selling $2,000 into the pool will shift the price by just 0.3%. This means our average sell price will lock in around $0.977.

The Math Behind the Loop:

• Buy on Bybit: $2,000 / $0.90 = 2222.2 Token X.
• CEX Fees (Taker 0.1%): minus 2.2 tokens. 2220 left.
• CEX Withdrawal: Fixed network fee of 10 Token X. 2210 tokens hit the wallet.
• Sell on DEX: 2210 * $0.977 = $2159.17.
• Minus DEX Swap Gas: ~$0.15 (on BNB Chain).
• Net Profit: $159.02 from a single 3-minute loop.

Bybit's market makers closed the price gap with the DEX roughly 4 minutes after we finished our loop. The window of opportunity closed. You snooze, you lose.

The Professional Spread Farmer’s Stack

If you don't want to build your entire software suite from scratch, here is the exact tech stack used by most mid-tier teams and alpha hunters:

• DeXito / Dexscreener / GeckoTerminal — For visual tracking of market anomalies. Keep an eye on the "Arbitrage" tab on specialized data platforms.
• DeBank / Arkham — For wallet-tracking top-tier arbitrageurs. Spotted a wallet consistently printing money in the mempool? Put it on a watchlist and reverse-engineer which pools it's milking.
• Tenderly — Transaction simulation. If you're routing heavy volume and want to avoid smart contract errors, simulate the tx on Tenderly first. It shows you the exact gas consumption and whether the call will succeed in production.

Grinding this market manually is doable, but your biggest enemy is human error. Screw up the network, forget to calculate CEX withdrawal fees, or trigger a swap without checking slippage, and your profit goes straight to the network validators. Stay cold, calculate costs down to the micro-cent, and don't get greedy.