Docs

import asyncio
import websockets
import json

async def stream_orders():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to order statuses
        await ws.send(json.dumps({
            "method": "subscribe",
            "subscription": {"type": "order_statuses"}
        }))

        # Wait for acknowledgement
        ack = await ws.recv()
        print(f"Subscribed: {ack}")

        # Process incoming data
        async for message in ws:
            data = json.loads(message)
            print(data)

asyncio.run(stream_orders())

import asyncio
import websockets
import json

async def stream_orders():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to order statuses
        await ws.send(json.dumps({
            "method": "subscribe",
            "subscription": {"type": "order_statuses"}
        }))

        # Wait for acknowledgement
        ack = await ws.recv()
        print(f"Subscribed: {ack}")

        # Process incoming data
        async for message in ws:
            data = json.loads(message)
            print(data)

asyncio.run(stream_orders())

import asyncio
import websockets
import json

async def stream_orders():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to order statuses
        await ws.send(json.dumps({
            "method": "subscribe",
            "subscription": {"type": "order_statuses"}
        }))

        # Wait for acknowledgement
        ack = await ws.recv()
        print(f"Subscribed: {ack}")

        # Process incoming data
        async for message in ws:
            data = json.loads(message)
            print(data)

asyncio.run(stream_orders())

JavaScript — With Reconnection

JavaScript with Auto-Reconnect

function connect() {
  const ws = new WebSocket("wss://your-stream.hyperpc.app");
  let pingInterval;

  ws.onopen = () => {
    console.log("Connected");

    // Subscribe to channels
    ws.send(JSON.stringify({
      method: "subscribe",
      subscription: { type: "raw_book_diffs" }
    }));

    // Keep-alive
    pingInterval = setInterval(() => {
      ws.send(JSON.stringify({ method: "ping" }));
    }, 30000);
  };

  ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.channel === "pong") return; // Ignore pong
    console.log(data);
  };

  ws.onclose = () => {
    clearInterval(pingInterval);
    console.log("Disconnected, reconnecting in 3s...");
    setTimeout(connect, 3000);
  };

  ws.onerror = (err) => {
    console.error("Error:", err);
    ws.close();
  };
}

connect();

function connect() {
  const ws = new WebSocket("wss://your-stream.hyperpc.app");
  let pingInterval;

  ws.onopen = () => {
    console.log("Connected");

    // Subscribe to channels
    ws.send(JSON.stringify({
      method: "subscribe",
      subscription: { type: "raw_book_diffs" }
    }));

    // Keep-alive
    pingInterval = setInterval(() => {
      ws.send(JSON.stringify({ method: "ping" }));
    }, 30000);
  };

  ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.channel === "pong") return; // Ignore pong
    console.log(data);
  };

  ws.onclose = () => {
    clearInterval(pingInterval);
    console.log("Disconnected, reconnecting in 3s...");
    setTimeout(connect, 3000);
  };

  ws.onerror = (err) => {
    console.error("Error:", err);
    ws.close();
  };
}

connect();

function connect() {
  const ws = new WebSocket("wss://your-stream.hyperpc.app");
  let pingInterval;

  ws.onopen = () => {
    console.log("Connected");

    // Subscribe to channels
    ws.send(JSON.stringify({
      method: "subscribe",
      subscription: { type: "raw_book_diffs" }
    }));

    // Keep-alive
    pingInterval = setInterval(() => {
      ws.send(JSON.stringify({ method: "ping" }));
    }, 30000);
  };

  ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.channel === "pong") return; // Ignore pong
    console.log(data);
  };

  ws.onclose = () => {
    clearInterval(pingInterval);
    console.log("Disconnected, reconnecting in 3s...");
    setTimeout(connect, 3000);
  };

  ws.onerror = (err) => {
    console.error("Error:", err);
    ws.close();
  };
}

connect();

Python — Multiple Channels with Keep-Alive

Multi-Channel with Keepalive

import asyncio
import websockets
import json

async def multi_stream():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to multiple channels
        channels = ["order_statuses", "raw_book_diffs", "twap_statuses"]
        for ch in channels:
            await ws.send(json.dumps({
                "method": "subscribe",
                "subscription": {"type": ch}
            }))
            ack = await ws.recv()
            print(f"Subscribed to {ch}: {ack}")

        # Background keepalive
        async def keepalive():
            while True:
                await ws.send(json.dumps({"method": "ping"}))
                await asyncio.sleep(30)

        asyncio.create_task(keepalive())

        # Process all messages
        async for message in ws:
            data = json.loads(message)
            if data.get("channel") == "pong":
                continue
            print(data)

asyncio.run(multi_stream())

import asyncio
import websockets
import json

async def multi_stream():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to multiple channels
        channels = ["order_statuses", "raw_book_diffs", "twap_statuses"]
        for ch in channels:
            await ws.send(json.dumps({
                "method": "subscribe",
                "subscription": {"type": ch}
            }))
            ack = await ws.recv()
            print(f"Subscribed to {ch}: {ack}")

        # Background keepalive
        async def keepalive():
            while True:
                await ws.send(json.dumps({"method": "ping"}))
                await asyncio.sleep(30)

        asyncio.create_task(keepalive())

        # Process all messages
        async for message in ws:
            data = json.loads(message)
            if data.get("channel") == "pong":
                continue
            print(data)

asyncio.run(multi_stream())

import asyncio
import websockets
import json

async def multi_stream():
    uri = "wss://your-stream.hyperpc.app"
    async with websockets.connect(uri) as ws:
        # Subscribe to multiple channels
        channels = ["order_statuses", "raw_book_diffs", "twap_statuses"]
        for ch in channels:
            await ws.send(json.dumps({
                "method": "subscribe",
                "subscription": {"type": ch}
            }))
            ack = await ws.recv()
            print(f"Subscribed to {ch}: {ack}")

        # Background keepalive
        async def keepalive():
            while True:
                await ws.send(json.dumps({"method": "ping"}))
                await asyncio.sleep(30)

        asyncio.create_task(keepalive())

        # Process all messages
        async for message in ws:
            data = json.loads(message)
            if data.get("channel") == "pong":
                continue
            print(data)

asyncio.run(multi_stream())

Warning

Always implement reconnection logic in production. Network interruptions, server maintenance, or idle timeouts can close your connection at any time.

Last upade: May 12, 2026

Heartbeat & Keep-Alive

Overview

On this page

Real-Time Streams

Code Examples

Launch App

Real-Time Streams

Code Examples

Launch App