Vous cherchez à récupérer l'historique complet des transactions Binance avec une précision tick par tick ? Vous êtes au bon endroit. Dans ce tutoriel, je vais vous guider pas à pas, en partant de zéro, sans aucun jargon technique. Vous apprendrez à utiliser l'API Tardis.dev pourExtraire toutes les données de marché dont vous avez besoin pour vos stratégies de trading, votre recherche ou vos projets de machine learning.

Pourquoi Télécharger des Données Tick par Tick Binance ?

Les données tick par tick représentent chaque transaction individuelle survenue sur le marché. Contrairement aux chandeliers (candlesticks) qui agrègent les données sur des intervalles fixes, le tick par tick capture l'intégralité de l'activité微观 du marché.

Cas d'utilisation concrets :

Comprendre les Bases : Qu'est-ce qu'une API ?

Avant de commencer, laissez-moi vous expliquer ce qu'est une API de manière simple. Imaginez un restaurant : vous êtes le client (vous), le厨房 (la cuisine) représente le serveur Binance, et l'API est le menu qui vous indique exactement quoi demander et sous quelle forme vous recevrez votre plat.

Une API (Interface de Programmation Applicative) est simplement un ensemble de règles qui permettent à deux programmes informatiques de communiquer. Vous envoyez une demande structurée, et vous recevez une réponse structurée en retour.

[Capture d'écran suggérée : Schéma simplifié client → API → Serveur, style infographic avec flèches]

Présentation de Tardis.dev

Tardis.dev est un service spécialisé dans la récupération de données de marché cryptographiques historiques. Il propose des données tick par tick pour plus de 50 exchanges, dont Binance. C'est l'outil de référence pour les chercheurs et développeurs qui ont besoin de données granulaires.

Inscription et Configuration Initiale

Étape 1 : Créer un Compte Tardis.dev

  1. Rendez-vous sur tardis.dev
  2. Cliquez sur "Sign Up" en haut à droite
  3. Utilisez votre email ou connectez-vous avec GitHub/Google
  4. Vérifiez votre email si nécessaire

[Capture d'écran suggérée : Page d'accueil Tardis.dev avec bouton Sign Up surligné en rouge]

Étape 2 : Obtenir Votre Clé API

  1. Après connexion, allez dans Settings → API Keys
  2. Cliquez sur Generate New Token
  3. Nommez votre token (ex: "MonProjetTrading")
  4. IMPORTANT : Copiez immédiatement la clé, elle ne sera affichée qu'une seule fois

[Capture d'écran suggérée : Section API Keys avec clé partiellement masquée, bouton Generate en évidence]

Étape 3 : Choisir Votre Plan

Tardis.dev propose plusieurs plans selon vos besoins :

PlanPrixLimite MensuelleRéduction
Free0€100 000 messages-
Hobby49€/mois5 millions-
Startup199€/mois25 millions-
Business599€/mois100 millions-
EnterpriseSur devisIllimité-

Pour débuter, le plan Free suffit largement à tester et développer votre projet.

Installation des Outils Nécessaires

Python : Le Langage Idéal pour Débuter

Python est le langage de programmation le plus accessible pour l'analyse de données. Si vous ne l'avez pas encore installé :

  1. Allez sur python.org/downloads
  2. Téléchargez la dernière version (Python 3.11 ou 3.12)
  3. Durante l'installation, cochez "Add Python to PATH"

[Capture d'écran suggérée : Assistant d'installation Python avec case "Add to PATH" cochée]

Installer les Bibliothèques Requises

Ouvrez votre terminal (ou Invite de commandes sur Windows) et tapez :

pip install tardis-client requests pandas python-dateutil

Ces bibliothèques permettent :

[Capture d'écran suggérée : Terminal affichant l'installation réussie des bibliothèques]

Votre Premier Script : Télécharger des Données BTC/USDT

Comprendre la Structure de l'API

L'API Tardis.dev fonctionne ainsi : vous spécifiez l'exchange (Binance), le marché (BTCUSDT), le type de données (trades/orders), et la période temporelle.

Script Complet pour Récupérer les Trades

# -*- coding: utf-8 -*-
"""
Script de téléchargement de données tick par tick Binance
Auteur: HolySheep AI Blog
Date: 2026-05-02
"""

import asyncio
from tardis_client import TardisClient, PlaybackType
import pandas as pd
from datetime import datetime, timedelta


============================================


CONFIGURATION - REMPLACEZ CES VALEURS


============================================



Votre clé API Tardis.dev

TARDIS_API_KEY = "VOTRE_CLE_API_TARDIS"


Paramètres de téléchargement

EXCHANGE = "binance"  # Exchange source
MARKET = "BTCUSDT"    # Paire de trading
START_DATE = "2026-04-01 00:00:00"
END_DATE = "2026-04-01 01:00:00"  # 1 heure de données


============================================


FONCTION PRINCIPALE


============================================


async def download_trades():
    """Télécharge les données de trades pour la période spécifiée"""
    
    print(f"📥 Démarrage du téléchargement...")
    print(f"   Exchange: {EXCHANGE}")
    print(f"   Marché: {MARKET}")
    print(f"   Période: {START_DATE} → {END_DATE}")
    print("-" * 50)
    
    # Connexion à l'API
    client = TardisClient(api_key=TARDIS_API_KEY)
    
    # Liste pour stocker les données
    trades_data = []
    
    # Requête vers l'API avec replay local
    async for local_timestamp, trade in client.replay(
        exchange=EXCHANGE,
        market=MARKET,
        playback_type=PlaybackType.from_datetime(
            start_datetime=datetime.strptime(START_DATE, "%Y-%m-%d %H:%M:%S"),
            end_datetime=datetime.strptime(END_DATE, "%Y-%m-%d %H:%M:%S")
        ),
        channels=["trades"]
    ):
        # Extraction des données de chaque trade
        trade_info = {
            'timestamp': local_timestamp,
            'id': trade.id,
            'price': float(trade.price),
            'amount': float(trade.amount),
            'side': trade.side,
            'order_type': trade.order_type
        }
        trades_data.append(trade_info)
        
        # Afficher les 5 premiers trades
        if len(trades_data) <= 5:
            print(f"   Trade #{len(trades_data)}: {trade_info['price']} @ {trade_info['timestamp']}")
    
    print("-" * 50)
    print(f"✅ Téléchargement terminé: {len(trades_data)} trades récupérés")
    
    # Conversion en DataFrame pandas
    df = pd.DataFrame(trades_data)
    
    # Sauvegarde en CSV
    filename = f"binance_{MARKET}_trades_{START_DATE[:10]}.csv"
    df.to_csv(filename, index=False)
    print(f"💾 Fichier sauvegardé: {filename}")
    
    return df


Point d'entrée du script

if __name__ == "__main__":
    # Exécution du script
    result = asyncio.run(download_trades())
    
    # Affichage des statistiques
    if not result.empty:
        print("\n📊 STATISTIQUES DES DONNÉES:")
        print(f"   Prix min: {result['price'].min():.2f}")
        print(f"   Prix max: {result['price'].max():.2f}")
        print(f"   Volume total: {result['amount'].sum():.6f}")
        print(f"   Nombre de trades: {len(result)}")

Exécuter le Script

  1. Sauvegardez le code ci-dessus dans un fichier nommé download_binance.py
  2. Remplacez VOTRE_CLE_API_TARDIS par votre vraie clé API
  3. Dans le terminal, naviguez vers le dossier contenant le fichier
  4. Exécutez avec : python download_binance.py

[Capture d'écran suggérée : Terminal montrant l'exécution réussie du script avec les statistiques]

Récupérer des Données de Carnet d'Ordres (Order Book)

Les données de order book sont particulièrement utiles pour analyser la profondeur du marché et la liquidité. Voici le script adapté :

# -*- coding: utf-8 -*-
"""
Téléchargement de snapshots de order book Binance
"""

import asyncio
from tardis_client import TardisClient, PlaybackType
from tardis_client.messages import OrderBookMessage, TradeMessage
import pandas as pd
from datetime import datetime


Configuration

TARDIS_API_KEY = "VOTRE_CLE_API_TARDIS"
EXCHANGE = "binance"
MARKET = "BTCUSDT"
START_DATE = "2026-04-15 00:00:00"
END_DATE = "2026-04-15 00:30:00"  # 30 minutes

async def download_orderbook():
    """Télécharge les snapshots de carnet d'ordres"""
    
    print(f"📊 Téléchargement du order book...")
    
    client = TardisClient(api_key=TARDIS_API_KEY)
    
    orderbook_data = []
    trade_data = []
    
    async for local_timestamp, message in client.replay(
        exchange=EXCHANGE,
        market=MARKET,
        playback_type=PlaybackType.from_datetime(
            start_datetime=datetime.strptime(START_DATE, "%Y-%m-%d %H:%M:%S"),
            end_datetime=datetime.strptime(END_DATE, "%Y-%m-%d %H:%M:%S")
        ),
        channels=["orderbook-snapshots", "trades"]
    ):
        if isinstance(message, OrderBookMessage):
            # Sauvegarder le snapshot complet du order book
            orderbook_entry = {
                'timestamp': local_timestamp,
                'bids_count': len(message.bids),
                'asks_count': len(message.asks),
                'best_bid': message.bids[0].price if message.bids else None,
                'best_ask': message.asks[0].price if message.asks else None,
                'spread': message.asks[0].price - message.bids[0].price if message.bids and message.asks else None
            }
            orderbook_data.append(orderbook_entry)
            
        elif isinstance(message, TradeMessage):
            # Sauvegarder les trades individuels
            trade_entry = {
                'timestamp': local_timestamp,
                'price': float(message.price),
                'amount': float(message.amount),
                'side': message.side
            }
            trade_data.append(trade_entry)
    
    print(f"✅ {len(orderbook_data)} snapshots récupérés")
    print(f"✅ {len(trade_data)} trades récupérés")
    
    # Sauvegarde des données
    df_orderbook = pd.DataFrame(orderbook_data)
    df_trades = pd.DataFrame(trade_data)
    
    df_orderbook.to_csv('orderbook_snapshots.csv', index=False)
    df_trades.to_csv('orderbook_trades.csv', index=False)
    
    return df_orderbook, df_trades

if __name__ == "__main__":
    ob_data, trade_data = asyncio.run(download_orderbook())
    
    print("\n📈 Échantillon du Order Book:")
    print(ob_data.head())
    print(f"\n💰 Volume trades: {trade_data['amount'].sum():.4f} BTC")

Analyser les Données avec l'IA (HolySheep)

Une fois vos données téléchargées, vous pouvez les analyser automatiquement avec des modèles d'IA. Inscrivez-vous ici sur HolySheep AI pour bénéficier de tarifs imbattables : GPT-4.1 à 8$ par million de tokens, Claude Sonnet 4.5 à 15$, et DeepSeek V3.2 à seulement 0.42$ par million de tokens — soit une économie de plus de 85% par rapport aux tarifs américains standard.

# -*- coding: utf-8 -*-
"""
Analyse IA de données Binance avec HolySheep AI
"""

import requests
import json
import pandas as pd


============================================


CONFIGURATION HOLYSHEEP


============================================



Votre clé API HolySheep (inscrivez-vous sur https://www.holysheep.ai/register)

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_API_URL = "https://api.holysheep.ai/v1/chat/completions"


Charger les données précédemment téléchargées

df = pd.read_csv('binance_BTCUSDT_trades_2026-04-01.csv')


Préparer un résumé des données pour l'analyse

data_summary = f"""
Analyse de {len(df)} trades BTC/USDT:
- Période: {df['timestamp'].min()} à {df['timestamp'].max()}
- Prix moyen: {df['price'].mean():.2f}
- Volatilité (écart-type): {df['price'].std():.2f}
- Volume total: {df['amount'].sum():.6f} BTC
- Nombre de transactions achat: {len(df[df['side']=='buy'])}
- Nombre de transactions vente: {len(df[df['side']=='sell'])}
"""


============================================


REQUÊTE À L'API HOLYSHEEP


============================================


def analyze_with_ai(data_summary, question):
    """Envoie une question à l'IA pour analyser les données"""
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "deepseek-v3.2",  # Modèle économique et performant
        "messages": [
            {
                "role": "system",
                "content": "Tu es un analyste financier expert en crypto-actifs. Analyse les données fournies et donne des insights actionnables."
            },
            {
                "role": "user", 
                "content": f"Données de marché:\n{data_summary}\n\nQuestion: {question}"
            }
        ],
        "temperature": 0.3,
        "max_tokens": 1000
    }
    
    # Latence typique HolySheep: <50ms grâce à l'infrastructure optimisée
    response = requests.post(HOLYSHEEP_API_URL, headers=headers, json=payload)
    
    if response.status_code == 200:
        return response.json()['choices'][0]['message']['content']
    else:
        return f"Erreur: {response.status_code} - {response.text}"


============================================


ANALYSES PRÉCONFIGURÉES


============================================


if __name__ == "__main__":
    print("🤖 Analyse IA des données Binance...")
    print("-" * 50)
    
    # Question 1: Résumé du marché
    question1 = "Donne-moi un résumé exécutif de l'activité de marché et identifie les anomalies potentielles."
    result1 = analyze_with_ai(data_summary, question1)
    print(f"\n📊 ANALYSE DU MARCHÉ:\n{result1}")
    
    # Question 2: Patterns de trading
    question2 = "Identifie les patterns de prix significatifs et suggère des insights pour le trading."
    result2 = analyze_with_ai(data_summary, question2)
    print(f"\n📈 PATTERNS IDENTIFIÉS:\n{result2}")
    
    print("\n✅ Analyse terminée!")
    print(f"💡 Astuce: Avec HolySheep, l'analyse de 1000 tokens coûte ~0.00042$ avec DeepSeek V3.2")

Formats de Données Disponibles

Tardis.dev propose plusieurs types de données pour Binance :

Type de DonnéeChannel APIDescriptionGranularité
TradestradesChaque transaction individuelleTick par tick
Order Bookorderbook-snapshotsÉtat du carnet d'ordresSnapshots
Order Book Deltasorderbook-rawModifications incrémentalesUpdates
Candlesticksfutures-candlesDonnées OHLCV agrégées1m, 5m, 1h, 1d
Tickertrade-tickerDernier prix et volumeTemps réel

Exemples d'Applications Pratiques

1. Backtesting d'une Stratégie Mean Reversion

# -*- coding: utf-8 -*-
"""
Backtest simple d'une stratégie mean reversion sur données tick
"""

import pandas as pd
import numpy as np


Charger les données

df = pd.read_csv('binance_BTCUSDT_trades_2026-04-01.csv')
df['timestamp'] = pd.to_datetime(df['timestamp'])
df = df.sort_values('timestamp')


Paramètres de la stratégie

WINDOW = 50          # Fenêtre mobile (en nombre de trades)
STD_MULTIPLIER = 2.0 # Nombre d'écarts-types pour le signal


Calculer la moyenne mobile et l'écart-type

df['rolling_mean'] = df['price'].rolling(window=WINDOW).mean()
df['rolling_std'] = df['price'].rolling(window=WINDOW).std()


Signaux de trading

df['upper_band'] = df['rolling_mean'] + (STD_MULTIPLIER * df['rolling_std'])
df['lower_band'] = df['rolling_mean'] - (STD_MULTIPLIER * df['rolling_std'])


Générer les signaux

df['signal'] = np.where(df['price'] < df['lower_band'], 1, 0)   # Achat
df['signal'] = np.where(df['price'] > df['upper_band'], -1, df['signal'])  # Vente


Supprimer les NaN

df = df.dropna()


Calculer les rendements

df['returns'] = df['price'].pct_change()


Stratégie: on achète quand le signal est 1, on vend quand -1

df['strategy_returns'] = df['signal'].shift(1) * df['returns']


Métriques de performance

total_return = (1 + df['strategy_returns'].dropna()).prod() - 1
sharpe_ratio = df['strategy_returns'].mean() / df['strategy_returns'].std() * np.sqrt(1440)  # Anualisé


Nombre de transactions

num_trades = (df['signal'].diff() != 0).sum()

print("=" * 50)
print("📊 RÉSULTATS DU BACKTEST")
print("=" * 50)
print(f"   Rendement total: {total_return*100:.2f}%")
print(f"   Ratio de Sharpe: {sharpe_ratio:.2f}")
print(f"   Nombre de trades: {num_trades}")
print(f"   Win rate: {(df['strategy_returns'] > 0).mean()*100:.1f}%")
print("=" * 50)

Optimisation et Bonnes Pratiques

Gestion Efficace de la Limite de Requêtes

# -*- coding: utf-8 -*-
"""
Système de limitation de requêtes avec retry automatique
"""

import time
import requests
from functools import wraps
from ratelimit import limits, sleep_and_retry


Configuration

API_RATE_LIMIT = 10  # Requêtes par seconde (ajustez selon votre plan)
TARDIS_API_KEY = "VOTRE_CLE_API_TARDIS"

@sleep_and_retry
@limits(calls=API_RATE_LIMIT, period=1)
def fetch_with_rate_limit(url, headers, params):
    """Effectue une requête avec limitation de débit"""
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 429:
        # Rate limit atteint, attendre et réessayer
        retry_after = int(response.headers.get('Retry-After', 5))
        print(f"⏳ Rate limit atteint, attente de {retry_after}s...")
        time.sleep(retry_after)
        raise Exception("Rate limit exceeded")
    
    return response

def download_large_dataset(symbol, start_date, end_date, chunk_hours=6):
    """
    Télécharge un gros volume de données par blocs
    Évite les timeouts et les erreurs de limite
    """
    
    all_data = []
    current_start = start_date
    
    while current_start < end_date:
        current_end = min(current_start + timedelta(hours=chunk_hours), end_date)
        
        print(f"📥 Téléchargement bloc: {current_start} → {current_end}")
        
        try:
            data = fetch_with_rate_limit(
                url=f"https://api.tardis.dev/v1/exports/{symbol}",
                headers={"Authorization": f"Bearer {TARDIS_API_KEY}"},
                params={
                    "start": current_start.isoformat(),
                    "end": current_end.isoformat(),
                    "format": "csv"
                }
            )
            
            if data.status_code == 200:
                all_data.append(data.content)
            else:
                print(f"⚠️ Erreur bloc: {data.status_code}")
                
        except Exception as e:
            print(f"❌ Erreur: {e}, passage au bloc suivant...")
            
        current_start = current_end
        
        # Pause entre les blocs
        time.sleep(0.5)
    
    return all_data

Erreurs Courantes et Solutions

1. Erreur 401 : Clé API Invalide ou Manquante

Symptôme :

ERROR - 401 Client Error: Unauthorized
{"error": "Invalid API key"}

Causes possibles :

Solution :

# Vérification de votre clé API
import os


Method 1: Vérifier via variable d'environnement

api_key = os.environ.get('TARDIS_API_KEY')
if api_key:
    print(f"✅ Clé trouvée: {api_key[:8]}...{api_key[-4:]}")
else:
    print("❌ Clé non trouvée dans les variables d'environnement")


Method 2: Vérification directe

TARDIS_API_KEY = "VOTRE_CLE_API"  # Assurez-vous qu'il n'y a pas d'espace


Method 3: Test de connexion

import requests
response = requests.get(
    "https://api.tardis.dev/v1/account",
    headers={"Authorization": f"Bearer {TARDIS_API_KEY}"}
)
if response.status_code == 200:
    print("✅ Connexion API réussie!")
else:
    print(f"❌ Erreur: {response.status_code} - {response.json()}")

2. Erreur 429 : Limite de Requêtes Dépassée

Symptôme :

ERROR - 429 Too Many Requests
{"error": "Rate limit exceeded. Retry-After: 5"}

Causes possibles :

Solution :

# Solution 1: Attendre et réessayer automatiquement
import time
import requests

def fetch_with_retry(url, headers, max_retries=5, backoff_factor=2):
    """Requête avec retry exponentiel"""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)
            
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                wait_time = retry_after * (backoff_factor ** attempt)
                print(f"⏳ Attente de {wait_time}s (tentative {attempt + 1}/{max_retries})")
                time.sleep(wait_time)
                continue
                
            return response
            
        except requests.exceptions.RequestException as e:
            print(f"❌ Erreur réseau: {e}")
            time.sleep(5)
    
    raise Exception("Nombre maximum de tentatives dépassé")


Solution 2: Utiliser le streaming pour réduire les requêtes

async def download_streaming(client, symbol, start, end):
    """Streaming des données plutôt que requêtes multiples"""
    
    data_list = []
    async for timestamp, message in client.replay(
        exchange="binance",
        market=symbol,
        playback_type=PlaybackType.from_datetime(start, end),
        channels=["trades"]
    ):
        # Traitement en temps réel, pas de mise en mémoire tampon
        data_list.append(message)
        
        # Option: traitement par lots pour éviter la surcharge mémoire
        if len(data_list) >= 10000:
            yield data_list
            data_list = []
    
    if data_list:
        yield data_list

3. Erreur 400 : Paramètres de Date Invalides

Symptôme :

ERROR - 400 Bad Request
{"error": "Invalid date range: end_date must be after start_date"}

Causes possibles :

Solution :

# Solution: Validation et formatting correct des dates
from datetime import datetime, timedelta
import pytz

def validate_date_range(start_str, end_str, max_hours=24):
    """Valide et formate correctement la plage de dates"""
    
    # Formats de date supportés
    formats = [
        "%Y-%m-%d %H:%M:%S",
        "%Y-%m-%dT%H:%M:%SZ",
        "%Y-%m-%d",
        "%Y/%m/%d %H:%M:%S"
    ]
    
    start_date = None
    end_date = None
    
    # Parser la date de début
    for fmt in formats:
        try:
            start_date = datetime.strptime(start_str, fmt)
            break
        except ValueError:
            continue
    
    # Parser la date de fin
    for fmt in formats:
        try:
            end_date = datetime.strptime(end_str, fmt)
            break
        except ValueError:
            continue
    
    if not start_date or not end_date:
        raise ValueError(f"Format de date invalide. Formats supportés: {formats}")
    
    # Validation de la logique
    if end_date <= start_date:
        raise ValueError("La date de fin doit être postérieure à la date de début")
    
    # Vérifier la durée
    duration = end_date - start_date
    if duration > timedelta(hours=max_hours):
        raise ValueError(f"La plage ne doit pas dépasser {max_hours} heures")
    
    return start_date, end_date


Exemples de调用

try:
    start, end = validate_date_range("2026-04-01 00:00:00", "2026-04-01 12:00:00")
    print(f"✅ Plage validée: {start} → {end}")
except ValueError as e:
    print(f"❌ Erreur: {e}")


Conversion en UTC (recommandé pour l'API)

def to_utc(dt, timezone="UTC"):
    """Convertit une date en UTC"""
    if dt.tzinfo is None:
        # Ajouter le fuseau horaire si absent
        local_tz = pytz.timezone(timezone)
        dt = local_tz.localize(dt)
    
    # Convertir en UTC
    return dt.astimezone(pytz.UTC)

4. Erreur 500 : Erreur Interne du Serveur

Symptôme :

ERROR - 500 Internal Server Error
{"error": "Internal server error, please try again later"}

Solution :

# Retry avec backoff et notification
import logging
import smtplib
from email.message import EmailMessage

def download_with_fallback(symbol, start, end, fallback_dates=None):
    """
    Téléchargement avec système de repli
    Si la période principale échoue, essaie des périodes alternatives
    """
    
    primary_url = f"https://api.tardis.dev/v1/export/{symbol}"
    fallback_urls = fallback_dates or []
    
    all_urls = [(primary_url, start, end)] + fallback_urls
    
    for url, s, e in all_urls:
        try:
            print(f"📥 Tentative: {s} → {e}")
            response = requests.get(
                url,
                headers={"Authorization": f"Bearer {TARDIS_API_KEY}"},
                params={"start": s, "end": e}
            )
            
            if response.status_code == 200:
                return response.json()
                
        except Exception as e:
            logging.warning(f"Échec tentative {url}: {e}")
            continue
    
    # Si toutes les tentatives échouent, envoyer une notification
    send_alert(f"Échec téléchargement pour {symbol} entre {start} et {end}")
    return None

def send_alert(message):
    """Envoie une notification d'erreur"""
    # À configurer avec vos paramètres email
    print(f"🚨 ALERTE: {message}")
    # Implémentez l'envoi d'email ici si nécessaire

FAQ : Questions Fréquentes

Quelle est la profondeur historique disponible ?

Binance propose des données historiques depuis 2017 environ. Tardis.dev stocke les données tick par tick à partir de début 2020. Pour les données antérieures, vous pouvez avoir besoin de sources alternatives.

Combien de données puis-je télécharger avec le plan gratuit ?

Le plan gratuit de Tardis.dev offre 100 000 messages par mois. Un "message" correspond généralement à un trade individuel ou à un snapshot de order book. Cela représente environ 2-4 heures de données BTC/USDT tick par tick.

Les données sont-elles en temps réel ?

Non, l'API de replay de Tardis.dev fournit des données historiques avec un délai. Pour le temps réel, vous devez utiliser l'API WebSocket live feed, qui n'est pas couverte dans ce tutoriel.

Puis-je utiliser ces données pour le trading en production ?

Ces données sont destinée à la recherche et au backtesting. Pour le trading en production, utilisez les APIs officielles de Binance avec des connexions WebSocket pour les données temps réel.

Conclusion et Prochaines Étapes

Vous disposez maintenant de toutes les bases pour télécharger et analyser les données historiques Binance tick par tick. Voici un récapitulatif de ce que vous avez appris :