Arbitraje DEX vs CEX: Manual de Spread Trading Paso a Paso

Anatomía del spread: por qué un DEX y un CEX nunca van a vivir en perfecta sincronía

Si crees que el arbitraje entre DEX y CEX es una "máquina de hacer dinero" donde basta con encontrar una diferencia del 2% y mover tokens de un lado a otro, prepárate para un golpe duro de realidad. El spread entre exchanges no es dinero gratis: es una prima de riesgo que pagas por la iliquidez, el slippage y los retrasos en la infraestructura.

En un CEX (como Binance, Bybit o EXMON), el precio se define en el libro de órdenes (Limit Order Book). La liquidez ahí es hiperdinámica: los market makers mueven la grilla de órdenes en microsegundos y los algoritmos recalculan el precio justo en tiempo real basándose en índices de futuros.

En un DEX (como Uniswap, Raydium o PancakeSwap), el precio depende directamente de la curva matemática de un pool de liquidez. En un AMM v2 clásico (x · y = k), el precio solo se mueve cuando una transacción entra físicamente al pool. Si en Binance el precio del token X se desploma un 5% en un segundo por culpa de una ballena vendiendo fuerte, el pool de Uniswap se va a quedar congelado en el precio viejo más alto hasta que:

• La transacción del bot de arbitraje se envíe a la red.
• La transacción pase la fase de validación y sea incluida en un bloque.

Es justamente en ese desfase temporal (desde un par de segundos en redes rápidas hasta varios bloques en Ethereum) donde nace el spread.

Radiografía técnica: ¿de dónde sale el spread para operar a mano?

Es imposible competir a mano contra bots de HFT y MEV searchers que están conectados a nodos RPC privados y les pagan propinas a los validadores vía Flashbots para colarse en el mismo bloque (backrunning). Los spreads enanos del 0.2% al 0.5% en ETH o BTC se los devoran los algoritmos en cuestión de microsegundos.

Pero el trader manual sale a cazar un tipo de ineficiencia completamente distinto:

• Pumps y dumps agresivos en altcoins de capitalización media (Mid-caps). Una ballena le pega a un pool en el DEX y vende $50,000 en tokens. En un pool sin tanta profundidad, el precio se derrumba al instante entre un 4% y un 7%. Los bots del CEX no pueden recomprar esa caída de inmediato porque en el CEX el libro de órdenes está denso y el precio ni se enteró.
• Congestión en la red y picos en el Gas Price. Durante un sacudón bravo en el mercado, el mempool se satura. Los bots de MEV se caen temporalmente o empiezan a pedir comisiones disparatadas, haciendo que los spreads en el DEX queden abiertos por 2 a 5 minutos.
• Listados a destiempo y suspensión de retiros/depósitos (Deposit/Withdrawal Halt). El exchange bloquea el ingreso o la salida de un token en una red específica por mantenimiento de un nodo. El flujo de liquidez entre el DEX y el CEX se corta de raíz. En el CEX se arma un "libro cerrado" y el precio empieza a cotizar por su cuenta, desfasándose del DEX hasta un 15%.

Arquitectura del setup y distribución del capital

El error típico del novato: ven un spread en el DEX, compran en el CEX, le dan a "Retirar a la wallet" y se quedan sentados esperando 15 minutos a que la red confirme la transacción. Para cuando los tokens llegan a la wallet, el spread no solo se esfumó, sino que terminas cerrando la jugada en pérdida garantizada.

El trading manual de spreads exige un posicionamiento delta-neutral o una división de balance previa.

El modelo "Split Balance" (División de Saldo)

Olvídate de hacer transferencias entre plataformas en medio de una operación. Los fondos se mueven mucho antes de arrancar la sesión.

Tu capital se divide en dos partes iguales:

Con este esquema, ejecutas las órdenes en simultáneo:

• Si el token en el DEX cotiza a $1.10 y en el CEX a $1.00: vendes ARB al instante en el DEX (te embolsas $1.10) y compras ARB en el CEX (a $1.00).
• No hay envío físico de tokens. Te aseguraste un delta del 10% (menos comisiones) en apenas 3 segundos.
• El rebalanceo de saldo entre la wallet y el exchange se hace después, cuando el mercado se calme y las comisiones de la red vuelvan a piso.

Matemática del trade: cálculo del spread neto y el punto de equilibrio

Ver una diferencia jugosa del 3% en la pantalla y cantarla como ganancia segura es la forma más rápida de quemar tu cuenta si estás empezando en el arbitraje. El spread bruto (Gross Spread) no vale nada; lo que realmente importa es el spread neto (Net Spread) después de descontar cada comisión de infraestructura y los peajes ocultos en el camino.

Fórmula para calcular el rendimiento neto

Net_Profit = (P_sell · V) - (P_buy · V) - Fee_CEX - Fee_DEX - Gas - Impact

Donde:

• P_sell y P_buy - Precios reales de ejecución de las órdenes (no el Mid-Price de la interfaz, sino los precios ponderados según la profundidad del order book).
• V - Volumen del trade en base o stables.
• Fee_CEX - Comisión de la exchange centralizada para el taker (usualmente entre 0.05% y 0.1%).
• Fee_DEX - Comisión del pool de liquidez (0.01%, 0.05%, 0.3% o 1% según el tier del pool).
• Gas - Costo por minar la transacción en el bloque, convertido a USD.
• Impact - El impacto de tu propio volumen en el precio dentro del AMM.

El enemigo principal: el Price Impact en los DEX

Si en un CEX ves 10,000 monedas en el order book a $1.00 cada una, te las llevas exactamente a $1.00 (más comisiones). En un DEX con la clásica mecánica de producto constante (x · y = k), cada token que compras te sale más caro que el anterior.

La fórmula del precio de salida para el token x por el token y en un pool x · y = k es:

y_out = (y_reserve · x_in · (1 - fee)) / (x_reserve + x_in · (1 - fee))

Si le metes una orden de $5,000 a un pool con $100,000 de liquidez, vas a mover el precio del pool un ~5%. Tu spread neto del 3% se evapora al instante y se convierte en un 2% de pérdida antes de que la tx siquiera toque el bloque.

Tabla de spread real según el volumen del trade (Pool de $50k, spread bruto del 2.5%)

En resumen: cada pool de liquidez tiene un techo matemático bien definido para el tamaño de tus trades. Intentar meter más capital del que soporta es arruinar tu propia estrategia.

Automatización del escaneo: armando un monitor en Python

Abrir el navegador y refrescar a mano las pestañas de DexScreener y el order book es de la época de las cavernas. Un trader pro no usa código para meter trades automáticos (competir contra los bots de MEV ahí es botar el dinero), sino para tirar una alerta sonora o de texto al instante en Telegram o consola cuando se abre una ventana anómala.

Abajo tienes un script en Python 3.10+ completamente funcional y listo para usar. Monitorea en tiempo real las reservas directas de un pool de PancakeSwap v2 (en la red BNB Chain) vía RPC y las compara con el order book de un CEX (usando la API REST de Binance como ejemplo, que se adapta volada a EXMON). El script es sencillo y aún se le puede sacar mucho jugo, pero funciona de 10.

Código del escáner de spread con reservas y comisiones

import sys
import time
import requests
from web3 import Web3
# ============================================================
# CONFIG
# ============================================================
BSC_RPC = "https://bsc-dataseed1.binance.org"
POOL_ADDRESS = Web3.to_checksum_address(
    "0x16b9a82891338f9bA80E2D6970FddA79D1eb0daE"
)
BINANCE_DEPTH_URL = (
    "https://api.binance.com/api/v3/depth"
    "?symbol=BNBUSDT&limit=20"
)
TRADE_VOLUME_USD = 300.0
CEX_TAKER_FEE = 0.001
DEX_FEE = 0.0025
MIN_NET_SPREAD_PCT = 0.8
# Estimado de gas por cada swap
ESTIMATED_GAS_COST_USD = 0.15
REQUEST_TIMEOUT = 3
# ============================================================
# WEB3
# ============================================================
w3 = Web3(Web3.HTTPProvider(BSC_RPC))
if not w3.is_connected():
    print("Error conectando al RPC de BSC")
    sys.exit(1)
# ============================================================
# ABI
# ============================================================
PAIR_ABI = [
    {
        "constant": True,
        "inputs": [],
        "name": "getReserves",
        "outputs": [
            {"name": "_reserve0", "type": "uint112"},
            {"name": "_reserve1", "type": "uint112"},
            {"name": "_blockTimestampLast", "type": "uint32"},
        ],
        "stateMutability": "view",
        "type": "function",
    },
    {
        "constant": True,
        "inputs": [],
        "name": "token0",
        "outputs": [{"name": "", "type": "address"}],
        "stateMutability": "view",
        "type": "function",
    },
    {
        "constant": True,
        "inputs": [],
        "name": "token1",
        "outputs": [{"name": "", "type": "address"}],
        "stateMutability": "view",
        "type": "function",
    },
]
pair = w3.eth.contract(
    address=POOL_ADDRESS,
    abi=PAIR_ABI
)
# ============================================================
# KNOWN TOKENS
# ============================================================
WBNB = Web3.to_checksum_address(
    "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
)
USDT = Web3.to_checksum_address(
    "0x55d398326f99059fF775485246999027B3197955"
)
# ============================================================
# VERIFY PAIR
# ============================================================
try:
    token0 = Web3.to_checksum_address(
        pair.functions.token0().call()
    )
    token1 = Web3.to_checksum_address(
        pair.functions.token1().call()
    )
except Exception as e:
    print("Error leyendo token0/token1")
    print(e)
    sys.exit(1)
PAIR_LAYOUT = None
if token0 == WBNB and token1 == USDT:
    PAIR_LAYOUT = "WBNB_USDT"
elif token0 == USDT and token1 == WBNB:
    PAIR_LAYOUT = "USDT_WBNB"
else:
    print("El pool no es un par WBNB/USDT válido")
    print("token0 =", token0)
    print("token1 =", token1)
    sys.exit(1)
print("Pair verified:")
print("token0 =", token0)
print("token1 =", token1)
# ============================================================
# BINANCE
# ============================================================
def get_orderbook():
    try:
        response = requests.get(
            BINANCE_DEPTH_URL,
            timeout=REQUEST_TIMEOUT
        )
        response.raise_for_status()
        data = response.json()
        if "bids" not in data:
            return None
        if "asks" not in data:
            return None
        return data
    except Exception:
        return None
def calculate_execution_buy_price(
    asks,
    target_usd
):
    """
    Compra de BNB por USDT.
    Retorna:
        avg_price,
        received_bnb
    """
    spent_usd = 0.0
    received_bnb = 0.0
    for price_str, qty_str in asks:
        price = float(price_str)
        qty = float(qty_str)
        level_usd = price * qty
        if spent_usd + level_usd >= target_usd:
            remaining_usd = target_usd - spent_usd
            partial_qty = remaining_usd / price
            received_bnb += partial_qty
            spent_usd += remaining_usd
            break
        received_bnb += qty
        spent_usd += level_usd
    if spent_usd < target_usd:
        return None, None
    avg_price = spent_usd / received_bnb
    return avg_price, received_bnb
def calculate_execution_sell_price(
    bids,
    sell_bnb
):
    """
    Venta de BNB por USDT.
    Retorna:
        avg_price,
        received_usdt
    """
    remaining_bnb = sell_bnb
    received_usdt = 0.0
    sold_bnb = 0.0
    for price_str, qty_str in bids:
        price = float(price_str)
        qty = float(qty_str)
        take_qty = min(
            remaining_bnb,
            qty
        )
        received_usdt += take_qty * price
        sold_bnb += take_qty
        remaining_bnb -= take_qty
        if remaining_bnb <= 0:
            break
    if remaining_bnb > 0:
        return None, None
    avg_price = received_usdt / sold_bnb
    return avg_price, received_usdt
# ============================================================
# DEX
# ============================================================
def get_reserves():
    try:
        reserves = (
            pair.functions
            .getReserves()
            .call()
        )
        raw0 = reserves[0]
        raw1 = reserves[1]
        if PAIR_LAYOUT == "WBNB_USDT":
            reserve_bnb = raw0 / 1e18
            reserve_usdt = raw1 / 1e18
        else:
            reserve_usdt = raw0 / 1e18
            reserve_bnb = raw1 / 1e18
        return (
            reserve_bnb,
            reserve_usdt
        )
    except Exception:
        return None, None
def amm_out(
    amount_in,
    reserve_in,
    reserve_out
):
    if (
        amount_in <= 0
        or reserve_in <= 0
        or reserve_out <= 0
    ):
        return 0.0
    amount_in_fee = (
        amount_in
        * (1 - DEX_FEE)
    )
    numerator = (
        amount_in_fee
        * reserve_out
    )
    denominator = (
        reserve_in
        + amount_in_fee
    )
    return numerator / denominator
# ============================================================
# MONITOR
# ============================================================
def monitor():
    print()
    print("DEX/CEX Arbitrage Monitor Started")
    print("-" * 80)
    while True:
        book = get_orderbook()
        if book is None:
            time.sleep(1)
            continue
        reserve_bnb, reserve_usdt = (
            get_reserves()
        )
        if (
            reserve_bnb is None
            or reserve_usdt is None
        ):
            time.sleep(1)
            continue
        bids = book["bids"]
        asks = book["asks"]
        # ====================================================
        # SCENARIO A
        # BUY ON DEX
        # SELL ON CEX
        # ====================================================
        bnb_from_dex = amm_out(
            TRADE_VOLUME_USD,
            reserve_usdt,
            reserve_bnb
        )
        if bnb_from_dex <= 0:
            time.sleep(1)
            continue
        sell_price, usdt_received = (
            calculate_execution_sell_price(
                bids,
                bnb_from_dex
            )
        )
        if usdt_received is None:
            time.sleep(1)
            continue
        usdt_received *= (
            1 - CEX_TAKER_FEE
        )
        usdt_received -= (
            ESTIMATED_GAS_COST_USD
        )
        spread_a = (
            (usdt_received - TRADE_VOLUME_USD)
            / TRADE_VOLUME_USD
        ) * 100
        # ====================================================
        # SCENARIO B
        # BUY ON CEX
        # SELL ON DEX
        # ====================================================
        buy_price, bought_bnb = (
            calculate_execution_buy_price(
                asks,
                TRADE_VOLUME_USD
            )
        )
        if bought_bnb is None:
            time.sleep(1)
            continue
        bought_bnb *= (
            1 - CEX_TAKER_FEE
        )
        usdt_from_dex = amm_out(
            bought_bnb,
            reserve_bnb,
            reserve_usdt
        )
        usdt_from_dex -= (
            ESTIMATED_GAS_COST_USD
        )
        spread_b = (
            (usdt_from_dex - TRADE_VOLUME_USD)
            / TRADE_VOLUME_USD
        ) * 100
        dex_price = (
            reserve_usdt
            / reserve_bnb
        )
        sys.stdout.write(
            "\r"
            f"DEX={dex_price:.2f} | "
            f"A:{spread_a:+.2f}% | "
            f"B:{spread_b:+.2f}%"
        )
        sys.stdout.flush()
        if spread_a >= MIN_NET_SPREAD_PCT:
            print(
                "\n"
                f"[SIGNAL] "
                f"BUY DEX -> SELL CEX "
                f"({spread_a:.2f}%)"
            )
        elif spread_b >= MIN_NET_SPREAD_PCT:
            print(
                "\n"
                f"[SIGNAL] "
                f"BUY CEX -> SELL DEX "
                f"({spread_b:.2f}%)"
            )
        time.sleep(1.5)
# ============================================================
# ENTRY
# ============================================================
if __name__ == "__main__":
    try:
        monitor()
    except KeyboardInterrupt:
        print("\nStopped.")

Este script calcula el slippage real porque no saca el precio por la cotización por defecto, sino que pasa tus $300 de volumen directo por el modelo matemático interno del pool.

Protocolo de ejecución manual: cómo evitar caer en la trampa de los sandwich bots

Hacer clic en dos botones en diferentes plataformas parece una tarea sencilla. En la práctica, el 80% de los traders manuales queman sus ganancias en el preciso instante en que envían su transacción al mempool público.

Tan pronto como tu transacción de compra en un DEX llega al mempool público de Ethereum, BNB Chain o Arbitrum, los bots de MEV (Maximum Extractable Value) se abalanzan sobre ella de inmediato. Si tienes configurada una tolerancia al deslizamiento (Slippage Tolerance) superior al 0.5%, el bot ejecuta un ataque de sándwich (Sandwich Attack) al instante:

• El bot compra el token justo antes de tu transacción, inflando el precio (Frontrun).
• Tu transacción se ejecuta al peor precio posible, justo al límite de tu slippage.
• El bot vende el token inmediatamente después de ti obteniendo una ganancia (Backrun).

¿El resultado final? Obtienes el token a un precio inflado y todo el spread se lo lleva el buscador de MEV.

Ruta de ejecución segura (Pipeline)

Para capturar spreads de forma manual sin alimentar a los bots, debes configurar tus operaciones siguiendo este esquema:

• Nodes RPC privados (MEV-Blocker / Flashbots). Olvídate de la configuración de red predeterminada en MetaMask. Todas las transacciones en DEX deben enviarse exclusivamente a través de relays privados que transmiten la transacción directamente al validador del bloque, evitando el mempool público.
  Para Ethereum: https://rpc.mevblocker.io o https://rpc.flashbots.net
  Para BNB Chain / Polygon / Arbitrum: utiliza servicios de protección MEV de QuickNode o proveedores como BloXroute.
• Límite de deslizamiento estricto (Slippage Limit). Nada de usar los valores predeterminados del 1% o 2% en las interfaces de Uniswap o 1inch. El slippage máximo permitido para una operación de arbitraje es del 0.1% al 0.3%. Si el precio se mueve una fracción antes de incluirse en el bloque, la transacción debe fallar (revert) en lugar de ejecutarse con pérdidas.
• Optimización de Gas Fee. Cambia la configuración de comisiones en tu billetera Web3 al modo manual (Advanced Gas Controls). Configura la Max Priority Fee (propina para el validador) un poco por encima de la mediana actual de la red para asegurar tu lugar al principio del siguiente bloque. En redes L2 (Arbitrum, Base, OP), es fundamental vigilar las L1 Data Fees; cuando Ethereum está saturado, enviar transacciones en L2 puede costar hasta 5 veces más de lo habitual.

Técnica avanzada: Arbitraje delta neutro «DEX Spot vs CEX Futures»

Mantener físicamente una altcoin en ambos saldos mientras esperas que aparezca el spread conlleva el riesgo de sufrir pérdidas por la caída del propio activo (Market Price Risk). Si las monedas se desploman un 15%, tu spread fijado del 2% no va a cubrir la bajada de la cartera.

La metodología avanzada aplicada en la Academia EXMON es el trading de spreads delta neutro a través de futuros.

Mecánica mediante cobertura en corto (Short Hedge)

En lugar de comprar el activo spot en un CEX, mantienes allí una posición corta (short) en futuros con apalancamiento de 1x.

Algoritmo de ejecución:

• Se produce un desplome (dump) en el DEX: el token cae a $0.95, mientras que en el CEX el futuro y el spot siguen cotizando a $1.00 (un spread del 5.2%).
• Compras el spot en el DEX a $0.95.
• Al mismo tiempo, abres un Short en el futuro en el CEX a un precio de $1.00.
• Tu delta se neutraliza al instante: sin importar hacia dónde se mueva el mercado, el valor total de tu cartera no cambia.
• Tan pronto como el precio en el DEX se alinea con el CEX (por ejemplo, ambas plataformas se estabilizan en $0.98), cierras ambas posiciones:
  • Vendes el spot en el DEX a $0.98 (Ganancia: +$0.03 por moneda).
  • Cierras el short en el CEX a $0.98 (Ganancia: +$0.02 por moneda).

Ganancia neta total: $0.05 por moneda (un 5% sobre el volumen utilizado) con cero riesgo de caída del propio token.

Bonus adicional: Si el contrato de futuros en el CEX cotiza en contango (el precio del futuro está por encima del spot), cobras en paralelo una Funding Rate (tasa de financiación) positiva cada hora de liquidación.

Riesgos y trampas ocultas poco conocidas

Si una estrategia parece perfecta, significa que aún no has visto sus vulnerabilidades ocultas. El spread trading manual está lleno de «minas» de ingeniería.

1. Tokens con impuestos integrados (Transfer Tax / Reflection Tokens)

Ciertos tokens ERC-20 / BEP-20 incluyen una comisión incrustada en el smart contract para cada transferencia (por ejemplo, del 2% al 5% para quema o billeteras de marketing).

Si no verificas el código del contrato a través de un explorador o escáner (TokenSniffer, GoPlus), sacarás el token del pool, perderás un 5% de inmediato debido a la propia mecánica del token, más un 0.3% de comisión del AMM, y cerrarás la operación con una pérdida masiva.

2. Desplazamiento de liquidez virtual en Uniswap v3 (Concentrated Liquidity Trap)

En Uniswap v2, la liquidez se distribuye desde cero hasta el infinito. En la versión v3, la liquidez se concentra en rangos de precios estrechos (Ticks).

Si el spread surgió porque el precio se salió del rango del creador de mercado principal, la diferencia visual de precio puede parecer enorme (hasta un 10%–20%). Pero el volumen de liquidez en ese tick actual podría ser de apenas $15. Intentar realizar una operación allí provocará un deslizamiento de precio instantáneo de decenas por ciento en tu contra.

3. Desbalance de liquidez y «capital atrapado» (Inventory Risk)

Habiendo operado el spread 5 veces seguidas en la misma dirección (por ejemplo, Compra en DEX -> Venta en CEX), habrás agotado por completo tus reservas de USDT en el CEX y llenado tu billetera Web3 de altcoins.

El rebalanceo requiere tiempo y costos de gas. Si el mercado entra en una tendencia fuerte, quedarás atrapado en una sola pata de la posición (one-legged trade). Regra de gestión de riesgo: nunca permitas un desequilibrio en los balances de las plataformas superior a 70/30.

Checklist del trader antes de hacer clic

Coloca esta checklist justo frente a tu monitor de trabajo. Entra a una operación únicamente si se cumplen los 5 puntos:

• Protección MEV activada: Nodo RPC privado seleccionado en la billetera (MEV-Blocker / Flashbots).
• Profundidad del pool verificada: El volumen de la operación no supera el 1%–2% de las reservas totales del pool en el DEX (Price Impact < 0.3%).
• Spread neto confirmado: La diferencia de precio cubre las comisiones combinadas de CEX + DEX + Gas por lo menos 2.5 veces.
• Smart contract limpio: El token no tiene comisiones de transferencia ocultas (Transfer Fee = 0%).
• Capital distribuido: Existe suficiente saldo en ambas monedas del par tanto en el CEX como en el DEX para una ejecución instantánea sin esperar tiempos de puentes (bridges).

El spread trading entre plataformas descentralizadas y centralizadas es una disciplina matemática pura. Aquí no gana el que adivina la dirección de la tendencia, sino el que calcula mejor las comisiones, controla la infraestructura y sabe esperar pacientemente su anomalía.