Référence complète de l'API REST

Maîtrisez l'API Smart Money avec notre référence REST complète. Découvrez tous les points de terminaison, paramètres, méthodes d'authentification et modèles d'intégration réels pour l'intelligence sur les produits dérivés crypto et le suivi des baleines.

Aperçu

L'API Smart Money offre un accès RESTful aux données en temps réel des produits dérivés cryptographiques sur trois grandes plateformes : Bybit, Binance et Hyperliquid. Notre API agrège les positions des portefeuilles de baleines, les taux de financement, les métriques d'intérêt ouvert, les données de liquidation et les signaux sur la chaîne dans une interface unifiée. Que vous construisiez des algorithmes de trading, des systèmes de gestion des risques ou des outils d'analyse de marché, l'API REST vous donne un accès programmatique direct à toute l'intelligence Smart Money.

Avec plus de 229 symboles de trading détectés automatiquement et plus de 600 portefeuilles de baleines surveillés, l'API fournit une intelligence de marché complète. Les connexions WebSocket en temps réel offrent des mises à jour en moins d'une seconde, tandis que nos points de terminaison REST gèrent les requêtes par lots, la récupération de données historiques et l'analyse de portefeuille à grande échelle.

Toutes les requêtes doivent inclure des identifiants d'authentification valides. Les utilisateurs du niveau gratuit ont 20 requêtes par jour limitées au BTC. Les niveaux Trader (400 requêtes/jour) et Pro (4 000 requêtes/jour) débloquent tous les symboles et fonctionnalités avancées.

Authentification

L'API Smart Money utilise une authentification par clé API. La méthode principale est l'en-tête de requête X-API-Key Vous pouvez générer des clés API depuis votre tableau de bord. Un JWT de session via Authorization: Bearer est accepté comme solution de repli pour les sessions navigateur/tableau de bord, mais les clients API doivent utiliser X-API-Key.

Authentification par clé API (principale)

Envoyez votre clé API dans l'en-tête X-API-Key sur chaque requête. Ne mettez jamais votre clé dans une URL.

HTTP

GET /v1/whales/events HTTP/1.1
Host: api.smartmoneyapi.com
X-API-Key: sm_your_key
Content-Type: application/json

JWT de session (solution de repli)

Les sessions navigateur/tableau de bord peuvent transmettre un JWT de session via Authorization: Bearer (valable 24 heures). Les clients programmatiques doivent privilégier X-API-Key.

Python

import requests
import json

# Obtenir un token JWT
response = requests.post(
  "https://api.smartmoneyapi.com/auth/jwt",
  json={"api_key": "sk_live_abc123xyz789"}
)
token = response.json()["token"]

# Utiliser le JWT pour les requêtes suivantes
headers = {"Authorization": f"Bearer {token}"}
whales = requests.get(
  "https://api.smartmoneyapi.com/v1/whales/events",
  headers=headers
)
print(whales.json())

URL de base et points de terminaison

Toutes les requêtes API sont envoyées à https://api.smartmoneyapi.com. L'API est organisée en catégories de ressources logiques avec des préfixes de version. La version stable actuelle est v1.

URL de base : https://api.smartmoneyapi.com/api/v1

URL WebSocket : wss://ws.smartmoneyapi.com/stream

Format de réponse

Toutes les réponses API sont renvoyées sous forme d'objets JSON avec un format d'enveloppe standard. Les réponses réussies renvoient des codes d'état HTTP 200-299 avec des données dans le corps de la réponse. Les réponses d'erreur incluent des messages d'erreur détaillés et des suggestions de résolution.

JSON

{
  "success": true,
  "data": {
    "total": 42,
    "positions": [
      {
        "wallet_address": "0x1234...",
        "symbol": "BTCUSDT",
        "position_size": 15.5,
        "entry_price": 42150.0,
        "current_price": 43200.5,
        "pnl": 16577.75,
        "pnl_percent": 3.91,
        "leverage": 5,
        "funding_rate": 0.00012,
        "last_updated": "2026-03-21T14:30:45Z"
      }
    ]
  },
  "pagination": {
    "page": 1,
    "limit": 50,
    "total_pages": 1
  },
  "timestamp": "2026-03-21T14:35:22Z"
}

Point de terminaison des positions des baleines

Récupérez les positions détaillées des portefeuilles de baleines surveillés sur toutes les plateformes. Ce point de terminaison affiche en temps réel l'effet de levier, les prix d'entrée, les prix de liquidation et le P&L non réalisé pour les positions à haute valeur.

GET /v1/whales/events PRO

Paramètre	Type	Description
symbol	string	Paire de trading (ex. BTCUSDT, ETHUSDT) optional
exchange	string	Filtrer par plateforme : bybit, binance, hyperliquid optional
min_position_size	number	Taille minimale de position dans l'actif de base optional
direction	string	Positions longues ou courtes uniquement optional
page	integer	Numéro de page de pagination, par défaut 1 optional
limit	integer	Résultats par page, max 100, par défaut 50 optional

Exemple de requête :

cURL

curl -X GET "https://api.smartmoneyapi.com/v1/whales/events?symbol=BTCUSDT&min_position_size=10&limit=25" \
  -H "X-API-Key: sm_your_key" \
  -H "Content-Type: application/json"

Point de terminaison des taux de financement

Accédez aux taux de financement en temps réel et historiques sur Bybit, Binance et Hyperliquid. Les taux de financement sont essentiels pour le trading d'arbitrage, les stratégies de swing et la couverture des produits dérivés. Notre API agrège les taux avec une granularité de 15 minutes et fournit une analyse des taux historiques.

GET /v1/funding-rates FREE

Paramètre	Type	Description
symbol	string	Paire de trading (ex. BTCUSDT) required
exchange	string	Plateforme : bybit, binance, hyperliquid optional
interval	string	1h, 4h, 1d, par défaut 1h optional
limit	integer	Périodes historiques à renvoyer, max 500 optional

Exemple de requête :

JavaScript

const fetchFundingRates = async () => {
  const response = await fetch(
    "https://api.smartmoneyapi.com/v1/funding-rates?symbol=BTCUSDT&interval=4h&limit=100",
    {
      headers: {
        "X-API-Key": "sm_your_key",
        "Content-Type": "application/json"
      }
    }
  );
  const data = await response.json();
  console.log(data);
};
fetchFundingRates();

Point de terminaison Open Interest

Surveillez l'open interest agrégé de tous les traders à effet de levier. Une divergence entre l'open interest et le mouvement des prix signale des potentiels de retournement ou de continuation de tendance. Suivez à la fois l'OI absolu et les taux de variation de l'OI.

GET /v1/open-interest TRADER

Paramètre	Type	Description
symbol	string	Paire de trading requis
exchange	string	bybit, binance, ou hyperliquid optionnel
granularity	string	1m, 5m, 15m, 1h, 4h, 1d, par défaut 15m optionnel

Point de terminaison Liquidations

Retourne deux vues complémentaires pour un symbole : les niveaux projetés par effet de levier niveaux (une estimation des clusters de liquidation) et une realized_heatmap — l'intensité RÉELLE des liquidations forcées exécutées (prix × temps) agrégée en direct depuis les flux WebSocket des exchanges publics : Binance, OKX, Bybit, Bitget et BitMEX. La heatmap est présente lorsque le flux contient des données pour le symbole.

GET /v1/liquidations TRADER

Paramètre	Type	Description
symbol	string	Symbole de l'actif, par défaut BTC optionnel

Trader retourne le risque en cascade, les distances les plus proches et les totaux/par côté réalisés. Pro retourne les niveaux projetés complets niveaux ainsi que la realized_heatmap complète (matrices, clusters par prix, comptes par exchange).

Liquidations On-Chain DeFi

Liquidations exécutées sur les protocoles DeFi capturées directement depuis nos propres nœuds complets BSC et Avalanche — indépendamment de tout bot de trading. Couvre Venus/Cream et Moolah sur BSC, et AAVE V3/V2, Benqi, BankerJoe, Granary et Vinium sur Avalanche. Nécessite une clé authentifiée (Trader+) ; Pro retourne également les positions à risque dépendantes des bots.

GET /v1/liquidations/onchain TRADER

Paramètre	Type	Description
chain	string	bsc ou avax ; omettre pour tous optionnel
limit	integer	Nombre maximal de lignes, par défaut 100, max 500 (les plus récentes en premier) optionnel

Point de terminaison Confirmation

Le point de terminaison /v1/confirm retourne un score de confluence basé sur des règles et multi-facteurs, combinant les dérivés, les données on-chain (Coin Metrics gratuits : MVRV / flux d'exchange / adresses actives) et le positionnement des baleines. Le score composite varie de -1.0 à +1.0 (pas de 0 à 100) et chaque réponse inclut une ventilation transparente des facteurs (score par composant × poids), ajustements, poids, et couverture. C'est une aide à la décision, pas un taux de réussite garanti. Un symbole non suivi retourne un résultat explicite NO_DATA / non pris en charge plutôt qu'un LOW fabriqué.

GET /v1/confirm TRADER

Paramètres : symbol (BTC/ETH/SOL) et direction (long/short). confidence est l'un des suivants : HIGH / MEDIUM / LOW / VETO / NO_DATA ; action est l'un des suivants : CONFIRM_FULL / CONFIRM_REDUCED / CONFIRM_MINIMAL / VETO_SKIP / NO_DATA_SKIP ; size_mult est le multiplicateur de taille de position suggéré.

Points de terminaison On-Chain Data

Accédez aux métriques on-chain Bitcoin et Ethereum, y compris les flux d'exchange, les mouvements des portefeuilles de baleines, le ratio MVRV, le NUPL, les conditions de dépense et la volatilité réalisée. Ces métriques identifient les cycles d'accumulation/distribution et fournissent des signaux précoces pour les grands retournements.

GET /v1/on-chain/metrics PRO

Paramètre	Type	Description
asset	string	bitcoin ou ethereum requis
metrics	array	Métriques spécifiques : exchange_flows, mvrv, nupl, whale_moves optionnel
interval	string	1d (quotidien), 1w (hebdomadaire), par défaut 1d optionnel

Référence des modèles de données

Comprendre la structure des réponses de l'API est essentiel pour l'intégration. Ci-dessous se trouvent les définitions complètes des modèles de données utilisés dans tous les points de terminaison.

Objet WhalePosition

JSON

{
  "id": "pos_1a2b3c4d5e6f7g8h",
  "wallet_address": "0x1234567890abcdef1234567890abcdef12345678",
  "exchange": "bybit",
  "symbol": "BTCUSDT",
  "position_type": "long",
  "position_size": 15.5,
  "entry_price": 42150.0,
  "current_price": 43200.5,
  "pnl": 16577.75,
  "pnl_percent": 3.91,
  "leverage": 5,
  "margin_balance": 129000.0,
  "used_margin": 126225.0,
  "available_margin": 2775.0,
  "liquidation_price": 34560.0,
  "funding_rate": 0.00012,
  "time_opened": "2026-03-15T08:30:00Z",
  "last_updated": "2026-03-21T14:30:45Z"
}

Objet FundingRateRecord

JSON

{
  "timestamp": "2026-03-21T14:00:00Z",
  "symbol": "BTCUSDT",
  "bybit": {
    "funding_rate": 0.00012,
    "next_rate": 0.00015
  },
  "binance": {
    "funding_rate": 0.00010,
    "next_rate": 0.00013
  },
  "hyperliquid": {
    "funding_rate": 0.00014,
    "next_rate": 0.00016
  },
  "aggregated": {
    "mean": 0.000120,
    "median": 0.000120,
    "spread": 0.000060
  }
}

Exemples de code

Voici des exemples de code prêts pour la production pour les modèles d'intégration courants.

Surveiller les positions des baleines en Python

Python

import requests
import time
from typing import List, Dict

class SmartMoneyClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.smartmoneyapi.com/api/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def get_whale_positions(self, symbol: str = None) -> Dict:
        """Récupère les positions des baleines avec un filtre optionnel sur le symbole"""
        params = {}
        if symbol:
            params["symbol"] = symbol

        response = requests.get(
            f"{self.base_url}/whales/events",
            headers=self.headers,
            params=params
        )
        return response.json()

    def get_funding_rates(self, symbol: str) -> Dict:
        """Obtenir les taux de financement actuels et historiques"""
        response = requests.get(
            f"{self.base_url}/funding-rates",
            headers=self.headers,
            params={"symbol": symbol, "limit": 100}
        )
        return response.json()

    def monitor_whale_activity(self, symbol: str, interval_seconds: int = 60):
        """Surveiller en continu les positions des baleines"""
        while True:
            positions = self.get_whale_positions(symbol)
            if positions["success"]:
                for pos in positions["data"]["positions"]:
                    print(f"Baleine {pos['wallet_address'][:10]}: "
                          f"{pos['position_type']} "
                          f"{pos['position_size']} {symbol} "
                          f"PnL: {pos['pnl_percent']}%")
            time.sleep(interval_seconds)

# Utilisation
client = SmartMoneyClient("sk_live_abc123xyz789")
whales = client.get_whale_positions("BTCUSDT")
print(f"Positions totales des baleines: {whales['data']['total']}")

Bonnes pratiques & conseils de performance

Utilisez la pagination : Toujours paginer les grands ensembles de résultats. Utilisez les paramètres limit et page pour récupérer les données par blocs de 50 à 100 enregistrements, pas tous en une seule fois.

Mettez en cache les réponses : Les positions des baleines ne changent pas chaque seconde. Mettez en cache les résultats pendant 30 à 60 secondes pour réduire les appels API et améliorer les performances.

Filtrez tôt : Utilisez les paramètres de requête (symbol, exchange, direction) pour filtrer les données côté serveur, pas dans votre code applicatif.

Gérez les limites de taux : Implémentez une logique de réessai avec backoff exponentiel. Lorsque vous atteignez les limites de taux (statut 429), attendez et réessayez.

Utilisez WebSocket pour le temps réel : Pour les données en streaming, privilégiez les connexions WebSocket plutôt que le polling des endpoints REST. Vous économiserez de la bande passante et obtiendrez une latence inférieure à la seconde.

Validez les horodatages : Tous les horodatages sont au format ISO 8601 UTC. Convertissez toujours vers votre fuseau horaire local pour l'affichage et stockez toujours en UTC.

Gérez les déconnexions : Implémentez une logique de reconnexion automatique avec backoff exponentiel pour les connexions WebSocket.

Surveillez votre quota : Vérifiez l'en-tête X-Requests-Remaining dans les réponses. Planifiez votre utilisation de l'API pour rester dans les limites de votre forfait.

Modèles d'intégration courants

Modèle 1 : Alerte sur l'accumulation des baleines

Configurez des alertes lorsque les positions des baleines dépassent un seuil, signalant des phases potentielles de hausse ou d'accumulation.

Modèle 2 : Détection d'arbitrage sur les taux de financement

Détectez automatiquement lorsque les écarts de taux de financement dépassent les seuils rentables entre les exchanges, permettant des algorithmes d'arbitrage cross-exchange.

Modèle 3 : Surveillance des cascades de liquidations

Suivez les grosses liquidations et positionnez l'algorithme pour tirer parti des liquidations en cascade et des mouvements de prix à fort impact.

Modèle 4 : Confirmation multi-signaux

Combinez les positions des baleines, les taux de financement, les métriques on-chain et nos scores de confirmation IA pour des signaux d'entrée à haute conviction.

Prêt à commencer ?

Obtenez votre clé API depuis la console et commencez à développer dès aujourd'hui. Tous les nouveaux comptes bénéficient d'un accès gratuit avec 20 requêtes par jour (BTC, ETH, SOL). Passez à Trader ou Pro pour un accès illimité à tous les symboles et fonctionnalités avancées.

Obtenir une clé API

Débloquez les fonctionnalités Pro

Bénéficiez d'un accès complet aux positions des baleines, aux scores de confirmation, aux données on-chain et à plus de 2000 requêtes API quotidiennes.

Voir les tarifs