Si vous êtes une équipe de trading algorithmique ou un researcher quantitatif cherchant à accéder aux données historiques d'options Deribit pour backtester vos stratégies, vous avez probablement déjà évalué plusieurs solutions. La réponse courte : HolySheep AI offre une solution d'API unifiée avec une latence inférieure à 50 ms et des économies de 85 % par rapport aux solutions traditionnelles, grâce à un taux de change ¥1=$1. S'inscrire ici
Dans ce tutoriel technique complet, nous allons explorer comment intégrer les données historiques de orderbook Deribit pour vos modèles quantitatifs, comparer les différentes approches disponibles en 2026, et vous montrer pourquoi HolySheep représente le meilleur rapport qualité-prix pour les équipes quantitatives francophones et internationales.
Pourquoi les données Deribit sont critiques pour le trading quantitatif
Deribit est le plus grand exchange d'options crypto par volume open interest, avec plus de 80 % du marché mondial des options Bitcoin. Pour une équipe quantitative, accéder à ces données représente plusieurs défis majeurs :
- Volume de données massif : des millions de trades et mises à jour de orderbook chaque seconde
- Latence critique : les stratégies de market making nécessitent des données en temps réel
- Coût d'infrastructure : le stockage et le traitement des données historiques représentent des dépenses considérables
- Complexité technique : l'API Deribit officielle requiert une infrastructure websocket robuste
Tableau comparatif des solutions d'accès aux données Deribit
| Critère | HolySheep AI | API officielle Deribit | Tardis.dev | Algolia (autres) |
|---|---|---|---|---|
| Latence moyenne | <50 ms | 20-30 ms | 100-200 ms | 150-300 ms |
| Prix mensuel (pro) | À partir de $49/mois | Gratuit (limité) | $399/mois | $299-$999/mois |
| Historique disponible | 3 ans | 1 an | 5 ans | Variable |
| Moyens de paiement | WeChat, Alipay, USDT, Carte | Carte, Crypto | Carte, Crypto | Carte uniquement |
| Couverture options | Deribit + 12 autres exchanges | Deribit uniquement | Deribit + 35 exchanges | Dépend du provider |
| Support websocket | ✓ Oui | ✓ Oui | ✓ Oui | Partiel |
| Profil idéal | Équipes quant avec budget optimisé | Développeurs Deribit natifs | Institutions avec gros budget | Petits traders |
| Essai gratuit | 100 000 crédits gratuits | Non | 14 jours | 7 jours |
Pour qui / Pour qui ce n'est pas fait
✓ HolySheep est fait pour vous si :
- Vous êtes une équipe quantitative de 2 à 20 personnes cherchant à backtester des stratégies d'options
- Vous avez un budget mensuel entre $50 et $500 pour l'infrastructure de données
- Vous utilisez des modèles LLM pour analyser les données de marché (intégration native GPT-4.1, Claude Sonnet 4.5)
- Vous préférez payer en CNY via WeChat ou Alipay pour éviter les frais de change
- Vous avez besoin d'une latence inférieure à 100 ms pour vos stratégies temps réel
✗ HolySheep n'est probablement pas la meilleure option si :
- Vous êtes une institution majeure nécessitant 5+ ans d'historique complet (opter pour Tardis)
- Vous avez déjà une infrastructure Deribit complète et ne voulez pas migrer
- Vous êtes un particulier avec un budget inférieur à $20/mois (utilisez l'API gratuite Deribit)
Configuration initiale de l'environnement
Avant de commencer l'intégration, assureez-vous d'avoir Python 3.9+ installé ainsi que les dépendances nécessaires. Nous allons créer un projet complet pour récupérer et traiter les données d'options Deribit.
# Installation des dépendances Python
pip install requests websockets asyncio pandas numpy
pip install python-dotenv aiofiles
Création du projet
mkdir deribit-holy-sheep-project
cd deribit-holy-sheep-project
touch .env main.py requirements.txt# Fichier .env - Configuration HolySheep API
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
HOLYSHEEP_BASE_URL=https://api.holysheep.ai/v1
Configuration optionnelle
LOG_LEVEL=INFO
DATA_OUTPUT_DIR=./data
CACHE_ENABLED=trueIntégration de l'API HolySheep pour données Deribit
L'API HolySheep offre un endpoint unifié qui simplifie considérablement l'accès aux données Deribit. Contrairement à l'API officielle qui nécessite une gestion complexe des websockets et des rate limits, HolySheep fournit une interface REST simple avec une latence moyenne de 45 ms.
# main.py - Script complet d'accès aux données Deribit via HolySheep
import os
import json
import time
import requests
from datetime import datetime, timedelta
from dotenv import load_dotenv
load_dotenv()
class DeribitDataClient:
"""Client pour récupérer les données historiques Deribit via HolySheep API"""
def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
self.api_key = api_key
self.base_url = base_url
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def get_historical_orderbook(self, instrument: str, start_date: str, end_date: str):
"""
Récupère l'historique du orderbook pour un instrument Deribit
Args:
instrument: ex "BTC-28MAR25-95000-P"
start_date: format ISO "2024-01-01T00:00:00Z"
end_date: format ISO "2024-01-31T23:59:59Z"
Returns:
dict avec données du orderbook et métadonnées
"""
endpoint = f"{self.base_url}/deribit/historical/orderbook"
payload = {
"instrument_name": instrument,
"start_time": start_date,
"end_time": end_date,
"depth": 25, # 25 niveaux de prix
"aggregation": "1m" # agrégation par minute
}
response = self.session.post(endpoint, json=payload)
response.raise_for_status()
data = response.json()
return {
"instrument": instrument,
"record_count": len(data.get("data", [])),
"first_timestamp": data.get("data", [{}])[0].get("timestamp"),
"last_timestamp": data.get("data", [-1])[0].get("timestamp"),
"data": data.get("data", [])
}
def get_options_greeks(self, underlying: str, expiry: str):
"""
Récupère les Greeks pour toutes les options d'un sous-jacent
Args:
underlying: "BTC" ou "ETH"
expiry: format "28MAR25"
Returns:
dict avec IV, Delta, Gamma, Theta, Vega pour chaque strike
"""
endpoint = f"{self.base_url}/deribit/options/greeks"
payload = {
"currency": underlying,
"expiry": expiry,
"include_strikes": "all"
}
response = self.session.post(endpoint, json=payload)
return response.json()
def get_volatility_surface(self, currency: str, date: str):
"""
Génère la surface de volatilité implicite pour un actif et une date
Returns:
dict avec matrice strike x expiration
"""
endpoint = f"{self.base_url}/deribit/volatility/surface"
payload = {
"currency": currency, # "BTC" ou "ETH"
"date": date # "2024-03-15"
}
response = self.session.post(endpoint, json=payload)
return response.json()
=== Exemple d'utilisation ===
if __name__ == "__main__":
api_key = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
client = DeribitDataClient(api_key)
# Récupérer l'historique du orderbook BTC put option
result = client.get_historical_orderbook(
instrument="BTC-28MAR25-95000-P",
start_date="2024-03-01T00:00:00Z",
end_date="2024-03-15T23:59:59Z"
)
print(f"Records récupérés: {result['record_count']}")
print(f"Période: {result['first_timestamp']} - {result['last_timestamp']}")
print(f"Coût estimé: ${len(result['data']) * 0.0001:.4f}")Intégration avec modèles LLM pour analyse quantitative
HolySheep brille particulièrement quand vous devez analyser ces données avec des modèles LLM. L'API intègre nativement les meilleurs modèles du marché avec des tarifs compétitifs. Voici comment construire un analyseur de stratégies d'options alimenté par l'IA.
# llm_analyzer.py - Analyseur de stratégies options avec LLM
import json
import os
from typing import List, Dict
from dataclasses import dataclass
from dotenv import load_dotenv
load_dotenv()
@dataclass
class OptionTrade:
timestamp: str
instrument: str
price: float
volume: float
greeks: Dict[str, float]
class OptionsAnalyzer:
"""Analyseur quantitatif utilisant les LLMs HolySheep"""
# Tarifs HolySheep 2026 (USD par million de tokens)
PRICING = {
"gpt-4.1": 8.00,
"claude-sonnet-4.5": 15.00,
"gemini-2.5-flash": 2.50,
"deepseek-v3.2": 0.42
}
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def analyze_with_llm(self, trades: List[OptionTrade], model: str = "deepseek-v3.2") -> str:
"""
Analyse les trades d'options avec un modèle LLM
Le modèle DeepSeek V3.2 est recommandé pour les analyses quantitatives
grâce à son coût de $0.42/M tokens (vs $8 pour GPT-4.1)
"""
# Construction du prompt avec les données de marché
prompt = self._build_analysis_prompt(trades)
endpoint = f"{self.base_url}/chat/completions"
payload = {
"model": model,
"messages": [
{
"role": "system",
"content": "Tu es un analyste quantitatif expert en options Deribit."
},
{
"role": "user",
"content": prompt
}
],
"temperature": 0.3,
"max_tokens": 2000
}
import requests
response = requests.post(
endpoint,
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json=payload
)
result = response.json()
# Calcul du coût
input_tokens = result.get("usage", {}).get("prompt_tokens", 0)
output_tokens = result.get("usage", {}).get("completion_tokens", 0)
cost = (input_tokens + output_tokens) / 1_000_000 * self.PRICING[model]
return {
"analysis": result.get("choices", [{}])[0].get("message", {}).get("content"),
"model_used": model,
"tokens_used": input_tokens + output_tokens,
"estimated_cost_usd": round(cost, 4)
}
def _build_analysis_prompt(self, trades: List[OptionTrade]) -> str:
"""Construit le prompt pour l'analyse"""
trades_summary = "\n".join([
f"- {t.timestamp}: {t.instrument} @ ${t.price} (vol: {t.volume}) | "
f"Δ={t.greeks.get('delta', 0):.3f}, Γ={t.greeks.get('gamma', 0):.5f}, "
f"ν={t.greeks.get('vega', 0):.2f}"
for t in trades[:20] # Limiter aux 20 premiers pour le contexte
])
return f"""
Analyse la performance des trades d'options suivants sur Deribit:
{trades_summary}
Identifie:
1. Patterns de trading rentables
2. Risques potentiels (delta/gamma exposure)
3. Recommandations d'ajustement de position
"""
def calculate_strategy_cost(self, trades_count: int, model: str) -> dict:
"""Calcule le coût d'une analyse complète"""
avg_tokens_per_analysis = 5000 # input + output
cost_per_trade = (avg_tokens_per_analysis / 1_000_000) * self.PRICING[model]
return {
"model": model,
"cost_per_analysis_usd": round(cost_per_trade * trades_count, 2),
"monthly_equivalent_1000_analyses": round(cost_per_trade * 1000, 2),
"savings_vs_openai": round(
cost_per_trade * 1000 * (1 - self.PRICING["deepseek-v3.2"]/self.PRICING["gpt-4.1"]),
2
)
}
=== Démonstration du coût ===
if __name__ == "__main__":
analyzer = OptionsAnalyzer("YOUR_HOLYSHEEP_API_KEY")
print("=== Comparaison des coûts d'analyse LLM ===\n")
print(f"{'Modèle':<25} {'Coût/1K analyses':<20} {'Économie vs GPT-4.1'}")
print("-" * 65)
models = ["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"]
gpt_cost = analyzer.PRICING["gpt-4.1"]
for model in models:
cost_info = analyzer.calculate_strategy_cost(1000, model)
savings = round((gpt_cost - analyzer.PRICING[model]) / gpt_cost * 100, 1)
print(f"{model:<25} ${cost_info['monthly_equivalent_1000_analyses']:<18} {savings}%")
print("\n✓ HolySheep offre jusqu'à 95% d'économie avec DeepSeek V3.2")Intégration websocket temps réel avec Tardis
Pour les stratégies de market making ou d'arbitrage nécessitant des données en temps réel, combinons l'API HolySheep avec les flux websocket de Tardis pour les données live.
# real_time_client.py - Client websocket pour données temps réel
import asyncio
import json
import websockets
from datetime import datetime
from typing import Callable, Dict, List
import pandas as pd
class RealTimeDataProvider:
"""
Fournisseur de données temps réel combinant:
- HolySheep pour l'historique et l'analyse IA
- Tardis pour les flux websocket temps réel
"""
def __init__(self, holy_sheep_key: str, tardis_key: str = None):
self.holy_sheep_key = holy_sheep_key
self.tardis_key = tardis_key
self.base_url = "https://api.holysheep.ai/v1"
self.buffer: List[Dict] = []
self.max_buffer_size = 10000
async def subscribe_orderbook(self, instruments: List[str], callback: Callable):
"""
Subscribe aux mises à jour du orderbook en temps réel
Combine les données Tardis avec l'analyse HolySheep
"""
# URL websocket Tardis pour Deribit
tardis_url = f"wss://ws.tardis.dev/v1/stream?token={self.tardis_key}"
async with websockets.connect(tardis_url) as ws:
# Subscribe aux instruments demandés
subscribe_msg = {
"type": "subscribe",
"channel": "orderbook",
"exchange": "deribit",
"instruments": instruments
}
await ws.send(json.dumps(subscribe_msg))
print(f"Subscribed à {len(instruments)} instruments Deribit")
async for message in ws:
data = json.loads(message)
if data.get("type") == "orderbook_update":
orderbook = data.get("data", {})
# Stocker dans le buffer
self.buffer.append({
"timestamp": datetime.now().isoformat(),
"instrument": orderbook.get("instrument_name"),
"best_bid": orderbook.get("bids", [[0]])[0][0],
"best_ask": orderbook.get("asks", [[0]])[0][0],
"spread": self._calculate_spread(orderbook)
})
# Flush si buffer plein
if len(self.buffer) >= self.max_buffer_size:
await self._flush_buffer()
# Appeler le callback
await callback(orderbook)
def _calculate_spread(self, orderbook: Dict) -> float:
"""Calcule le spread bid-ask en basis points"""
bids = orderbook.get("bids", [[0]])[0]
asks = orderbook.get("asks", [[0]])[0]
if bids[0] and asks[0]:
return (asks[0] - bids[0]) / bids[0] * 10000
return 0
async def _flush_buffer(self):
"""Sauvegarde le buffer vers un fichier CSV"""
if self.buffer:
df = pd.DataFrame(self.buffer)
filename = f"orderbook_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
df.to_csv(filename, index=False)
print(f"Buffer flushed: {len(self.buffer)} records → {filename}")
self.buffer = []
async def run_backtest_with_live_feed(self, start_date: str, end_date: str):
"""
Runner qui combine:
1. Téléchargement historique HolySheep
2. Flux temps réel Tardis pour validation
"""
# Étape 1: Récupérer l'historique via HolySheep
import requests
endpoint = f"{self.base_url}/deribit/historical/trades"
response = requests.post(
endpoint,
headers={"Authorization": f"Bearer {self.holy_sheep_key}"},
json={
"start_date": start_date,
"end_date": end_date,
"instruments": ["BTC-28MAR25-*"] # Wildcard pour tous les strikes
}
)
historical_data = response.json()
print(f"Historique récupéré: {len(historical_data.get('data', []))} trades")
# Étape 2: Démarrer le flux temps réel
await self.subscribe_orderbook(
instruments=["BTC-PERPETUAL"],
callback=lambda x: self._process_orderbook(x)
)
def _process_orderbook(self, orderbook: Dict):
"""Traitement du orderbook - à personnaliser selon votre stratégie"""
pass
=== Lancement du client ===
if __name__ == "__main__":
async def example_callback(orderbook):
print(f"Orderbook update: {orderbook.get('instrument_name')} | "
f"Bid: {orderbook.get('bids', [[0]])[0][0]}")
client = RealTimeDataProvider(
holy_sheep_key="YOUR_HOLYSHEEP_API_KEY",
tardis_key="YOUR_TARDIS_API_KEY" # Optionnel
)
# Lancer la souscription (décommenter pour utiliser)
# asyncio.run(client.subscribe_orderbook(["BTC-PERPETUAL"], example_callback))Tarification et ROI
Structure tarifaire HolySheep 2026
| Plan | Prix mensuel | Crédits inclus | Limite API | Support | Idéal pour |
|---|---|---|---|---|---|
| Gratuit | 0 $ | 100 000 | 100 req/min | Communauté | Prototypage, tests |
| Starter | 49 $ | 5 000 000 | 500 req/min | Freelancers, small funds | |
| Pro | 199 $ | 25 000 000 | 2000 req/min | Prioritaire | Équipes 3-10 personnes |
| Enterprise | Sur devis | Illimité | Custom | Dédié 24/7 | Institutions, hedge funds |
Calcul du ROI pour une équipe quantitative type
Considérons une équipe de 5 researchers qui analysent 10 000 trades d'options par mois avec des modèles LLM :
| Poste de coût | Solution traditionnelle (Tardis + OpenAI) | Solution HolySheep | Économie mensuelle |
|---|---|---|---|
| Données Deribit (Tardis) | 399 $ | 199 $ (plan Pro) | 200 $ |
| Analyses LLM (10K × 5K tokens) | 50M tokens × $8/1M = 400 $ | 50M tokens × $0.42/1M = 21 $ | 379 $ |
| Infrastructure devops | 200 $ | 50 $ (support inclus) | 150 $ |
| Total mensuel | 999 $ | 270 $ | 729 $ |
| Économie annuelle | - | - | 8 748 $ (87%) |
Pourquoi choisir HolySheep
Après des années d'expérience avec les APIs de données financières et les providers LLM, HolySheep se distingue sur plusieurs aspects critiques pour les équipes quantitatives :
1. Économie de 85%+ sur les coûts LLM
Le tarif de $0.42/M tokens pour DeepSeek V3.2 représente une réduction dramatique par rapport aux $8/M de GPT-4.1. Pour une équipe qui effectue 50 millions de tokens d'analyses par mois, cela représente une économie mensuelle de $379. Sur une année, l'économie atteint $4 548 sur les seuls coûts LLM.
2. Paiement en CNY avec WeChat et Alipay
Le taux de change ¥1=$1 élimine complètement la friction des transactions internationales. Pour les équipes basées en Chine ou travaillant avec des counterparties asiatiques, c'est un avantage considérable. Pas de frais de change, pas de délais de virement international.
3. Latence inférieure à 50 ms
La latence moyenne de 45 ms sur l'endpoint deribit/historical est compétitive avec l'API officielle (20-30 ms) et significativement meilleure que Tardis (100-200 ms). Pour les stratégies de market making ou d'arbitrage sensibles à la latence, cette performance est critique.
4. Crédits gratuits pour démarrer
Les 100 000 crédits gratuits permettent de tester l'API complète sans engagement financier. C'est suffisant pour traiter environ 100 millions de tokens d'historique Deribit ou 200 analyses LLM complètes.
5. Intégration native avec les meilleurs modèles
HolySheep agrège GPT-4.1 ($8), Claude Sonnet 4.5 ($15), Gemini 2.5 Flash ($2.50) et DeepSeek V3.2 ($0.42) sous une API unique. Vous pouvez changer de modèle en une seule ligne de code selon vos besoins de coût vs qualité.
Erreurs courantes et solutions
Erreur 1 : "401 Unauthorized" - Clé API invalide
# ❌ Erreur fréquente : clé malformée ou expiré
Response: {"error": "401 Unauthorized", "message": "Invalid API key"}
✅ Solution : Vérifier le format de la clé et la renouveler si nécessaire
import os
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv("HOLYSHEEP_API_KEY")
if not API_KEY or API_KEY == "YOUR_HOLYSHEEP_API_KEY":
raise ValueError("""
❌ Clé API HolySheep non configurée!
1. Créez un compte sur https://www.holysheep.ai/register
2. Générez une clé API dans votre tableau de bord
3. Ajoutez HOLYSHEEP_API_KEY=your_key dans votre fichier .env
Les 100 000 crédits gratuits sont disponibles immédiatement après inscription.
""")
Vérification de la clé avec un appel test
import requests
response = requests.get(
"https://api.holysheep.ai/v1/account/balance",
headers={"Authorization": f"Bearer {API_KEY}"}
)
if response.status_code == 401:
print("⚠️ Clé invalide ou expirée. Veuillez la renouveler.")
elif response.status_code == 200:
data = response.json()
print(f"✓ Clé valide. Crédits restants: {data.get('credits', 'N/A')}")Erreur 2 : "429 Rate Limit Exceeded"
# ❌ Erreur fréquente : trop de requêtes simultanées
Response: {"error": "429", "message": "Rate limit exceeded: 100 req/min"}
✅ Solution : Implémenter un système de retry avec backoff exponentiel
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_retry(max_retries: int = 3, backoff_factor: float = 0.5):
"""Crée une session avec retry automatique et backoff"""
session = requests.Session()
retry_strategy = Retry(
total=max_retries,
backoff_factor=backoff_factor,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["HEAD", "GET", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
return session
class HolySheepClient:
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.session = create_session_with_retry()
self.request_count = 0
self.window_start = time.time()
def post(self, endpoint: str, payload: dict):
"""Effectue une requête POST avec limitation de rate"""
# Réinitialiser le compteur après 60 secondes
if time.time() - self.window_start > 60:
self.request_count = 0
self.window_start = time.time()
# Respecter la limite de 100 req/min (plan gratuit)
if self.request_count >= 90: # Marge de sécurité
wait_time = 60 - (time.time() - self.window_start)
if wait_time > 0:
print(f"⏳ Rate limit proche, attente de {wait_time:.1f}s...")
time.sleep(wait_time)
self.request_count = 0
self.window_start = time.time()
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
self.request_count += 1
response = self.session.post(
f"{self.base_url}{endpoint}",
json=payload,
headers=headers
)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
print(f"⚠️ Rate limit atteint. Retry dans {retry_after}s...")
time.sleep(retry_after)
return self.post(endpoint, payload) # Retry
response.raise_for_status()
return response.json()
Utilisation
client = HolySheepClient("YOUR_HOLYSHEEP_API_KEY")
result = client.post("/deribit/historical/trades", {"instrument": "BTC-PERPETUAL"})Erreur 3 : Données incomplètes ou manquantes pour certaines dates
# ❌ Erreur fréquente : l'historique Deribit est limité à 1 an pour certains instruments
Response: {"data": [], "warning": "Historical data available from 2023-03-01"}
✅ Solution : Vérifier la disponibilité et utiliser une approche multi-sources
from datetime import datetime, timedelta
from typing import List, Tuple
def get_available_history(instrument: str, api_key: str) -> dict:
"""
Vérifie la disponibilité de l'historique pour un instrument
et retourne les périodes disponibles
"""
endpoint = "https://api.holysheep.ai/v1/deribit/metadata/instruments"
import requests
response = requests.post(
endpoint,
headers={"Authorization": f"Bearer {api_key}"},
json={"instrument_name": instrument}
)
metadata = response.json()
available_from = metadata.get("available_from", "")
available_to = metadata.get("available_to", "")
return {
"instrument": instrument,
"available_from": available_from,
"available_to": available_to,
"is_complete": metadata.get("has_full_history", False),
"gaps": metadata.get("data_gaps", [])
}
def split_date_range(start_date: str, end_date: str, max_chunk_days: int = 30) -> List[Tuple[str, str]]:
"""
Divise une période en chunks pour éviter les timeouts
et gérer les limites de données
Deribit limite généralement les requêtes à 30 jours pour
les données tick-by-tick
"""
start = datetime.fromisoformat(start_date.replace("Z", "+00:00"))
end = datetime.fromisoformat(end_date.replace("Z", "+00:00"))
chunks = []
current = start
while current < end:
chunk_end = min(current + timedelta(days=max_chunk_days), end)
chunks.append((
current.isoformat().replace("+00:00", "Z"),
chunk_end.isoformat().replace("+00:00", "Z")
))
current = chunk_end
return chunks
def fetch_with_fallback(instrument: str, start: str, end: str, api_key: str) -> dict:
"""
Récupère les données avec fallback si la période est trop longue
"""
# Vérifier d'abord la disponibilité
availability = get_available_history