إنشاء بث مباشر لتداول عبر SAHMK WebSocket ‏(JavaScript + Python)

wss://api.sahmk.sa/ws/v1/stocks/?api_key=YOUR_API_KEY

{
  "type": "connected",
  "plan": "pro",
  "limits": {
    "max_symbols_per_connection": 60,
    "max_symbols_per_call": 20,
    "stream_modes": ["standard"]
  },
  "message": "Connected to SAHMK real-time stock stream",
  "timestamp": "2026-02-10T10:00:00.000Z"
}

{"action":"subscribe","symbols":["2222","1120"]}
{"action":"unsubscribe","symbols":["2222"]}
{"action":"ping"}
{"action":"subscribe","symbols":["*"]}

const API_KEY = "YOUR_API_KEY";
const URL = `wss://api.sahmk.sa/ws/v1/stocks/?api_key=${API_KEY}`;
const SYMBOLS = ["2222", "1120"];

let ws = null;
let pingTimer = null;
let reconnectAttempt = 0;
let manualClose = false;
let lastErrorSignal = null;

function nextDelayMs(attempt) {
  const base = 1000;
  const cap = 30000;
  const exp = Math.min(cap, base * 2 ** attempt);
  const jitter = Math.floor(Math.random() * 500);
  return exp + jitter;
}

function startPing() {
  clearInterval(pingTimer);
  pingTimer = setInterval(() => {
    if (ws && ws.readyState === WebSocket.OPEN) {
      ws.send(JSON.stringify({ action: "ping" }));
    }
  }, 30000);
}

function stopPing() {
  clearInterval(pingTimer);
  pingTimer = null;
}

function parseRetryAfterSeconds(details) {
  if (!details || typeof details !== "object") return null;
  const raw = details.retry_after_seconds;
  const parsed = Number(raw);
  if (!Number.isFinite(parsed) || parsed <= 0) return null;
  return parsed;
}

function connect() {
  ws = new WebSocket(URL);

  ws.onopen = () => {
    reconnectAttempt = 0;
    lastErrorSignal = null;
    ws.send(JSON.stringify({ action: "subscribe", symbols: SYMBOLS }));
    startPing();
  };

  ws.onmessage = (event) => {
    let msg;
    try {
      msg = JSON.parse(event.data);
    } catch {
      console.error("Invalid JSON payload from stream:", event.data);
      return;
    }

    if (msg.type === "connected") {
      console.log("Connected limits:", msg.limits);
      return;
    }

    if (msg.type === "subscribed") {
      console.log("Subscribed symbols:", msg.symbols);
      return;
    }

    if (msg.type === "quote") {
      const { symbol, data } = msg;
      console.log(`${symbol}: ${data.price} (${data.change_percent}%)`);
      // Example UI hook:
      // document.querySelector(__TOKEN_14__).textContent = data.price;
      return;
    }

    if (msg.type === "error") {
      // Keep latest message-level signal so close handling can choose the right action.
      lastErrorSignal = {
        code: msg.code || null,
        details: msg.details || null,
      };
      console.error("Server error:", msg);
      return;
    }

    if (msg.type === "pong") {
      console.log("pong");
    }
  };

  ws.onerror = (event) => {
    console.error("WebSocket error:", event);
  };

  ws.onclose = (event) => {
    stopPing();
    console.warn(`Closed: code=${event.code} reason=${event.reason}`);

    // Auth path. Do not loop forever without intervention.
    if (event.code === 4401) {
      console.error("Authentication failure (4401). Check API key.");
      return;
    }

    // 4403 means access/entitlement class. Stop and fix account state.
    if (event.code === 4403) {
      console.error("Access denied (4403). Fix account/plan status before retrying.");
      return;
    }

    // 4429 means temporary throttle class. Retry with backoff + jitter.
    if (event.code === 4429) {
      const retryAfterSeconds = parseRetryAfterSeconds(lastErrorSignal?.details);
      const jitterMs = Math.floor(Math.random() * 500);
      const requestedDelayMs = (retryAfterSeconds || 1) * 1000 + jitterMs;
      const delayMs = Math.max(nextDelayMs(reconnectAttempt++), requestedDelayMs);
      console.warn(
        `Throttled (4429). Reconnecting in ${delayMs}ms.`
      );
      if (!manualClose) setTimeout(connect, delayMs);
      return;
    }

    // Deploy/restart can drop active sockets; reconnect and resubscribe on open.
    if (!manualClose) {
      const delay = nextDelayMs(reconnectAttempt++);
      setTimeout(connect, delay);
    }
  };
}

window.addEventListener("beforeunload", () => {
  manualClose = true;
  if (ws && ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ action: "unsubscribe", symbols: SYMBOLS }));
  }
  stopPing();
  ws?.close(1000, "Page unload");
});

connect();

import asyncio
import contextlib
import json
import random
import websockets

API_KEY = "YOUR_API_KEY"
URL = f"wss://api.sahmk.sa/ws/v1/stocks/?api_key={API_KEY}"
SYMBOLS = ["2222", "1120"]

def next_delay_seconds(attempt: int) -> float:
  base = 1.0
  cap = 30.0
  exp = min(cap, base * (2 ** attempt))
  jitter = random.uniform(0.0, 0.5)
  return exp + jitter

def parse_retry_after_seconds(details):
  if not isinstance(details, dict):
    return None
  raw = details.get("retry_after_seconds")
  try:
    value = float(raw)
  except (TypeError, ValueError):
    return None
  if value <= 0:
    return None
  return value

async def ping_loop(ws):
  while True:
    await asyncio.sleep(30)
    await ws.send(json.dumps({"action": "ping"}))

async def stream_forever():
  attempt = 0
  last_error_signal = None
  while True:
    try:
      async with websockets.connect(URL, ping_interval=None) as ws:
        attempt = 0
        last_error_signal = None
        await ws.send(json.dumps({"action": "subscribe", "symbols": SYMBOLS}))
        pinger = asyncio.create_task(ping_loop(ws))

        try:
          async for raw in ws:
            try:
              msg = json.loads(raw)
            except json.JSONDecodeError:
              print("Invalid JSON payload from stream:", raw)
              continue
            msg_type = msg.get("type")

            if msg_type == "connected":
              print("Connected limits:", msg.get("limits"))
            elif msg_type == "subscribed":
              print("Subscribed:", msg.get("symbols"))
            elif msg_type == "quote":
              symbol = msg.get("symbol")
              data = msg.get("data", {})
              print(f"{symbol}: {data.get('price')} ({data.get('change_percent')}%)")
            elif msg_type == "error":
              last_error_signal = {
                "code": msg.get("code"),
                "details": msg.get("details"),
              }
              print("Server error:", msg)
            elif msg_type == "pong":
              print("pong")
        finally:
          pinger.cancel()
          with contextlib.suppress(asyncio.CancelledError):
            await pinger
    except websockets.exceptions.ConnectionClosed as exc:
      print(f"Connection closed: code={exc.code}, reason={exc.reason}")
      if exc.code == 4401:
        print("Authentication failure (4401). Check API key.")
        return
      if exc.code == 4403:
        print("Access denied (4403). Fix account/plan status before retrying.")
        return
      if exc.code == 4429:
        signal = last_error_signal or {}
        retry_after = parse_retry_after_seconds(signal.get("details"))
        jitter = random.uniform(0.0, 0.5)
        requested_delay = (retry_after if retry_after else 1.0) + jitter
        delay = max(next_delay_seconds(attempt), requested_delay)
        print(f"Throttled (4429). Reconnecting in {delay:.2f}s")
        await asyncio.sleep(delay)
        attempt += 1
        continue
    except Exception as exc:
      print(f"Unexpected error: {exc}")

    delay = next_delay_seconds(attempt)
    print(f"Reconnecting in {delay:.2f}s")
    await asyncio.sleep(delay)
    attempt += 1

if __name__ == "__main__":
  asyncio.run(stream_forever())

pip install websockets

wss://api.sahmk.sa/ws/v1/market/trades/?api_key=YOUR_API_KEY

// Enterprise-only example:
ws.send(JSON.stringify({
  action: "subscribe",
  symbols: ["*"]
}));