Dans l'écosystème des options cryptographiques, Deribit domine le marché avec plus de 85% du volume mondial sur les options Bitcoin et Ethereum. La reconstruction de la surface de volatilité implicite (IV Surface) constitue le fondement de nombreuses stratégies de trading quantitatif. Ce tutoriel technique couvre l'intégralité du pipeline : de l'extraction brute des données de chaîne d'options Deribit jusqu'à la construction mathématique de la surface IV tridimensionnelle.
Comparatif des solutions d'accès aux données Deribit
| Critère | HolySheep AI | API Officielle Deribit | Services relais tiers |
|---|---|---|---|
| Latence moyenne | <50ms | 120-300ms | 80-200ms |
| Prix par 1M tokens | DeepSeek V3.2: $0.42 | Gratuit (rate limits) | $2-15 |
| Paiement | WeChat/Alipay, ¥1=$1 | Crypto uniquement | Crypto + carte |
| Historique options | Via LLM enrichi | Direct via API REST | Variable |
| Calcul IV Surface | Assistance IA native | Code maison requis | Plugins payants |
| Credits gratuits | Oui, inscription | Non | Limité |
| SLA garanti | 99.9% | Variable | 99% |
Pour qui / Pour qui ce n'est pas fait
Ce tutoriel est fait pour :
- Les traders quantitatifs construisant des modèles de pricing d'options
- Les chercheurs en finance quantitative analysant la structure de volatilité
- Les développeurs de robots de trading sur options Deribit
- Les équipes desk desk cherchant à reconstruire des surfaces IV historiques
Ce tutoriel n'est pas fait pour :
- Les traders discrets qui n'ont pas besoin d'analyse technique avancée
- Les personnes cherchant des signaux de trading sans，理解 la modélisation
- Ceux qui n'ont pas d'expérience en programmation Python ou en finance quantitative
Comprendre l'architecture Deribit pour les options
Deribit expose une API REST et WebSocket complète. Les endpoints essentiels pour les données d'options sont :
/public/get_book_summary_by_currency- Résumé des options disponibles/public/get_order_book- Carnet d'ordres en temps réel/public/get_last_trades- Transactions récentes/public/get_historical_volatility- Volatilité historique des sous-jacents
Récupération des données de chaîne d'options
import requests
import json
from datetime import datetime, timedelta
Configuration Deribit API
BASE_URL = "https://www.deribit.com/api/v2"
def get_options_chain(instrument_name=None, currency="BTC", kind="option"):
"""
Récupère la chaîne d'options complète pour un sous-jacent
"""
url = f"{BASE_URL}/public/get_instruments"
params = {
"currency": currency,
"kind": kind,
"expired": "false"
}
response = requests.get(url, params=params)
data = response.json()
if data.get("success"):
return data["result"]
else:
raise Exception(f"Erreur API: {data}")
def get_option_greeks(instrument_name):
"""
Récupère les grecques et le prix pour une option spécifique
"""
url = f"{BASE_URL}/public/get_book_summary_by_instrument_name"
params = {"instrument_name": instrument_name}
response = requests.get(url, params=params)
data = response.json()
return data.get("result", {})
Exemple d'utilisation
options = get_options_chain(currency="BTC", kind="option")
print(f"Nombre d'options BTC disponibles: {len(options)}")
Filtrer par expiration (exemple: 29 décembre 2023)
target_date = "20231229"
filtered = [opt for opt in options if target_date in opt["instrument_name"]]
print(f"Options avec expiration {target_date}: {len(filtered)}")Construction du modèle de pricing Black-Scholes-Merton
Pour calculer la volatilité implicite, nous devons implémenter le modèle BSM avec la résolution numérique de l'équation de Black-Scholes par la méthode de Newton-Raphson.
import numpy as np
from scipy.stats import norm
from scipy.optimize import brentq
class BlackScholesMerton:
"""
Implémentation du modèle BSM pour le calcul de volatilité implicite
"""
def __init__(self, r=0.0):
self.r = r # Taux sans risque
def d1_d2(self, S, K, T, sigma):
"""Calcule d1 et d2 pour le modèle BSM"""
d1 = (np.log(S / K) + (self.r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
return d1, d2
def call_price(self, S, K, T, sigma):
"""Prix d'un call européen via BSM"""
if T <= 0 or sigma <= 0:
return max(0, S - K)
d1, d2 = self.d1_d2(S, K, T, sigma)
return S * norm.cdf(d1) - K * np.exp(-self.r * T) * norm.cdf(d2)
def put_price(self, S, K, T, sigma):
"""Prix d'un put européen via BSM"""
if T <= 0 or sigma <= 0:
return max(0, K - S)
d1, d2 = self.d1_d2(S, K, T, sigma)
return K * np.exp(-self.r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
def implied_volatility(self, market_price, S, K, T, option_type