Genesis Arbitrage

Genesis Arbitrage · · 16 min de lecture

API de carnet d’ordres crypto : profondeur, prix d’exécution et slippage entre exchanges

En bref

  • Une API de carnet d’ordres renvoie les niveaux d’achat et de vente — le prix et la taille de chacun — sous forme de snapshot REST ou de flux WebSocket de changements. Le meilleur bid et le meilleur ask ne décrivent que les premiers dollars d’une transaction.
  • La profondeur fixe le prix d’un gros ordre. Dans un exemple hypothétique, un achat de 10 000 $ traverse cinq niveaux, son prix moyen se retrouve 25 points de base au-dessus du mid du carnet, et le spread entre exchanges passe de 1,20 % à 0,70 %.
  • Sur les plans Pro et Max, Genesis API renvoie des prix d’exécution déjà calculés pour 500–10 000 $, le Δ des carnets pour les lignes d’arbitrage, l’âge et la profondeur des carnets, l’historique du slippage et une échelle de slippage DEX. REST uniquement ; les carnets accusent 5 à 20 secondes de retard sur l’exchange.

Une API de carnet d’ordres crypto renvoie les ordres d’achat et de vente en cours pour une paire, regroupés par niveau de prix : chaque niveau porte un prix et la taille qui s’y trouve. À partir de ces niveaux, on calcule le prix d’exécution d’un ordre d’une taille donnée, son slippage et la profondeur de marché, et, avec les carnets de deux exchanges, la part du spread qui survit à une transaction réelle.

Un exchange sert son propre carnet en snapshot REST ou en flux WebSocket, alors que Genesis API, sur les plans Pro et Max, sert des prix d’exécution, de la profondeur et le Δ des carnets déjà calculés pour de nombreux exchanges à la fois.

Ce que renvoie une API de carnet d’ordres

Un carnet d’ordres est la liste des ordres à cours limité en attente pour une paire. Les ordres d’achat (bids) sont triés du prix le plus élevé vers le bas, les ordres de vente (asks) du plus bas vers le haut. Un niveau est un prix et la taille totale à ce prix ; l’écart entre le meilleur ask et le meilleur bid est le spread du carnet.

Un snapshot REST est la réponse à une seule requête : les niveaux à cet instant. L’endpoint du carnet d’ordres de Binance est public et ne demande aucune clé API ; voici une requête pour les cinq meilleurs niveaux de BTC/USDT et une réponse (les chiffres sont hypothétiques) :

curl "https://api.binance.com/api/v3/depth?symbol=BTCUSDT&limit=5"
{
  "lastUpdateId": 81273645120,
  "bids": [["96015.90000000", "1.25000000"], …],
  "asks": [["96016.00000000", "0.84100000"], …]
}

Chaque niveau arrive sous la forme d’une paire de chaînes [prix, quantité], la quantité étant en coins : le meilleur bid contient 1,25 × 96 015,9 = 120 019,88 $. Le paramètre limit vaut 100 par défaut et peut aller jusqu’à 5 000 niveaux par côté (documentation de Binance).

Un flux WebSocket est poussé par l’exchange sur une connexion persistante. Binance propose deux types de flux de carnet : btcusdt@depth5, btcusdt@depth10 et btcusdt@depth20 poussent les 5, 10 ou 20 meilleurs niveaux, tandis que btcusdt@depth ne pousse que les changements. Les deux se mettent à jour toutes les 1 000 ms, ou toutes les 100 ms avec le suffixe @100ms (flux WebSocket de Binance).

Un carnet local complet se construit à partir d’un snapshot plus le flux de différences, en faisant correspondre le lastUpdateId du snapshot avec les identifiants de mise à jour des événements ; si un événement est manqué, le carnet est reconstruit de zéro.

MéthodeCe que vous obtenezÀ utiliser pour
Snapshot RESTNiveaux au moment de la requête, jusqu’à 5 000 par côté sur BinanceVérifications ponctuelles, interrogations peu fréquentes
Flux WebSocketMeilleurs niveaux ou changements toutes les 100–1 000 msUn carnet local en mémoire, un bot de trading
Genesis API via RESTNiveaux sous la forme [price, montant en USD], prix d’exécution, profondeur et âge du carnetComparer des exchanges, vérifier un setup

Pourquoi le meilleur bid et le meilleur ask trompent à grande taille

Le meilleur ask n’est que le prix du premier niveau. Un achat au marché supérieur à ce niveau prend les suivants, plus chers, et le prix moyen d’exécution grimpe : c’est le slippage.

Un exemple hypothétique : le token ABC sur l’exchange A, meilleur bid 0,9996, meilleur ask 1,0004, mid du carnet 1,0000. Un achat au marché de 10 000 $ traverse cinq niveaux d’ask :

Prix askDans le carnet, $Pris, $Coins
1,00041 1001 1001 099,56
1,00101 4001 4001 398,60
1,00182 6002 6002 595,33
1,00303 0003 0002 991,03
1,00506 0001 9001 890,55

L’ordre achète 9 975,07 coins au total. Le prix moyen d’exécution est le VWAP, le prix moyen pondéré par les volumes : 10 000 / 9 975,07 ≈ 1,0025.

Slippage par rapport au meilleur ask : (1,0025 − 1,0004) / 1,0004 × 100 ≈ 0,21 %. Par rapport au mid du carnet : (1,0025 − 1,0000) / 1,0000 × 10 000 = 25 points de base. Quatre d’entre eux correspondent à la moitié du spread du carnet, que paie tout achat au marché ; les 21 autres viennent de la profondeur.

Profondeur de marché à ±X % et murs

La profondeur de marché est la taille totale des ordres situés à une distance donnée du meilleur prix. Dans l’exemple, les asks à moins de +0,2 % du meilleur, jusqu’à 1,0024, totalisent 1 100 + 1 400 + 2 600 = 5 100 $, et à moins de +0,5 %, jusqu’à 1,0054, 14 100 $.

Lisez la profondeur comme une capacité : un ordre supérieur à la profondeur à +0,2 % sera exécuté sur des niveaux au-delà de cette limite. Sur l’exchange A, un achat de 5 000 $ y tient, pas un achat de 10 000 $.

Un mur est un gros ordre sur un seul niveau, nettement plus grand que ses voisins : 6 000 $ à 1,0050 dans l’exemple. Tant que le mur tient, il retient le prix, mais il peut être retiré une seconde avant que votre ordre l’atteigne, et l’achat s’exécute alors sur les niveaux situés derrière.

Dans Genesis API, la profondeur provient de /orderbooks/book, le carnet d’un marché, et de /orderbooks/coin/{coin}, les carnets d’un coin sur tous les exchanges et marchés à la fois (Carnet d’un marché, Carnets d’un coin). La réponse contient les 10 meilleurs bids et asks sous la forme [price, montant en USD], les plus gros murs dans walls_bid et walls_ask, et la profondeur de tout le côté à ±50 % du meilleur prix dans depth_bid_usd et depth_ask_usd. Un couloir de ±50 % est large : pour une taille précise, regardez les niveaux ou le prix d’exécution déjà calculé.

Âge du carnet : carnets périmés et profondeur limitée

Chaque snapshot de carnet a un âge. Si le carnet d’un exchange a 15 secondes de plus que celui de l’autre, une partie du spread entre eux peut être un décalage temporel : le prix du carnet le plus ancien a déjà bougé.

Dans Genesis API, les carnets accusent 5 à 20 secondes de retard sur l’exchange, et chacun porte son âge. Le début d’une réponse /orderbooks/book tirée de la documentation :

{
  "exchange": "Binance",
  "market": "spot",
  "coin": "BTC",
  "book_ts": 1794675858,
  "age_sec": 6,
  "stale": false,
  "source": "ws",
  "depth_limited": false,
  "levels_bid": 500,
  "levels_ask": 500,
  …
}

book_ts est l’heure du carnet en secondes unix, age_sec son âge en secondes, et stale: true signale un carnet de plus de 30 secondes. source indique comment le carnet a été pris sur l’exchange : par WebSocket (ws) ou par requêtes REST (rest).

depth_limited: true signifie que l’exchange publie une profondeur limitée : les totaux sont partiels et un gros ordre peut ne pas être exécuté. Lorsque les ordres s’épuisent, /orderbooks/exec renvoie null au lieu d’un prix, et le Δ des carnets renvoie le statut exhausted.

Spread exécutable entre exchanges : Δ des carnets

Revenons à l’exemple hypothétique. Sur l’exchange B, la dernière transaction s’est faite à 1,0120, le meilleur bid est 1,0116 et l’ask 1,0124. Les bids de B contiennent 1 100 $ à 1,0116, 1 300 $ à 1,0110, 2 800 $ à 1,0102, 2 900 $ à 1,0090 et 5 000 $ à 1,0070.

Vendre 10 000 $ dans ces bids donne un VWAP de 1,0095 par la même formule. Cela fait (1,0120 − 1,0095) / 1,0120 × 10 000 ≈ 24,7 points de base sous le mid du carnet de B.

Mode de calcul du spreadAcheter sur A → vendre sur BSpread
Dernières transactions, comme dans une ligne du tableau1,0000 → 1,01201,20 %
Meilleurs prix du carnet1,0004 → 1,01161,12 %
Après exécution de 10 000 $1,0025 → 1,00950,70 %

Spread de la ligne : (1,0120 − 1,0000) / 1,0000 × 100 = 1,20 %. Après exécution : (1,0095 − 1,0025) / 1,0025 × 100 ≈ 0,70 %. La ligne promet 120 $ sur 10 000 $, et il en reste environ 70 $ après les carnets : 10 000 × 0,006983 ≈ 69,83.

Sur les 50 points de base perdus, 8 sont partis dans l’écart entre la dernière transaction et les meilleurs ordres, et les 42 autres dans la profondeur des deux carnets.

Le Δ des carnets est le nom que Genesis Arbitrage donne au spread d’une ligne recalculé à travers les carnets d’ordres pour une taille donnée ; sur le site, c’est la colonne « Δ par ordres » des tableaux d’arbitrage, par exemple Spot – Futures. Dans l’API, il provient de /orderbooks/spreads/{dataset} : chaque ligne d’un coin dans le jeu de données spot-spot, spot-futures, futures-futures, dex-spot ou dex-futures reçoit un objet order_delta (Δ des carnets).

order_delta contient buy_price et sell_price pour la taille choisie, le spread_pct après exécution et un status : ok, no_book (pas de carnet) ou exhausted (le carnet n’a pas été rempli). Le volume vaut 0 (meilleurs prix du carnet) ou 500, 1000, 2500, 5000, 10000, et le résultat ne dépasse jamais le spread de la ligne. Les lignes DEX contiennent side et cex_price à la place d’une paire de prix : le côté CEX et son prix d’exécution.

Les prix d’exécution eux-mêmes, pour tous les marchés à la fois, proviennent de /orderbooks/exec : une paire [prix d’achat, prix de vente] sous une clé comme Binance|spot|BTC, avec null là où le carnet est trop mince (Prix d’exécution).

Le setup complet, avec le transfert du coin et les vérifications de réseau, est traité dans Arbitrage crypto entre exchanges.

Exemple Python : spread de la ligne et spread après exécution

Le script prend les setups Spot – Spot avec un spread d’au moins 0,5 %, demande le Δ des carnets à 5 000 $ pour les dix coins aux spreads les plus larges et affiche combien de points de base les carnets ont mangés. La clé provient de la variable d’environnement GENESIS_API_KEY. Sur 429 et 503, le script attend Retry-After secondes, et si l’attente dépasse une minute — le quota mensuel est épuisé — il s’arrête.

import os
import time
import requests

BASE = "https://api.genesisarbitrage.com/v1"
HEADERS = {"X-API-Key": os.environ["GENESIS_API_KEY"]}
VOLUME = 5000      # dollars par jambe
MIN_SPREAD = 0.5   # spread de la ligne, %


def get(path, params):
    for _ in range(3):
        r = requests.get(BASE + path, headers=HEADERS,
                         params=params, timeout=15)
        if r.status_code in (429, 503):
            wait = int(r.headers.get("Retry-After", "5"))
            if wait > 60:  # le quota mensuel est épuisé
                break
            time.sleep(wait)
            continue
        r.raise_for_status()
        return r.json()["data"]
    raise RuntimeError("L’API n’a pas répondu, réessayez plus tard")


rows = get("/arbitrage/spot-spot", {"min_spread": MIN_SPREAD})
rows.sort(key=lambda x: x["spread_pct"], reverse=True)
coins = list(dict.fromkeys(x["coin"] for x in rows))[:10]

for coin in coins:
    data = get("/orderbooks/spreads/spot-spot",
               {"coin": coin, "volume": VOLUME})
    for row in data:
        od = row["order_delta"]
        if row["spread_pct"] < MIN_SPREAD or od["status"] != "ok":
            continue  # no_book ou exhausted : la taille ne sera pas exécutée
        lost = (row["spread_pct"] - od["spread_pct"]) * 100
        print(f'{coin} {row["exchange_buy"]}→{row["exchange_sell"]}'
              f' {row["spread_pct"]:.2f}% → {od["spread_pct"]:.2f}%,'
              f' les carnets ont mangé {lost:.0f} pb')
    time.sleep(0.25)  # jusqu’à 4 requêtes par seconde : Pro en autorise 5

Le script effectue jusqu’à 11 appels avec une pause de 0,25 s entre les coins. Lancez-le en boucle pas plus souvent que meta.freshness_sec : 10 s sur Pro et 5 s sur Max (limites de Genesis API). Pour y ajouter des notifications, voir Bot d’arbitrage crypto en Python.

Historique du coût d’exécution

Un snapshot isolé ne dit pas si le slippage actuel est normal pour le marché ou si le carnet est plus mince que d’habitude. /orderbooks/exec-history renvoie l’historique de Genesis Charts : combien de points de base par rapport au mid du carnet coûte une exécution de 500, 1 000, 2 500, 5 000 et 10 000 $, séparément pour les achats et les ventes (Historique d’exécution).

Chaque intervalle compte 360 points : 1m couvre 6 heures, 15m 3,75 jours, 1h 15 jours et 1d environ un an, avec des données depuis le 6 septembre 2026. Une requête accepte jusqu’à 8 marchés dans le paramètre keys. Les valeurs d’achat sont positives et celles de vente négatives ; null signifie qu’il n’y a pas de données ou que le carnet n’a pas été rempli. Genesis API ne sert pas les snapshots passés du carnet lui-même.

import os
import statistics
import requests

KEY = "Binance|spot|BTC"
r = requests.get(
    "https://api.genesisarbitrage.com/v1/orderbooks/exec-history",
    headers={"X-API-Key": os.environ["GENESIS_API_KEY"]},
    params={"keys": KEY, "interval": "1h"},  # 360 heures, 15 jours
    timeout=15,
)
r.raise_for_status()
data = r.json()["data"]
series = data["series"][KEY]
if series is None:
    raise SystemExit("marché introuvable : " + KEY)
i = data["volumes_usd"].index(10000)  # la série d’achat de 10 000 $
buy = series["buy"][i]
known = [x for x in buy if x is not None]
if not known:
    raise SystemExit("aucune donnée pour la période")
print("médiane sur 15 jours, pb :", statistics.median(known))
print("dernier point, pb :", buy[-1])

Hypothétiquement, si la médiane sur 15 jours est de 12 points de base et le dernier point de 25, l’exécution coûte maintenant deux fois le niveau habituel, et il est logique de relever le seuil de spread pour ce coin.

DEX : échelle de slippage, taxes de tokens et honeypots

Un pool de DEX n’a pas de carnet d’ordres : le prix du swap provient de la formule du pool, et plus la transaction est grande par rapport à la liquidité, plus le prix bouge. C’est pourquoi une jambe DEX s’évalue avec une échelle : le slippage à une série de tailles.

/orderbooks/dex-slippage renvoie, par contrat, le slippage à l’achat et à la vente à 100, 500, 1 000, 2 500, 5 000, 10 000, 20 000, 50 000 et 100 000 $, les taxes du token et le flag honeypot, comme les colonnes du tableau DEX du site (Slippage DEX). Dans la réponse d’exemple de la documentation, le slippage à l’achat est de 0,86 % à 10 000 $, de 3,12 % à 50 000 $ et de 6,05 % à 100 000 $.

Cela fixe la limite d’un setup : un spread DEX – CEX de 2 % survit au slippage du pool à 10 000 $, mais pas à 50 000 $, avant même les frais. null dans l’échelle signifie que le pool manque de liquidité pour cette taille, et le gas du réseau n’est pas dans la réponse : prévoyez-le à part.

tax_buy_pct et tax_sell_pct sont la taxe d’achat et de vente du token en % ; null signifie qu’il n’y a pas de source et ne doit pas être lu comme zéro. honeypot : no — aucun signe, suspect — les sources divergent, yes — la vente du token peut être impossible.

Pour vérifier un token à la main, voir Comment vérifier un token avant de l’acheter ; pour les prix et la liquidité DEX à côté des CEX, voir API DEX.

Carnets d’ordres dans Genesis API : endpoints et plans

TâcheEndpoint
Prix d’exécution pour 500–10 000 $ sur chaque marché/orderbooks/exec
Le spread d’une ligne après exécution/orderbooks/spreads/{dataset}
10 niveaux, murs, profondeur et âge du carnet/orderbooks/book
Les carnets d’un coin sur chaque exchange/orderbooks/coin/{coin}
Historique du coût d’exécution/orderbooks/exec-history
Slippage DEX, taxes et flag honeypot/orderbooks/dex-slippage

Les six font partie des plans API Pro et Max. Pro coûte 100 $ par mois : 5 M d’appels, 5 requêtes par seconde, fraîcheur de 10 s. Max coûte 200 $ : 10 M d’appels, 15 requêtes par seconde, 5 s ; sur Trial et Start, les endpoints de carnets d’ordres renvoient 403 plan_restricted.

Les paramètres et des exemples de réponse figurent dans le guide des endpoints des carnets d’ordres ; pour un aperçu des données de l’API, voir API crypto et la leçon Données d’API pour l’arbitrage.

Questions et réponses

Pourquoi le spread du tableau est-il plus grand que celui que j’obtiens en transaction ?

Le spread de la ligne provient des dernières transactions, alors qu’un ordre au marché s’exécute contre le carnet, et plus la taille est grande, plus son prix moyen s’éloigne du meilleur. Les frais et le mouvement du prix pendant le transfert s’y ajoutent. Le Δ des carnets montre la part du spread qui reste à votre taille.

À quelle fréquence les carnets d’ordres se mettent-ils à jour ?

Un carnet change à chaque nouvel ordre et à chaque annulation ; le flux de Binance pousse les changements toutes les 100 ou 1 000 ms. Dans Genesis API, les carnets accusent 5 à 20 secondes de retard sur l’exchange (l’âge est dans age_sec), et les réponses se rafraîchissent toutes les 10 secondes sur Pro et toutes les 5 secondes sur Max.

Genesis API a-t-elle un WebSocket pour les carnets d’ordres ?

Non. Genesis API est uniquement REST : une requête HTTP GET et une réponse JSON. Les flux de carnets en temps réel viennent des WebSocket des exchanges eux-mêmes, et c’est ce dont a besoin un bot qui passe des ordres via l’API de trading d’un exchange.

Existe-t-il une API de carnet d’ordres gratuite ?

Les exchanges ont des endpoints publics : le carnet de Binance sur /api/v3/depth répond sans clé, mais il ne couvre qu’un exchange et vous calculez vous-même le prix d’exécution. Genesis API n’a pas de plan gratuit ; les carnets d’ordres sont inclus dans Pro à 100 $ par mois et dans Max à 200 $.