Referencja WebSocket API

Przesyłanie danych w czasie rzeczywistym dotyczących pozycji wielorybów, stóp finansowania, likwidacji i wskaźników potwierdzenia AI. Opóźnienie poniżej sekundy z automatycznym ponownym łączeniem, efektywną kompresją danych i wieloma subskrypcjami strumieni.

Przegląd

WebSocket API zapewnia dwukierunkową komunikację o niskim opóźnieniu dla danych pochodnych kryptowalut w czasie rzeczywistym. Zamiast odpytywać punkty końcowe REST co 5-30 sekund, połączenia WebSocket dostarczają aktualizacje natychmiast po zmianie warunków rynkowych. Idealne dla botów handlowych, systemów alarmowych i paneli w czasie rzeczywistym.

Kluczowe zalety WebSocket w porównaniu z REST:

Opóźnienie poniżej sekundy dla zdarzeń wpływających na rynek (likwidacje, ruchy wielorybów)

Efektywne wykorzystanie przepustowości dzięki aktualizacjom delta-encoded

Wiele jednoczesnych subskrypcji w jednym połączeniu

Filtrowanie i agregacja po stronie serwera

Automatyczne zarządzanie heartbeat i ponownym łączeniem

Mniejsza liczba żądań API w ramach limitu

Połączenia WebSocket są dostępne dla wszystkich poziomów API. Użytkownicy darmowego poziomu mogą subskrybować strumienie stóp finansowania i likwidacji. Poziomy Trader i Pro odblokowują pozycje wielorybów, otwarte zainteresowanie i wskaźniki potwierdzenia.

Uwierzytelnianie

Połączenia WebSocket używają tego samego uwierzytelniania co punkty końcowe REST. Przekaż swój klucz API jako parametr zapytania lub wyślij go w pierwszej wiadomości po połączeniu.

URL połączenia

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

Dołącz swój klucz API w URL połączenia:

URL

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

Cykl życia połączenia

Początkowe połączenie

Po połączeniu z punktem końcowym WebSocket, serwer weryfikuje token uwierzytelniający i wysyła potwierdzenie połączenia.

Odpowiedź serwera (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
}

Heartbeat (Ping/Pong)

Serwer wysyła okresowe pingi heartbeat co 30 sekund. Twój klient musi odpowiedzieć wiadomością pong, aby utrzymać połączenie. Jeśli serwer nie otrzyma odpowiedzi pong w ciągu 10 sekund, połączenie zostanie zamknięte.

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") {
    // Odpowiedz na ping pongiem
    ws.send(JSON.stringify({
      type: "pong",
      id: msg.id
    }));
  }
};

ws.onopen = () => {
  console.log("Połączono z WebSocket");
};

Subskrypcje

Po połączeniu subskrybuj strumienie danych za pomocą wiadomości subskrypcyjnych. Każda subskrypcja generuje aktualizacje przy każdej zmianie danych rynkowych.

Format wiadomości subskrypcyjnej

JSON

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

Format wiadomości anulującej subskrypcję

JSON

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

Strumień pozycji wielorybów

Aktualizacje w czasie rzeczywistym dotyczące dużych pozycji wielorybów na wszystkich śledzonych symbolach i giełdach. Aktualizacje są wysyłane, gdy wieloryby otwierają, zamykają lub modyfikują pozycje. Zawiera cenę wejścia, aktualną cenę, P&L, dźwignię i ryzyko likwidacji.

JSON — Subskrypcja

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

Wiadomość aktualizująca

JSON — Aktualizacja

{
  "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"
  }
}

Strumień stóp finansowania

Aktualizacje stóp finansowania w czasie rzeczywistym na Bybit, Binance i Hyperliquid. Aktualizacje co 1 minutę lub gdy stopy zmieniają się znacząco. Zawiera indywidualne stopy giełdowe i zagregowane metryki.

JSON — Subskrypcja

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

Wiadomość aktualizująca

JSON — Aktualizacja

{
  "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
    }
  }
}

Strumień likwidacji

Kanał likwidacji w czasie rzeczywistym pokazujący wymuszone zamknięcia pozycji z dźwignią. Zawiera rozmiar pozycji, cenę likwidacji, kierunek (long/short) i giełdę. Przydatne do identyfikacji kaskad likwidacji i ruchów rynkowych o dużym wpływie.

JSON — Subskrypcja

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

Wiadomość aktualizująca

JSON — Aktualizacja

{
  "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"
  }
}

Strumień otwartego zainteresowania

Zagregowane otwarte zainteresowanie dla wszystkich traderów z dźwignią dla każdego symbolu. Śledź wzrosty OI (więcej pieniędzy wchodzących w dźwignię) i spadki (zamykanie pozycji). Rozbieżność OI od ruchu cenowego identyfikuje ukryte wyczerpanie bycze/niedźwiedzie.

JSON — Subskrypcja

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

Strumień wskaźników potwierdzenia

Wskaźniki potwierdzenia AI w czasie rzeczywistym łączące pozycje wielorybów, sygnały on-chain, stopy finansowania i dane sentymentu. Wskaźniki aktualizują się przy każdej zmianie sygnałów podstawowych, dostarczając sygnały wejścia/wyjścia dla algorytmów handlowych.

JSON — Subskrypcja

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

Automatyczna logika ponownego łączenia

Problemy z siecią lub konserwacja serwera mogą powodować rozłączenia. Zaimplementuj logikę ponownego łączenia z wykładniczym wycofywaniem, aby automatycznie odzyskiwać połączenie po awariach, z poszanowaniem obciążenia serwera.

Zalecana strategia ponownego łączenia

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("Połączono");
      this.reconnectDelay = 1000; // Resetuj wycofywanie
      this.resubscribe(); // Ponowna subskrypcja po ponownym połączeniu
    };

    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("Błąd WebSocket:", err);
  }

  reconnect() {
    console.log(`Ponowne łączenie za ${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(`Aktualizacja: ${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 });

Przykłady kodu

Klient WebSocket w Pythonie

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:
        # Czekaj na potwierdzenie połączenia
        ack = await websocket.recv()
        print(f"Połączono: {ack}")

        # Subskrybuj pozycje wielorybów
        await websocket.send(json.dumps({
            "type": "subscribe",
            "channel": "whale_positions",
            "symbols": ["BTCUSDT", "ETHUSDT"]
        }))

        # Nasłuchuj aktualizacji
        while True:
            try:
                msg = await websocket.recv()
                data = json.loads(msg)

                if data["type"] == "ping":
                    # Odpowiedz na ping
                    await websocket.send(json.dumps({
                        "type": "pong",
                        "id": data["id"]
                    }))
                elif data["type"] == "data":
                    print(f"Nowa pozycja: {data['data']}")
            except websockets.exceptions.ConnectionClosed:
                print("Połączenie zamknięte, ponowne łączenie...")
                await asyncio.sleep(1)

asyncio.run(stream_whale_positions())

Wskazówki dotyczące wydajności

Filtruj przy subskrypcji: Użyj obiektu params do filtrowania danych po stronie serwera (min_position_size, min_size_usd) zamiast filtrować w aplikacji.

Subskrypcje zbiorcze: Subskrybuj wiele symboli w jednej wiadomości zamiast jednej subskrypcji na symbol.

Anuluj nieużywane: Gdy nie potrzebujesz już strumienia, anuluj subskrypcję, aby zaoszczędzić przepustowość i zmniejszyć liczbę wiadomości.

Użyj kompresji gzip: Włącz kompresję wiadomości w kliencie WebSocket, aby zaoszczędzić przepustowość (redukcja 20-40%).

Monitoruj stan połączenia: Śledź opóźnienia ping/pong i automatyczne ponowne łączenia, aby diagnozować problemy z siecią.

Buforuj wiadomości podczas rozłączenia: Gdy połączenie zostanie przerwane, kolejkowuj sygnały strategii i wykonaj je po ponownym połączeniu.

Rozpocznij przesyłanie strumieniowe teraz

Odbierz klucz API i zacznij budować systemy handlu w czasie rzeczywistym. Transmisja WebSocket jest dostępna we wszystkich planach.

Odbierz klucz API

Buduj systemy handlu w czasie rzeczywistym

Śledź pozycje wielorybów, stopy finansowania i wyniki potwierdzenia AI z opóźnieniem poniżej sekundy.

Zobacz plany