Référence de l'API WebSocket

Streaming de données en temps réel pour les positions des baleines, les taux de financement, les liquidations et les scores de confirmation IA. Latence inférieure à la seconde avec reconnexion automatique, compression efficace des données et abonnements multi-flux.

Aperçu

L'API WebSocket offre une communication bidirectionnelle à faible latence pour les données en temps réel sur les dérivés cryptographiques. Au lieu d'interroger les points de terminaison REST toutes les 5 à 30 secondes, les connexions WebSocket livrent les mises à jour instantanément lorsque les conditions du marché changent. Idéal pour les bots de trading, les systèmes d'alerte et les tableaux de bord en temps réel.

Avantages clés de WebSocket par rapport à REST :

Latence inférieure à la seconde pour les événements qui font bouger le marché (liquidations, mouvements des baleines)

Utilisation efficace de la bande passante avec des mises à jour encodées en delta

Abonnements multiples simultanés sur une seule connexion

Filtrage et agrégation côté serveur

Gestion automatique des pulsations et des reconnexions

Nombre réduit de requêtes API contre votre quota

Les connexions WebSocket sont disponibles pour tous les niveaux d'API. Les utilisateurs du niveau gratuit peuvent s'abonner aux flux de taux de financement et de liquidations. Les niveaux Trader et Pro débloquent les positions des baleines, l'intérêt ouvert et les scores de confirmation.

Authentification

Les connexions WebSocket utilisent la même authentification que les points de terminaison REST. Passez votre clé API en tant que paramètre de requête ou envoyez-la dans le premier message après la connexion.

URL de connexion

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

Incluez votre clé API dans l'URL de connexion :

URL

wss://ws.smartmoneyapi.com/stream?token=sk_live_abc123xyz789

Cycle de vie de la connexion

Connexion initiale

Lorsque vous vous connectez au point de terminaison WebSocket, le serveur valide votre jeton d'authentification et envoie un accusé de réception de connexion.

Réponse du serveur (JSON)

{
  "type": "connection_ack",
  "connection_id": "conn_1a2b3c4d5e6f7g8h",
  "server_version": "1.2.4",
  "timestamp": "2026-03-21T14:35:22Z",
  "api_tier": "pro",
  "max_subscriptions": 50,
  "max_symbols_per_sub": 100
}

Pulsation (Ping/Pong)

Le serveur envoie des pulsations périodiques toutes les 30 secondes. Votre client doit répondre avec un message pong pour maintenir la connexion active. Si le serveur ne reçoit pas de réponse pong dans les 10 secondes, la connexion sera fermée.

JavaScript

const ws = new WebSocket("wss://ws.smartmoneyapi.com/stream?token=sk_live_abc123xyz789");

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);

  if (msg.type === "ping") {
    // Répondre au ping avec un pong
    ws.send(JSON.stringify({
      type: "pong",
      id: msg.id
    }));
  }
};

ws.onopen = () => {
  console.log("Connecté à WebSocket");
};

Abonnements

Après la connexion, abonnez-vous aux flux de données en utilisant des messages d'abonnement. Chaque abonnement génère des mises à jour chaque fois que les données du marché changent.

Format du message d'abonnement

JSON

{
  "type": "subscribe",
  "channel": "whale_positions",
  "symbols": ["BTCUSDT", "ETHUSDT"],
  "params": {
    "min_position_size": 10,
    "exchanges": ["bybit", "binance"]
  }
}

Format du message de désabonnement

JSON

{
  "type": "unsubscribe",
  "channel": "whale_positions",
  "symbols": ["BTCUSDT"]
}

Flux des positions des baleines

Mises à jour en temps réel des grandes positions des baleines sur tous les symboles et échanges suivis. Les mises à jour sont envoyées lorsque les baleines ouvrent, ferment ou modifient des positions. Inclut le prix d'entrée, le prix actuel, le P&L, le levier et le risque de liquidation.

JSON — Abonnement

{
  "type": "subscribe",
  "channel": "whale_positions",
  "symbols": ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
}

Message de mise à jour

JSON — Mise à jour

{
  "type": "data",
  "channel": "whale_positions",
  "symbol": "BTCUSDT",
  "data": {
    "wallet_address": "0x1234...",
    "exchange": "bybit",
    "direction": "long",
    "position_size": 25.3,
    "entry_price": 41200.0,
    "current_price": 43200.5,
    "pnl": 50701.50,
    "pnl_percent": 4.86,
    "leverage": 8,
    "liquidation_price": 33760.0,
    "timestamp": "2026-03-21T14:35:45Z"
  }
}

Flux des taux de financement

Mises à jour en temps réel des taux de financement sur Bybit, Binance et Hyperliquid. Mises à jour toutes les 1 minute ou lorsque les taux changent de manière significative. Inclut les taux individuels des échanges et les métriques agrégées.

JSON — Abonnement

{
  "type": "subscribe",
  "channel": "funding_rates",
  "symbols": ["BTCUSDT", "ETHUSDT"]
}

Message de mise à jour

JSON — Mise à jour

{
  "type": "data",
  "channel": "funding_rates",
  "symbol": "BTCUSDT",
  "data": {
    "timestamp": "2026-03-21T14:00:00Z",
    "bybit": {
      "rate": 0.000120,
      "next_rate": 0.000145
    },
    "binance": {
      "rate": 0.000098,
      "next_rate": 0.000115
    },
    "hyperliquid": {
      "rate": 0.000140,
      "next_rate": 0.000160
    },
    "aggregated": {
      "mean": 0.000119,
      "median": 0.000120,
      "spread": 0.000062
    }
  }
}

Flux des liquidations

Flux en temps réel des liquidations montrant les fermetures forcées de positions à effet de levier. Inclut la taille de la position, le prix de liquidation, la direction (long/short) et l'échange. Utile pour identifier les cascades de liquidations et les mouvements de marché à fort impact.

JSON — Abonnement

{
  "type": "subscribe",
  "channel": "liquidations",
  "params": {
    "min_size_usd": 50000
  }
}

Message de mise à jour

JSON — Mise à jour

{
  "type": "data",
  "channel": "liquidations",
  "data": {
    "exchange": "binance",
    "symbol": "BTCUSDT",
    "direction": "long",
    "position_size": 12.5,
    "liquidation_price": 41000.0,
    "size_usd": 512500.0,
    "timestamp": "2026-03-21T14:35:12Z"
  }
}

Flux de l'intérêt ouvert

Intérêt ouvert agrégé pour tous les traders à effet de levier sur chaque symbole. Suivez les augmentations de l'intérêt ouvert (plus d'argent entrant dans l'effet de levier) et les diminutions (fermetures de positions). La divergence de l'intérêt ouvert par rapport au mouvement des prix identifie l'épuisement caché haussier/baissier.

JSON — Abonnement

{
  "type": "subscribe",
  "channel": "open_interest",
  "symbols": ["BTCUSDT", "ETHUSDT"]
}

Flux des scores de confirmation

Scores de confirmation IA en temps réel combinant les positions des baleines, les signaux on-chain, les taux de financement et les données de sentiment. Les scores se mettent à jour chaque fois que les signaux sous-jacents changent, fournissant des signaux d'entrée/sortie en direct pour les algorithmes de trading.

JSON — Abonnement

{
  "type": "subscribe",
  "channel": "confirmation_scores",
  "symbols": ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
}

Logique de reconnexion automatique

Les problèmes de réseau ou la maintenance du serveur peuvent entraîner des déconnexions. Implémentez une logique de reconnexion avec backoff exponentiel pour récupérer automatiquement des échecs tout en respectant la charge du serveur.

Stratégie de reconnexion recommandée

JavaScript

class SmartMoneyWebSocket {
  constructor(token, options = {}) {
    this.token = token;
    this.maxReconnectDelay = options.maxReconnectDelay || 30000;
    this.reconnectDelay = 1000;
    this.subscriptions = new Map();
    this.connect();
  }

  connect() {
    this.ws = new WebSocket(
      `wss://ws.smartmoneyapi.com/stream?token=${this.token}`
    );

    this.ws.onopen = () => {
      console.log("Connecté");
      this.reconnectDelay = 1000; // Réinitialiser le backoff
      this.resubscribe(); // Ré-abonner après reconnexion
    };

    this.ws.onmessage = (event) => {
      const msg = JSON.parse(event.data);
      if (msg.type === "ping") {
        this.ws.send(JSON.stringify({ type: "pong", id: msg.id }));
      }
      this.onMessage(msg);
    };

    this.ws.onclose = () => this.reconnect();
    this.ws.onerror = (err) => console.error("Erreur WebSocket :", err);
  }

  reconnect() {
    console.log(`Reconnexion dans ${this.reconnectDelay}ms`);
    setTimeout(() => {
      this.connect();
      this.reconnectDelay = Math.min(
        this.reconnectDelay * 1.5,
        this.maxReconnectDelay
      );
    }, this.reconnectDelay);
  }

  subscribe(channel, symbols, params) {
    const key = `${channel}:${symbols.join(",")}`;
    this.subscriptions.set(key, { channel, symbols, params });
    this.ws.send(JSON.stringify({ type: "subscribe", channel, symbols, params }));
  }

  resubscribe() {
    for (const { channel, symbols, params } of this.subscriptions.values()) {
      this.ws.send(JSON.stringify({ type: "subscribe", channel, symbols, params }));
    }
  }

  onMessage(msg) {
    if (msg.type === "data") {
      console.log(`Mise à jour : ${msg.channel}/${msg.symbol}`, msg.data);
    }
  }
}

const client = new SmartMoneyWebSocket("sk_live_abc123xyz789");
client.subscribe("whale_positions", ["BTCUSDT", "ETHUSDT"]);
client.subscribe("funding_rates", ["BTCUSDT"]);
client.subscribe("liquidations", [], { min_size_usd: 100000 });

Exemples de code

Client WebSocket en Python

Python

import asyncio
import json
import websockets

async def stream_whale_positions():
    uri = "wss://ws.smartmoneyapi.com/stream?token=sk_live_abc123xyz789"

    async with websockets.connect(uri) as websocket:
        # Attendre l'accusé de réception de connexion
        ack = await websocket.recv()
        print(f"Connecté : {ack}")

        # S'abonner aux positions des baleines
        await websocket.send(json.dumps({
            "type": "subscribe",
            "channel": "whale_positions",
            "symbols": ["BTCUSDT", "ETHUSDT"]
        }))

        # Écouter les mises à jour
        while True:
            try:
                msg = await websocket.recv()
                data = json.loads(msg)

                if data["type"] == "ping":
                    # Répondre au ping
                    await websocket.send(json.dumps({
                        "type": "pong",
                        "id": data["id"]
                    }))
                elif data["type"] == "data":
                    print(f"Nouvelle position : {data['data']}")
            except websockets.exceptions.ConnectionClosed:
                print("Connexion fermée, reconnexion...")
                await asyncio.sleep(1)

asyncio.run(stream_whale_positions())

Conseils de performance

Filtrer lors de l'abonnement : Utilisez l'objet params pour filtrer les données côté serveur (min_position_size, min_size_usd) plutôt que de filtrer dans votre application.

Abonnements par lots : Abonnez-vous à plusieurs symboles dans un seul message plutôt qu'un abonnement par symbole.

Désabonnez-vous inutilisé : Lorsque vous n'avez plus besoin d'un flux, désabonnez-vous pour économiser la bande passante et réduire le volume de messages.

Utiliser la compression gzip : Activez la compression des messages dans votre client WebSocket pour économiser la bande passante (réduction de 20 à 40 %).

Surveiller la santé de la connexion : Suivez la latence ping/pong et les reconnexions automatiques pour diagnostiquer les problèmes de réseau.

Mettre en mémoire tampon les messages pendant la déconnexion : Lorsque la connexion tombe, mettez en file d'attente les signaux de stratégie et exécutez-les lors de la reconnexion.

Commencez à streamer maintenant

Obtenez votre clé API et commencez à créer des systèmes de trading en temps réel. La diffusion WebSocket est disponible pour tous les niveaux.

Obtenir une clé API

Créez des systèmes de trading en temps réel

Suivez les positions des baleines, les taux de financement et les scores de confirmation IA avec une latence inférieure à la seconde.

Voir les offres