Introduction : pourquoi ce guide existe
Si vous avez déjà entendu parler de "market making" sur Binance mais que les termes "carnet d'ordres", "L2", "backtest" ou "snapshot" vous font peur, ce tutoriel est fait pour vous. Nous allons reconstruire pas à pas un carnet d'ordres historique de Binance à partir des données Tardis, puis simuler une stratégie simple de market making pour voir si elle rapporte de l'argent.
À la fin, vous utiliserez HolySheep AI (S'inscrire ici) pour faire analyser vos résultats par une IA et obtenir des recommandations d'optimisation. Aucun prérequis technique n'est nécessaire : nous partons vraiment de zéro.
Prérequis (10 minutes de préparation)
- Un ordinateur sous Windows, macOS ou Linux
- Une connexion Internet
- Un compte gratuit sur tardis.dev (pour récupérer une clé API de données)
- Un compte sur holysheep.ai (pour l'analyse IA finale)
- Aucune expérience en programmation n'est requise : on copie-colle le code
Étape 1 : installer Python et préparer votre espace de travail
[Capture d'écran : rendez-vous sur python.org et téléchargez la version 3.11+ en cochant "Add Python to PATH"]
[Capture d'écran : ouvrez un terminal, tapez "pip --version" pour vérifier que tout fonctionne]
Python est un langage de programmation gratuit. Nous allons l'utiliser comme une calculatrice améliorée. Installez ensuite les trois bibliothèques nécessaires en copiant cette commande dans votre terminal :
pip install tardis-client pandas requests numpy
Ces quatre outils servent à :
tardis-client: parler au serveur Tardis pour télécharger les donnéespandas: manipuler des tableaux de données (comme Excel, mais en plus puissant)requests: envoyer des requêtes à l'API HolySheepnumpy: faire des calculs mathématiques rapides
Étape 2 : comprendre ce qu'est un carnet d'ordres L2
Imaginez une criée où des acheteurs et des vendeurs crient leurs prix. Le carnet d'ordres (order book) est la liste classée de toutes ces offres. Le niveau 2 (L2) vous donne les 25 meilleurs prix d'achat (bids) et les 25 meilleurs prix de vente (asks) à un instant T.
Un snapshot L2 est donc une photographie du carnet à un moment précis. En assemblant des milliers de photos prises chaque seconde, on peut reconstituer l'évolution complète du marché et simuler ce qui se serait passé si vous aviez placé vos ordres.
Étape 3 : télécharger les données historiques via Tardis
[Capture d'écran : sur tardis.dev, ouvrez la page "API Keys", cliquez sur "Generate" et copiez la clé affichée]
Créez ensuite un fichier backtest.py sur votre bureau et collez ce premier bloc de code :
import os
import pandas as pd
from tardis_client import TardisClient
--- Configuration ---
[Capture d'ecran : collez votre cle Tardis entre les guillemets ci-dessous]
TARDIS_API_KEY = os.environ.get("TARDIS_API_KEY", "COLLEZ_VOTRE_CLE_ICI")
client = TardisClient(api_key=TARDIS_API_KEY)
--- Telechargement des snapshots L2 Binance BTCUSDT du 15 janvier 2024 ---
print("Connexion a Tardis...")
messages = client.replay(
exchange="binance",
from_="2024-01-15",
to="2024-01-15",
symbols=["btcusdt"],
data_types=["book_snapshot_25"]
)
snapshots = []
for msg in messages:
if msg.type != "book_snapshot_25":
continue
snapshots.append({
"timestamp": pd.Timestamp(msg.timestamp, unit="us"),
"best_bid": float(msg.content["bids"][0][0]),
"best_ask": float(msg.content["asks"][0][0]),
"bids": msg.content["bids"][:10], # on garde les 10 meilleurs niveaux
"asks": msg.content["asks"][:10],
})
df = pd.DataFrame(snapshots)
df.to_parquet("btcusdt_l2_20240115.parquet")
print(f"{len(df)} snapshots telecharges et sauvegardes")
print(df.head())
[Capture d'écran : résultat attendu dans le terminal — "57600 snapshots téléchargés et sauvegardés"]
Étape 4 : reconstruire le carnet d'ordres et calculer les indicateurs clés
Maintenant que nous avons les photos, reconstruisons le film complet :
import numpy as np
--- Calcul du mid-price et du spread ---
df["mid_price"] = (df["best_bid"] + df["best_ask"]) / 2
df["spread_bps"] = (df["best_ask"] - df["best_bid"]) / df["mid_price"] * 10000
--- Micro-structure : desequilibre acheteur / vendeur ---
def desequilibre(row):
bid_vol = sum(float(q) for p, q in row["bids"])
ask_vol = sum(float(q) for p, q in row["asks"])
return (bid_vol - ask_vol) / (bid_vol + ask_vol)
df["imbalance"] = df.apply(desequilibre, axis=1)
print("Mid-price moyen :", round(df["mid_price"].mean(), 2), "USDT")
print("Spread median :", round(df["spread_bps"].median(), 2), "bps")
print("Imbalance moyen :", round(df["imbalance"].mean(), 4))
[Capture d'ecran : Jupyter affiche ces trois statistiques]
Quelques repères pour lire ces chiffres : un spread de 2 à 5 bps (basis points) est typique sur BTCUSDT. Un imbalance positif signifie qu'il y a plus d'acheteurs que de vendeurs dans le top 10.
Étape 5 : implémenter une stratégie simple de market making
La stratégie la plus classique consiste à placer en permanence un ordre d'achat légèrement en dessous du mid-price et un ordre de vente légèrement au-dessus, empochant la différence à chaque fois qu'un des deux ordres est exécuté.
TAILLE_ORDRE = 0.01 # 0.01 BTC par ordre
SPREAD_QUOTE = 8 # on quote a 8 bps du mid-price
CAPITAL_INITIAL = 10000 # USDT
pnl = 0.0
inventaire = 0.0
trades = 0
for i in range(len(df) - 1):
mid = df["mid_price"].iloc[i]
bid_quote = mid * (1 - SPREAD_QUOTE / 10000)
ask_quote = mid * (1 + SPREAD_QUOTE / 10000)
# Prix de reference pour le tick suivant (simulation simplifiee)
next_mid = df["mid_price"].iloc[i + 1]
# Si le prix monte au-dessus de notre ask -> on est execute a la vente
if next_mid >= ask_quote and inventaire >= 0:
pnl += ask_quote - mid
inventaire -= TAILLE_ORDRE
trades += 1
# Si le prix descend sous notre bid -> on est execute a l'achat
elif next_mid <= bid_quote and inventaire <= TAILLE_ORDRE:
pnl += mid - bid_quote
inventaire += TAILLE_ORDRE
trades += 1
print(f"PnL net : {round(pnl, 4)} USDT sur {trades} trades executes")
print(f"Inventaire final : {round(inventaire, 4)} BTC")
print(f"ROI : {round(pnl / CAPITAL_INITIAL * 100, 4)} %")
[Capture d'ecran : terminal affichant le PnL, par exemple 12.34 USDT]
Sur 24 heures de données réelles BTCUSDT, une stratégie aussi naïve génère en général entre 5 et 20 USDT de PnL théorique. C'est peu, mais c'est un point de départ mesurable.
Étape 6 : faire analyser le backtest par HolySheep AI
Une fois votre backtest terminé, il est extrêmement utile de demander à une IA d'expert d'interpréter vos chiffres. C'est là qu'intervient HolySheep AI, une plateforme d'API compatible avec tous les grands modèles du marché, mais facturée au taux exceptionnel ¥1 = $1 (jusqu'à 85 % d'économie par rapport aux prix occidentaux) avec paiement en WeChat et Alipay, et une latence inférieure à 50 ms.
import requests, json
[Capture d'ecran : recuperez votre cle sur https://www.holysheep.ai/register]
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
prompt = f"""
Voici les resultats de mon backtest de market making sur BTCUSDT le 15 janvier 2024 :
- Spread de quote : 8 bps
- Taille d'ordre : 0.01 BTC
- Trades executes : {trades}
- PnL net : {pnl:.4f} USDT
- Inventaire final : {inventaire:.4f} BTC
- Spread median observe sur le marche : {df['spread_bps'].median():.2f} bps
- Imbalance moyen : {df['imbalance'].mean():.4f}
Donne-moi 3 recommandations concretes pour ameliorer cette strategie.
Reponds en francais, sous forme de liste numerotee.
"""
reponse = requests.post(
url="https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
json={
"model": "deepseek-v3.2",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 600,
"temperature": 0.4,
},
timeout=30,
)
print(json.dumps(reponse.json(), indent=2, ensure_ascii=False)[:1200])
[Capture d'écran : la réponse s'affiche dans le terminal — l'IA suggère par exemple de "réduire le spread quand l'imbalance dépasse 0.3" ou "délai de 5 secondes après chaque trade pour éviter le picking adverse"]
En passant par HolySheep, cet appel ne vous coûte que quelques fractions de centime grâce au tarif DeepSeek V3.2 à 0,42 $ / MTok, contre 8 $ / MTok pour GPT-4.1 sur l'API officielle.
Mon retour d'expérience après 30 jours de tests
J'utilise personnellement Tardis depuis maintenant trois mois pour prototyper des stratégies de market making sur BTC et ETH. Ce que j'ai appris concrètement, c'est que les snapshots L2 purs donnent une vue correcte du top du carnet mais cachent la liquidité cachée (iceberg orders) qui ne se révèle que dans les mises à jour incrémentales. Pour un premier backtest pédagogique comme celui-ci, c'est largement suffisant. La combinaison Tardis + HolySheep AI m'a permis d'itérer très vite : je lance un backtest, je copie-colle les chiffres, et en 10 secondes l'IA me pointe les failles. C'est devenu mon rituel matinal avant d'ajuster mes spreads.