5 outils d'analyse crypto pro : Données On-Chain & DeFi

Dune Analytics

Pour tout ce qui est custom, Dune est tout simplement indispensable, mais c'est un outil qui se mérite. Concrètement, vous êtes face à une pure interface SQL branchée sur une base de données on-chain titanesque et brute. Si vous devez extraire l'inflow net de capitaux sur les pools Uniswap v3 ou traquer le solde réel des wallets d'insiders juste après un gros mint — c'est le passage obligé.

Le hic, c'est que sans maîtriser la syntaxe PostgreSQL, vous allez vite vous retrouver dans le décor. Évidemment, on peut réutiliser les dashboards tout prêts de la communauté, mais c'est un piège à cons. Il y a deux mois, on est tombés sur un dashboard ultra-populaire mesurant le volume des réseaux Layer 2 qui surévaluait les métriques de près de 100%. Il s'est avéré que le créateur avait foiré son inner join, ce qui doublait les transactions lors des appels répétés au contract. Bref, gober les dashboards des autres les yeux fermés est une fausse bonne idée : il faut toujours checker la logique du code des requêtes à la main.

Token Terminal

Si vous voulez analyser des projets Web3 comme des boîtes traditionnelles, c'est sur Token Terminal que ça se passe. La plateforme agrège les ratios financiers classiques : le P/E ratio, le chiffre d'affaires ou le bénéfice net des protocoles.

Parfois, éplucher ces tableaux offre un sacré retour à la réalité. Un projet peut squatter le top 30 des plus grosses capitalisations boursières, alors qu'en ouvrant l'onglet des frais générés, on se rend compte que les revenus réels sont insignifiants. Toute la hausse reposait sur le fait que la core team imprimait ses propres jetons natifs à la chaîne pour les distribuer en récompenses de staking. Dès que l'émission ralentit, l'économie s'effondre comme un château de cartes. Après, pour analyser des memecoins ou des tokens fraîchement sortis sans le moindre business model, le service est totalement inutile : il n'y a tout simplement aucune donnée à caler dans l'équation.

Un mot sur les indicateurs macro de Glassnode

Pour anticiper les fins de cycles long terme sur le Bitcoin, beaucoup d'analystes ne jurent que par Glassnode. Des indicateurs comme le NUPL (bénéfice/perte net non réalisé) ou les réserves de coins sur les exchanges donnent une bonne température du marché — pour savoir si la panique s'installe ou si, au contraire, tout le monde est en plein délire d'extreme greed.

Cependant, il ne faut surtout pas les prendre pour des signaux de trading clés en main. Les indicateurs de Glassnode sont de vrais paquebots, ils manquent de réactivité. Le marché peut être jugé complètement surchauffé selon les données on-chain, alors que le prix va continuer à pumper pendant deux semaines sur du pur short squeeze et du FOMO de liquidation. En plus, leur grille tarifaire pique un peu : cracher des centaines de dollars par mois pour accéder aux métriques de niveau T3, c'est un truc à réserver exclusivement aux institutionnels.

DefiLlama

C'est le boss incontesté des agrégateurs du secteur DeFi. Ce qui plaît avec cette plateforme, c'est sa capacité à nettoyer les chiffres de la TVL (Total Value Locked) pour éviter le double comptage de capital, notamment quand un même collatéral est réinvesti en boucle à travers plusieurs protocoles de lending à effet de levier.

Pourtant, les ratés arrivent là aussi. Suite à des hard forks ou de grosses mises à jour réseau, la granularité des données sur certaines pools de liquidité peut accuser un retard de quelques heures, voire de plusieurs jours. On a eu le cas où un protocole a modifié la logique de son smart contract : DefiLlama a affiché une TVL à zéro pendant 48 heures sur la pool, alors que le trading tournait à plein régime en coulisses. Malgré tout, pour couvrir des secteurs comme les RWA (Real World Assets) ou le liquid staking, il n'y a pas vraiment d'alternative sérieuse à l'heure actuelle.

Coinglass

Le site ultra-spécialisé parfait pour screener le marché des dérivés et des futures. On y va principalement pour surveiller l'Open Interest (l'intérêt ouvert), les funding rates et les cartes thermiques de liquidation.

En pratique : Les énormes clusters d'ordres stop sur la heatmap fonctionnent souvent comme de véritables aimants pour le prix. Ça ne veut pas dire que le marché va y aller à coup sûr, mais ces zones à forte densité de liquidité attirent forcément l'attention des market makers et des gros poissons qui cherchent de la contrepartie pour exécuter de grosses tailles. Attention tout de même, il ne faut pas croire l'historique de Coinglass sur parole : ils réajustent régulièrement les graphiques des liquidations passées quand les exchanges mettent du temps à envoyer leurs logs de données.

Le cheat sheet des métriques

Pour éviter de s'y perdre et savoir où chercher, le plus simple est de trier par cas d'usage :

• Dune: traquer les mouvements des baleines, auditer la distribution des tokens d'un smart contract ;
• Token Terminal: auditer les revenus réels, calculer le ratio market cap / frais générés ;
• Glassnode: repérer les zones globales de capitulation et de surchauffe sur BTC/ETH ;
• DefiLlama: monitorer l'évolution de la TVL, surveiller les volumes d'émission des stablecoins ;
• Coinglass: analyser les taux de financement (Funding Rates), détecter les zones de squeeze potentielles sur les futures.

Automatiser la détection d'anomalies via l'API

Passer ses journées à refresh des dashboards ne sert à rien. Le plus efficace reste de coder un script basique pour parser les métriques de dérivés de Coinglass et lever une alerte dès qu'il y a des variations anormales sur l'Open Interest (OI) quand le marché commence à s'emballer sévère.

import logging
import os
from typing import Any, Dict, List, Optional
import requests
# Configuration du logging pour l'environnement de production
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
logger = logging.getLogger("CoinglassAnalyzer")
# Seuils limites pour la logique métier (idéal à externaliser dans un fichier de config)
OI_CHANGE_THRESHOLD_PCT = 12.0
LIQUIDATION_THRESHOLD_USD = 40_000_000.0
class CoinglassClient:
    """Client pour interagir avec l'API v2 de Coinglass et effectuer des analyses de marché basiques."""
    
    BASE_URL = "https://open-api.coinglass.com/public/v2"
    def __init__(self, api_key: Optional[str] = None):
        # Priorité à la clé passée en argument, sinon on récupère celle des variables d'environnement
        self.api_key = api_key or os.getenv("COINGLASS_API_KEY")
        if not self.api_key:
            raise ValueError("Clé API Coinglass introuvable. Passez-la au constructeur ou définissez la variable d'environnement COINGLASS_API_KEY")
        self.session = requests.Session()
        self.session.headers.update({
            "accept": "application/json",
            "coinglassSecret": self.api_key
        })
    def fetch_liquidation_data(self, symbol: str) -> Optional[List[Dict[str, Any]]]:
        """
        Récupère les données de liquidation pour un symbole donné.
        L'endpoint v2 pour les liquidations renvoie généralement une liste par exchange ou un tableau agrégé.
        """
        url = f"{self.BASE_URL}/derivatives/orderbook_liquidation"
        params = {"symbol": symbol.upper()}
        try:
            response = self.session.get(url, params=params, timeout=10)
            response.raise_for_status()
            payload = response.json()
            # Vérification du flag de succès spécifique à l'API Coinglass
            if str(payload.get("code")) != "0" and not payload.get("success"):
                logger.error(f"L'API a renvoyé une erreur pour {symbol} : {payload.get('msg', 'Erreur inconnue')}")
                return None
            # Dans la v2, les données sont généralement situées dans la clé 'data', sous forme de liste ou de dict
            return payload.get("data")
        except requests.RequestException as e:
            logger.error(f"Erreur réseau lors de la requête de données pour {symbol} : {e}")
            return None
    def analyze_market(self, symbol: str) -> Optional[Dict[str, Any]]:
        """Analyse les données de marché en se basant sur les liquidations et l'OI récupérés."""
        raw_data = self.fetch_liquidation_data(symbol)
        if not raw_data:
            return None
        # L'API Coinglass peut retourner une liste d'objets triés par exchange.
        # Un code orienté production doit être capable de gérer aussi bien un objet unique qu'un tableau.
        main_data = raw_data[0] if isinstance(raw_data, list) and raw_data else raw_data
        if not isinstance(main_data, dict):
            logger.error(f"Format de données invalide renvoyé par l'API pour {symbol}")
            return None
        try:
            # Extraction sécurisée avec conversion de types
            oi = float(main_data.get("openInterest") or 0)
            oi_change = float(main_data.get("openInterestChgVolPercentage") or 0)
            liq = float(main_data.get("totalLiquidationVolume") or 0)
        except (ValueError, TypeError) as e:
            logger.error(f"Erreur lors du parsing des valeurs numériques pour {symbol} : {e}")
            return None
        alerts = []
        if abs(oi_change) >= OI_CHANGE_THRESHOLD_PCT:
            alerts.append(f"Signifcant OI Shift: {oi_change:.2f}%")
        if liq >= LIQUIDATION_THRESHOLD_USD:
            alerts.append(f"High Liquidation Volume: ${liq:,.0f}")
        # Log informatif sur l'état du processus
        logger.info(
            f"{symbol.upper()} | OI: ${oi:,.0f} | Δ OI: {oi_change:.2f}% | "
            f"24h Liq: ${liq:,.0f} | Alerts Triggered: {len(alerts)}"
        )
        # Déclenchement des warnings si les seuils sont franchis
        for alert in alerts:
            logger.warning(f"ALERT [{symbol.upper()}]: {alert}")
        return {
            "symbol": symbol.upper(),
            "open_interest": oi,
            "oi_change_pct": oi_change,
            "liquidations_24h": liq,
            "alerts": alerts
        }
if __name__ == "__main__":
    # Exemple d'initialisation et d'exécution du script en conditions réelles
    # Pour tester, vous pouvez coller votre clé ici ou l'exporter dans votre terminal : export COINGLASS_API_KEY="votre_clé"
    try:
        analyzer = CoinglassClient()
        analysis_result = analyzer.analyze_market("BTC")
        
        if analysis_result:
            print("\n--- Résultats de l'analyse ---")
            print(analysis_result)
            
    except ValueError as err:
        logger.critical(err)