Introduction
Vous cherchez à récupérer les données historiques de Binance pour votre bot de trading, votre analyse technique ou votre projet de backtesting ? Cet article vous explique concrètement comment obtenir les K-lines (chandeliers japonais) de Binance pour plusieurs cryptomonnaies et plusieurs périodes temporelles avec Python. La méthode officielle via l'API REST Binance fonctionne parfaitement, mais HolySheep AI offre une alternative intéressante si vous souhaitez ensuite analyser ces données avec des modèles IA performants — le tout pour une fraction du coût des solutions traditionnelles.
Méthodes disponibles pour récupérer les données K-lines
Il existe principalement deux approches pour获取Binance的历史K线数据 :
- API REST officielle Binance — Gratuite, directe, sans latence artificielle, mais limitée en taux de requêtes (1200/minute en poids)
- HolySheep AI comme couche d'abstraction — Permet de стандартизировать les données pour ingestion directe dans des modèles IA avec une latence <50ms et des coûts dérisoires ($0.42/Mток для DeepSeek V3.2)
- Solutions tierces — CCXT, pandas-datareader, solutions SaaS payantes
Le tableau ci-dessous compare ces trois approches selon les critères essentiels pour un projet de trading ou d'analyse crypto :
| Critère | API Binance officielle | HolySheep AI | CCXT / Solutions tierces |
|---|---|---|---|
| Prix | Gratuit (rate limits apply) | $0.42/Mток (DeepSeek V3.2) | $20-$500/mois |
| Latence moyenne | 150-300ms | <50ms | 200-500ms |
| Moyens de paiement | N/A | WeChat, Alipay, USDT, cartes | Cartes uniquement |
| Couverture des données | Toutes les paires Binance Spot et Futures | Données structurées pour IA | Variable selon provider |
| Profil recommandé | Développeurs avancés, traders techniques | Projets IA/ML sur crypto, backtesting automatisé | Entreprises, APIs金融 |
| Crédits gratuits | Non | Oui — inscription via ce lien | Généralement non |
personally, j'utilise HolySheep pour standardiser mes datasets crypto avant de les fed into mes modèles de prédiction. L'économie de 85%+ sur les coûts d'API comparé à OpenAI est significative quand on traite des millions de chandeliers.
Prérequis et installation
Avant de commencer, assurez-vous d'avoir :
- Python 3.8+ installé
- Un compte Binance avec une API key (optionnel pour les données publiques)
- La bibliothèque requests :
pip install requests pandas
Méthode 1 : API REST Binance officielle (recommandée)
Cette méthode est gratuite et ne nécessite pas de clé API pour les endpoints publics. Elle donne accès à l'intégralité des données historiques K-lines.
# Installation des dépendances
pip install requests pandas
binance_klines.py
import requests
import pandas as pd
from datetime import datetime
def get_binance_klines(
symbol: str,
interval: str = "1h",
start_time: int = None,
end_time: int = None,
limit: int = 1000
) -> pd.DataFrame:
"""
Récupère les K-lines historiques depuis l'API Binance.
Args:
symbol: Symbole de la paire (ex: 'BTCUSDT', 'ETHUSDT')
interval: Période ('1m', '5m', '15m', '1h', '4h', '1d', '1w')
start_time: Timestamp en ms (optionnel)
end_time: Timestamp en ms (optionnel)
limit: Nombre de chandeliers (max 1000 par requête)
Returns:
DataFrame pandas avec les colonnes OHLCV
"""
base_url = "https://api.binance.com/api/v3/klines"
params = {
"symbol": symbol.upper(),
"interval": interval,
"limit": limit
}
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
response = requests.get(base_url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
# Colonnes standard des K-lines Binance
columns = [
"open_time", "open", "high", "low", "close", "volume",
"close_time", "quote_volume", "n_trades",
"taker_buy_base", "taker_buy_quote", "ignore"
]
df = pd.DataFrame(data, columns=columns)
# Conversion des types
df["open_time"] = pd.to_datetime(df["open_time"], unit="ms")
df["close_time"] = pd.to_datetime(df["close_time"], unit="ms")
for col in ["open", "high", "low", "close", "volume", "quote_volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df
Exemple d'utilisation
if __name__ == "__main__":
# Récupérer 1000 chandeliers de 1h pour BTCUSDT
btc_data = get_binance_klines("BTCUSDT", interval="1h", limit=1000)
print(f"✅ BTCUSDT: {len(btc_data)} chandeliers récupérés")
print(btc_data.tail(3))
Méthode 2 : Récupérer plusieurs symboles et périodes
Pour les stratégies multi-actifs ou le backtesting complet, voici une fonction avancée qui itère sur plusieurs paires et périodes simultanément :
# multi_klines.py
import requests
import pandas as pd
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict
import time
class BinanceMultiFetcher:
"""Classe pour récupérer des K-lines sur plusieurs symboles et périodes."""
BASE_URL = "https://api.binance.com/api/v3/klines"
INTERVALS = {
"1m": "1m", "5m": "5m", "15m": "15m",
"1h": "1h", "4h": "4h", "1d": "1d", "1w": "1w"
}
def __init__(self, rate_limit_per_second: int = 10):
self.rate_limit = rate_limit_per_second
self.last_request_time = 0
def _rate_limit(self):
"""Respecte les limites de taux Binance."""
elapsed = time.time() - self.last_request_time
if elapsed < (1 / self.rate_limit):
time.sleep((1 / self.rate_limit) - elapsed)
self.last_request_time = time.time()
def fetch_klines(
self,
symbol: str,
interval: str = "1h",
start_time: int = None,
end_time: int = None,
limit: int = 1000
) -> pd.DataFrame:
"""Récupère les K-lines pour un symbole donné."""
self._rate_limit()
params = {
"symbol": symbol.upper(),
"interval": interval,
"limit": limit
}
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
try:
response = requests.get(self.BASE_URL, params=params, timeout=30)
response.raise_for_status()
data = response.json()
columns = [
"open_time", "open", "high", "low", "close", "volume",
"close_time", "quote_volume", "n_trades",
"taker_buy_base", "taker_buy_quote", "ignore"
]
df = pd.DataFrame(data, columns=columns)
df["symbol"] = symbol.upper()
df["interval"] = interval
# Conversions
df["open_time"] = pd.to_datetime(df["open_time"], unit="ms")
numeric_cols = ["open", "high", "low", "close", "volume", "quote_volume"]
df[numeric_cols] = df[numeric_cols].apply(pd.to_numeric, errors="coerce")
return df
except requests.exceptions.RequestException as e:
print(f"❌ Erreur pour {symbol}: {e}")
return pd.DataFrame()
def fetch_multiple(
self,
symbols: List[str],
intervals: List[str] = None,
lookback_days: int = 30,
limit_per_call: int = 1000
) -> Dict[str, pd.DataFrame]:
"""
Récupère les données pour plusieurs symboles et périodes.
Args:
symbols: Liste des symboles (ex: ['BTCUSDT', 'ETHUSDT'])
intervals: Liste des périodes (défaut: ['1h', '4h', '1d'])
lookback_days: Nombre de jours de données historiques
limit_per_call: Limite par requête API (max 1000)
Returns:
Dict {f"{symbol}_{interval}": DataFrame}
"""
if intervals is None:
intervals = ["1h", "4h", "1d"]
# Calcul du start_time (timestamp en ms)
start_time = int((pd.Timestamp.now() - pd.Timedelta(days=lookback_days)).timestamp() * 1000)
results = {}
# Requêtes parallèles avec ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=5) as executor:
futures = {}
for symbol in symbols:
for interval in intervals:
future = executor.submit(
self.fetch_klines,
symbol=symbol,
interval=interval,
start_time=start_time,
limit=limit_per_call
)
key = f"{symbol.upper()}_{interval}"
futures[future] = key
for future in as_completed(futures):
key = futures[future]
try:
df = future.result()
if not df.empty:
results[key] = df
print(f"✅ {key}: {len(df)} chandeliers")
except Exception as e:
print(f"❌ {key}: {e}")
return results
Exemple d'utilisation complète
if __name__ == "__main__":
fetcher = BinanceMultiFetcher(rate_limit_per_second=10)
# Définition des symboles et périodes
symbols = ["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT", "ADAUSDT"]
intervals = ["1h", "4h", "1d"]
print("📊 Récupération des données multi-symboles...")
all_data = fetcher.fetch_multiple(
symbols=symbols,
intervals=intervals,
lookback_days=90 # 90 jours de données
)
# Export vers CSV pour analyse ultérieure
for key, df in all_data.items():
filename = f"data/{key.replace('/', '_')}.csv"
df.to_csv(filename, index=False)
print(f"\n✅ Total: {len(all_data)} fichiers générés")
# Afficher les statistiques pour BTC
btc_daily = all_data.get("BTCUSDT_1d")
if btc_daily is not None:
print(f"\n📈 BTC/USDT (journalier):")
print(f" Période: {btc_daily['open_time'].min()} → {btc_daily['open_time'].max()}")
print(f" Prix min: ${btc_daily['low'].min():,.2f}")
print(f" Prix max: ${btc_daily['high'].max():,.2f}")
Pour qui / pour qui ce n'est pas fait
| ✅ Idéal pour | ❌ Pas adapté pour |
|---|---|
|
|
Tarification et ROI
La beauté de l'API Binance officielle ? Elle est 100% gratuite pour les endpoints publics. Vos seuls coûts sont :
- Votre temps de développement : ~2-4 heures pour maîtriser l'API
- Hébergement : Si vous déployez en production, ~$5-20/mois pour un VPS
- Option HolySheep : Si vous ajoutez une couche IA pour analyse des données, comptez $0.42/Mток avec DeepSeek V3.2 — soit environ $0.042 pour traiter 100K chandeliers
ROI attendu : Pour un trader générant $100/mois grâce à une stratégie backtestée, l'investissement temps est amorti dès le premier trade profitable.
Pourquoi choisir HolySheep
Bien que l'API Binance soit gratuite, HolySheep offre des avantages distincts pour les projets d'intelligence artificielle :
- Économie de 85%+ : $0.42/Mток vs $3-5/Mток sur OpenAI — idéal pour le traitement massif de données
- Multiples moyens de paiement : WeChat Pay, Alipay, USDT — pratique pour les utilisateurs chinois
- Latence ultra-faible : <50ms contre 150-300ms pour les alternatives
- Crédits gratuits à l'inscription : S'inscrire ici pour démarrer sans risque
- Taux de change avantageux : ¥1 = $1 — simplification comptable pour les utilisateurs internationaux
Erreurs courantes et solutions
Erreur 1 : "APIError 429 Rate limit exceeded"
# ❌ Problème : Trop de requêtes en peu de temps
✅ Solution : Implémenter un exponential backoff et respect des rate limits
import time
from requests.exceptions import RequestException
def fetch_with_retry(url, params, max_retries=5):
for attempt in range(max_retries):
try:
response = requests.get(url, params=params)
if response.status_code == 429:
# Attendre avec backoff exponentiel
wait_time = (2 ** attempt) + random.uniform(0, 1)
print(f"⏳ Rate limit atteint. Attente de {wait_time:.1f}s...")
time.sleep(wait_time)
continue
response.raise_for_status()
return response.json()
except RequestException as e:
if attempt == max_retries - 1:
raise
time.sleep(2 ** attempt)
return None
Limites Binance à respecter :
- 1200 poids/minute (request weight)
- 10-50ms entre chaque requête pour endpoints klines
- 1 requête par connexion simultanée max
Erreur 2 : "Invalid symbol" ou données vides
# ❌ Problème : Symbole mal formaté ou non existant
✅ Solution : Vérifier le format et lister les symboles disponibles
def get_valid_symbols():
"""Récupère la liste des symboles tradables sur Binance."""
url = "https://api.binance.com/api/v3/exchangeInfo"
response = requests.get(url)
data = response.json()
valid_symbols = []
for s in data["symbols"]:
if s["status"] == "TRADING": # Uniquement les symboles actifs
valid_symbols.append({
"symbol": s["symbol"],
"baseAsset": s["baseAsset"],
"quoteAsset": s["quoteAsset"]
})
return pd.DataFrame(valid_symbols)
Utilisation
symbols_df = get_valid_symbols()
print(symbols_df.head(10))
Formats valides Binance :
- BTCUSDT (Spot)
- BTCUSDT_PERP (Futures USDT-M)
- BTCUSD_231229 (Futures Coin-M avec expiration)
⚠️ Attention : 'BTC/USD' ou 'BTC-USD' ne fonctionnent PAS
Erreur 3 : "Invalid interval parameter"
# ❌ Problème : Période mal spécifiée
✅ Solution : Utiliser uniquement les intervalles supportés
VALID_INTERVALS = [
"1m", # 1 minute
"3m", # 3 minutes
"5m", # 5 minutes
"15m", # 15 minutes
"30m", # 30 minutes
"1h", # 1 heure
"2h", # 2 heures
"4h", # 4 heures
"6h", # 6 heures
"8h", # 8 heures
"12h", # 12 heures
"1d", # 1 jour
"3d", # 3 jours
"1w", # 1 semaine
"1M" # 1 mois
]
def validate_interval(interval: str) -> str:
"""Valide et normalise l'intervalle."""
if interval not in VALID_INTERVALS:
raise ValueError(
f"Intervalle invalide: '{interval}'. "
f"Intervalles valides: {VALID_INTERVALS}"
)
return interval
❌ NE PAS utiliser : "60m", "1hour", "1 day", "1 jour"
✅ Utiliser : "1h", "1d", "5m", etc.
Conclusion et recommandations
La récupération des données K-lines Binance avec Python est straightforward grâce à l'API REST officielle, gratuite et bien documentée. Pour un projet de trading algorithmique ou de backtesting, c'est la solution optimale : pas de coût, données complètes, rate limits raisonnables pour un usage normal.
Si votre projet inclut une dimension d'intelligence artificielle — analyse de sentiment, prédiction de prix, génération de signaux — alors HolySheep devient intéressant : économies de 85%+ sur les coûts IA, support WeChat/Alipay pour les utilisateurs chinois, et latence <50ms pour des analyses en temps réel.
personally, j'utilise l'API Binance pour la collecte brute puis HolySheep pour le processing IA. Le combo optimal pour des projets de trading quantitatif.
Pas à pas rapide
- Installez les dépendances :
pip install requests pandas - Copiez le code de la méthode 1 ou 2 selon vos besoins
- Exécutez le script — les données seront affichées et exportées en CSV
- Pour l'analyse IA, inscrivez-vous sur HolySheep AI et utilisez les crédits gratuits
Le code est prêt à l'emploi, copy-paste et ça marche. Les rate limits Binance sont généreuses pour un usage personnel (1200 req/min), donc vous ne devriez pas les atteindre avec un script simple. Bon trading !