Arbitrage DEX CEX: Manuel de Trading de Spread Crypto (2026)

Anatomie du spread : pourquoi DEX et CEX ne seront jamais parfaitement synchronisés

Si vous pensez que l'arbitrage entre un DEX et un CEX est une imprimante à billets magique où il suffit de repérer un écart de 2 % et de transférer vos tokens d'un côté à l'autre, préparez-vous à un atterrissage brutal. Le spread inter-exchange, ce n'est pas de l'argent gratuit : c'est une prime de risque payée pour l'illiquidité, le slippage et la latence de l'infrastructure.

Sur un CEX (comme Binance, Bybit ou EXMON), le prix est fixé dans un carnet d'ordres (Limit Order Book). La liquidité y est hyper dynamique : les market makers ajustent leur grille d'ordres en une fraction de microseconde, et les algorithmes recalculent la fair value en continu selon les index des contrats futures.

Sur un DEX (comme Uniswap, Raydium ou PancakeSwap), le prix dépend directement de la courbe mathématique d'une pool de liquidité. Dans un AMM v2 classique (x · y = k), le prix ne bouge que lorsqu'une transaction est physiquement exécutée dans la pool on-chain. Si le prix du token X s'effondre de 5 % en une seconde sur Binance à cause d'un gros vendeur, la pool Uniswap restera totalement figée sur son ancien prix plus élevé tant que :

• La transaction d'un bot d'arbitrage n'est pas envoyée sur le réseau.
• Cette transaction n'a pas passé la phase de validation pour être incluse dans un bloc.

C'est précisément dans cette fenêtre temporelle (de quelques secondes sur les blockchains rapides à plusieurs blocs sur Ethereum) que naît le spread.

Dissection technique : d'où provient le spread exploitable manuellement ?

En manuel, il est strictement impossible de rivaliser avec les bots HFT et les MEV searchers connectés à des nœuds RPC privés, qui arrosent les étrennes aux validateurs via Flashbots pour s'insérer dans le même bloc (backrunning). Les micro-spreads de 0,2 % à 0,5 % sur l'ETH ou le BTC sont engloutis par les algorithmes en quelques microsecondes.

En réalité, le trader manuel chasse un tout autre type de déséquilibre :

• Dump ou pump impulsif sur des altcoins mid-caps. Une « baleine » débarque sur une pool DEX et vend pour 50 000 $ de tokens. Sur une pool sans grande profondeur, le prix décroche instantanément de 4 à 7 %. Les bots CEX ne peuvent pas racheter le dip dans la seconde, car le carnet d'ordres sur le CEX reste très dense et le prix y est resté immobile.
• Congestion du réseau et spikes de gas. En pleine tempête de volatilité sur le marché, le mempool se retrouve totalement saturé. Les bots MEV décrochent temporairement ou exigent des frais démentiels, ce qui laisse des spreads béants sur les DEX pendant 2 à 5 minutes.
• Listings désynchronisés et suspension des retraits (Deposit/Withdrawal Halt). Un CEX coupe les dépôts ou les retraits d'un token sur un réseau donné en raison d'une mise à jour de nœud. Le pont de liquidité entre le DEX et le CEX est coupé net. Le carnet d'ordres du CEX devient un vase clos, et le prix commence à vivre sa propre vie, allant jusqu'à dévier de plus de 15 % par rapport au DEX.

Architecture du setup et allocation du capital

L'erreur typique du débutant : repérer un spread sur un DEX, acheter sur le CEX, cliquer sur « Retirer vers le portefeuille », puis poireauter 15 minutes le temps que la blockchain valide la transaction. Le temps que les tokens arrivent sur le wallet, non seulement le spread s'est envolé, mais vous validez une perte sèche garantie.

Le trading de spread manuel exige une approche delta-neutre ou une répartition préalable des balances.

Le modèle Split Balance (Capital fractionné)

Oubliez les transferts de fonds d'une plateforme à l'autre en plein trade. Les transferts s'effectuent bien avant de lancer la session.

Votre capital est scindé en deux parts égales :

Grâce à cette configuration, vous exécutez vos ordres simultanément :

• Si le token s'échange à 1,10 $ sur le DEX et à 1,00 $ sur le CEX : vous vendez instantanément vos ARB sur le DEX (vous encaissez 1,10 $) et vous rachetez ARB sur le CEX (à 1,00 $).
• Aucun mouvement physique de tokens n'est nécessaire. Vous venez d'empocher un delta de 10 % (hors frais) en l'espace de 3 secondes.
• Le rééquilibrage (rebalancing) de votre capital entre le wallet et l'exchange se fait plus tard, une fois le calme revenu sur le marché et quand les frais de réseau retombent à leur niveau plancher.

Maths du trade : calculer le spread « net » et le point de breakeven

Voir un joli gap de 3 % à l'écran et déjà calculer son profit garanti, c'est la cause n°1 de cramage de compte chez les débutants en arbitrage. Le spread « brut » (Gross Spread) ne veut absolument rien dire. Ce qui nous intéresse, c'est uniquement le spread net (Net Spread) une fois qu'on s'est acquitté de tous les frais parasites de chaque brique d'infrastructure.

Formule de calcul du rendement net

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

Où :

• P_sell et P_buy - les prix d'exécution réels des ordres (pas le Mid-Price théorique affiché en haut du site, mais le prix moyen pondéré par rapport à la profondeur de l'order book).
• V - le volume du trade en sous-jacent ou en stables.
• Fee_CEX - la commission de l'exchange pour un ordre taker (en général 0,05 %–0,1 %).
• Fee_DEX - les frais du pool (0,01 %, 0,05 %, 0,3 % ou 1 % selon le tier du pool).
• Gas - le coût d'inclusion de la transaction dans le bloc, converti en USD.
• Impact - l'impact de votre propre volume sur le prix au sein du pool AMM.

L'ennemi juré : le Price Impact sur DEX

Si sur un CEX vous voyez 10 000 tokens dans le carnet à 1,00 $, vous allez les avoir à pile 1,00 $ (frais en sus). Sur un DEX basé sur un mécanisme classique de Constant Product (x · y = k), chaque token acheté coûte plus cher que le précédent.

Formule du prix de vente d'un token x contre un token y dans un pool x · y = k :

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

Si vous balancez un ordre de 5 000 $ dans un pool qui n'a que 100 000 $ de liquidité, vous allez faire déraper le prix de ~5 %. Votre spread net théorique de 3 % se transforme instantanément en une perte de 2 %, avant même que votre tx ne soit mintée dans un bloc.

Tableau du spread réel en fonction du volume (Pool à 50k $, spread brut de 2,5 %)

Moralité : chaque taille de pool possède un plafond de volume strictement défini par les maths. Injecter trop de capital, c'est flinguer son propre R/R.

Automatisation du screener : on code un bot de monitoring en Python

Ouvrir son navigateur pour F5 des onglets DexScreener et le carnet d'ordres d'un CEX à la main, c’est complètement préhistorique. Un trader manuel utilise du code non pas pour exécuter automatiquement ses trades (sur ce terrain, impossible de rivaliser avec les bots MEV), mais pour déclencher un alerte sonore ou un ping Telegram/console instantané dès qu'une fenêtre anormale se profile.

Voici un script Python 3.10+ fully functional et prêt à tourner. Il surveille en temps réel les réserves directes d'un pool PancakeSwap v2 (BNB Chain) via RPC et les confronte au carnet d'ordres d'un CEX (ici l'API REST de Binance, facilement adaptable pour EXMON). Évidemment, le script est basique et mérite un peu de refacto pour être parfait, mais il fait parfaitement le job.

Code du scanner de spread prenant en compte les réserves et les fees

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
# estimation approximative du coût en gas pour le swap
ESTIMATED_GAS_COST_USD = 0.15
REQUEST_TIMEOUT = 3
# ============================================================
# WEB3
# ============================================================
w3 = Web3(Web3.HTTPProvider(BSC_RPC))
if not w3.is_connected():
   print("Erreur de connexion au RPC 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("Erreur de lecture 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("Le pool n'est pas une paire WBNB/USDT")
   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
):
   """
   Achat de BNB contre USDT.
   Retourne :
       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
):
   """
   Vente de BNB contre USDT.
   Retourne :
       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.")

Ce bot intègre le slippage réel dans ses calculs : au lieu de se baser sur un taux générique théorique, il simule le passage exact de votre ordre de 300 $ dans le modèle mathématique du pool.

Protocole d'exécution manuelle : comment ne pas finir en liquidité pour bots sandwich

Cliquer sur deux boutons sur différentes plateformes a l'air simple sur le papier. En pratique, 80 % des traders manuels perdent leurs profits au moment même où ils envoient leur transaction dans le mempool public.

Dès que votre ordre d'achat sur un DEX atterrit dans le mempool public d'Ethereum, BNB Chain ou Arbitrum, des bots MEV (Maximum Extractable Value) le repèrent instantanément. Si votre tolérance au slippage (Slippage Tolerance) dépasse 0,5 %, le bot vous colle une attaque sandwich (Sandwich Attack) :

• Le bot achète le token juste avant vous pour faire grimper le prix (Frontrun).
• Votre transaction s'exécute au pire prix possible, tout juste à la limite de votre slippage.
• Le bot revend le token immédiatement après vous pour s'en mettre plein les poches (Backrun).

Au final, vous récupérez le token au prix fort, et tout le spread va directement dans la poche du chercheur MEV.

Sécurisation du pipeline d'exécution

Pour capturer les spreads manuellement sans nourrir les bots, configurez vos transactions selon ce protocole :

• Noeuds RPC privés (MEV-Blocker / Flashbots). Oubliez les paramètres réseau par défaut de MetaMask. Toutes vos transactions sur les DEX doivent passer exclusivement par des relais privés qui envoient la transaction directement au validateur de bloc, en esquivant le mempool public.
  Pour Ethereum : https://rpc.mevblocker.io ou https://rpc.flashbots.net
  Pour BNB Chain / Polygon / Arbitrum : utilisez les services de protection MEV de QuickNode ou des solutions comme BloXroute.
• Limite de slippage stricte. Dégagez ces réglages par défaut à 1 % ou 2 % sur Uniswap ou 1inch. Le slippage max toléré pour un trade d'arbitrage doit se situer entre 0,1 % et 0,3 %. Si le prix bouge une fraction de seconde avant l'inclusion dans le bloc, la transaction doit échouer net (revert) plutôt que de s'exécuter à perte.
• Optimisation des frais de gas. Passez la configuration des frais de votre portefeuille Web3 en mode manuel (Advanced Gas Controls). Réglez le Max Priority Fee (le pourboire au validateur) légèrement au-dessus de la médiane actuelle du réseau pour vous tailler une place en début de bloc. Sur les L2 (Arbitrum, Base, OP), surveillez de près les frais de données L1 (L1 Data Fee) : en cas de grosse congestion sur Ethereum, envoyer des transactions sur un L2 peut vous coûter 5 fois plus cher que d'habitude.

Technique avancée : l'arbitrage delta-neutre « DEX Spot vs CEX Futures »

Détenir physiquement un altcoin sur les deux soldes vous expose au risque de baisse du marché (Market Price Risk) pendant que vous attendez qu'un spread se pointe. Si le token se prend une gamelle de 15 %, votre spread verrouillé de 2 % ne sauvera pas votre capital de la cata.

La méthodologie avancée utilisée à l'Académie EXMON repose sur le spread trading delta-neutre via les contrats futures.

Mécanique de fonctionnement via un hedge court (Short Hedge)

Au lieu d'acheter l'actif au comptant sur un CEX, vous y ouvrez une position short en futures avec un levier de 1x.

Algorithme d'exécution :

• Un décrochage de prix se produit sur le DEX : le token tombe à 0,95 $, tandis que sur le CEX, le futures et le spot restent à 1,00 $ (spread de 5,2 %).
• Vous achetez le spot sur le DEX à 0,95 $.
• En même temps, vous ouvrez un short sur les futures du CEX à 1,00 $.
• Votre delta est instantanément neutralisé : peu importe comment le marché bouge, la valeur totale de votre portefeuille ne bouge pas d'un poil.
• Quand le prix sur le DEX se réaligne sur le CEX (par exemple, les deux plateformes se calent à 0,98 $), vous fermez les deux :
  • Vente du spot sur le DEX à 0,98 $ (Profit : +0,03 $ par token).
  • Clôture du short sur le CEX à 0,98 $ (Profit : +0,02 $ par token).

Bénéfice net total : 0,05 $ par token (soit 5 % de rendement sur le capital engagé) sans le moindre risque de voir le prix du token s'effondrer.

Bonus sympa : si les futures sur le CEX tradent en contango (le prix du futures est plus élevé que le spot), vous encaissez en plus un funding rate (taux de financement) positif à chaque heure de règlement.

Pièges cachés et risques méconnus

Si une stratégie a l'air trop propre, c'est que vous n'avez pas encore vu les failles cachées. Le spread trading manuel est truffé de mines antipersonnel techniques.

1. Les tokens à taxe intégrée (Transfer Tax / Reflection Tokens)

Certains tokens ERC-20 / BEP-20 intègrent directement dans leur smart contract des frais par transfert (par exemple, 2 % à 5 % pour du burn ou alimenter un wallet marketing).

Si vous zappez l'audit du code du contrat via un explorateur ou un scanner (TokenSniffer, GoPlus), vous sortez le token du pool, vous perdez 5 % à cause de la mécanique du token, encore 0,3 % de frais AMM, et vous bouclez votre trade sur une grosse perte bien lourde.

2. Le piège de la liquidité concentrée sur Uniswap v3 (Concentrated Liquidity Trap)

Sur Uniswap v2, la liquidité est étalée de zéro à l'infini. Sur la v3, elle est concentrée dans des fourchettes de prix étroites (les ticks).

Si un spread apparaît parce que le prix a explosé hors de la fourchette du teneur de marché principal, la différence de prix visuelle peut paraître énorme (jusqu'à 10 % ou 20 %). Sauf que le volume de liquidité sur le tick actuel n'est peut-être que de 15 $. Essayer d'exécuter un trade là-dedans va provoquer un slippage monstre de plusieurs dizainesers de pourcents contre vous.

3. Déséquilibre de liquidité et capital bloqué (Inventory Risk)

En enchaînant un spread 5 fois de suite dans le même sens (ex: Achat sur DEX -> Vente sur CEX), vous allez vider tout votre stock d'USDT sur le CEX et vous retrouver avec un portefeuille Web3 gorgé d'altcoins.

Le rééquilibrage demande du temps et coûte des frais. Si le marché part dans une tendance forte, vous vous retrouverez coincé sur une seule jambe de votre position. Règle d'or du risque : ne laissez jamais le déséquilibre des soldes entre les plateformes dépasser un ratio de 70/30.

Checklist du trader avant de cliquer

Affichez cette checklist juste sous vos yeux. Ne passez à l'action que si ces 5 conditions sont réunies :

• Protection MEV activée : Le portefeuille est bien relié à un nœud RPC privé (MEV-Blocker / Flashbots).
• Profondeur du pool vérifiée : La taille de l'ordre ne dépasse pas 1 % à 2 % des réserves totales du pool sur le DEX (Price Impact < 0,3 %).
• Spread net validé : L'écart de prix couvre l'ensemble des frais CEX + DEX + Gas par un facteur d'au moins 2,5.
• Smart contract propre : Le token ne comporte aucune taxe de transfert cachée (Transfer Fee = 0 %).
• Capital réparti : Les soldes sur le CEX et le DEX sont suffisants des deux côtés de la paire pour exécuter instantanément sans attendre de transferts ou de bridges.

Le spread trading entre plateformes décentralisées et centralisées est une discipline mathématique. Ce n'est pas celui qui devine la direction du trend qui gagne, mais celui qui calcule le mieux ses frais, maîtrise son infrastructure et sait attendre son anomalie de marché.