Websockets.

// Module 07, Connecting to the Limitless WebSocket.
// $ npm install @limitless-exchange/sdk

import { WebSocketClient } from '@limitless-exchange/sdk';

// The SDK wraps socket.io under the hood and targets the
// /markets namespace. Public feeds (prices, orderbook) need
// no auth; authenticated feeds (positions) require an API key.
const ws = new WebSocketClient({
  url:           'wss://ws.limitless.exchange',
  apiKey:        process.env.LIMITLESS_API_KEY, // optional for public data
  autoReconnect: true,
});

ws.on('connect',      ()    => console.log('ws open'));
ws.on('disconnect',   (why) => console.log('ws closed:', why));
ws.on('exception',    (err) => console.error('stream error:', err));

// Fire the connect, subscriptions happen in Section 03.
ws.connect();

# Module 07, Connecting to the Limitless WebSocket.
# $ pip install limitless-sdk

import asyncio
import os

from limitless_sdk.websocket import WebSocketClient, WebSocketConfig

# WebSocketConfig targets wss://ws.limitless.exchange on the
# /markets namespace under the hood. auto_reconnect=True wires
# up exponential backoff for you (see Section 04).
config = WebSocketConfig(
    url="wss://ws.limitless.exchange",
    auto_reconnect=True,
    reconnect_delay=5,
)
ws_client = WebSocketClient(config)


@ws_client.on("connect")
async def on_connect() -> None:
    print("ws open")


@ws_client.on("disconnect")
async def on_disconnect() -> None:
    print("ws closed")


@ws_client.on("exception")
async def on_exception(err) -> None:
    print("stream error:", err)


async def main() -> None:
    # API key is optional for public feeds.
    await ws_client.connect(api_key=os.environ.get("LIMITLESS_API_KEY"))
    await asyncio.Event().wait()  # keep the task alive


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

// Module 07, Connecting to the Limitless WebSocket.
// $ go get github.com/limitless-labs-group/limitless-exchange-go-sdk@v1.0.5

package main

import (
    "context"
    "log"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

func main() {
    // WithWebSocketAPIKey is optional, public feeds work without it.
    ws := limitless.NewWebSocketClient(
        limitless.WithWebSocketAPIKey(os.Getenv("LIMITLESS_API_KEY")),
    )

    ctx := context.Background()
    if err := ws.Connect(ctx); err != nil {
        log.Fatalf("ws connect: %v", err)
    }
    defer ws.Disconnect()

    log.Println("ws open, connected to wss://ws.limitless.exchange")

    // Channel callbacks + Subscribe() calls happen in Section 03.
    select {} // block forever
}

// Module 07, Reconnects are automatic. YOU resubscribe.
//
// socket.io handles heartbeats internally, no manual ping/pong.
// autoReconnect: true gives you exponential backoff for free.
// What the SDK does NOT do is re-issue your subscriptions, so
// the server forgets them on every reconnect.

import { WebSocketClient } from '@limitless-exchange/sdk';

const ws = new WebSocketClient({
  url:           'wss://ws.limitless.exchange',
  apiKey:        process.env.LIMITLESS_API_KEY,
  autoReconnect: true,
});

const SLUGS = ['btc-100k-weekly', 'us-cpi-oct-above-3'];

function restoreSubscriptions() {
  // Single call, subscribe_market_prices replaces the previous sub.
  ws.subscribe('subscribe_market_prices', { marketSlugs: SLUGS });
  ws.subscribe('subscribe_positions');
}

ws.on('connect',   () => { console.log('connected');   restoreSubscriptions(); });
ws.on('reconnect', () => { console.log('reconnected'); restoreSubscriptions(); });

ws.on('orderbookUpdate', (d) => { /* apply delta */ });
ws.on('exception',       (e) => console.error('ws:', e));

ws.connect();

# Module 07, Reconnects are automatic. YOU resubscribe.
#
# The SDK wraps socket.io, which handles heartbeats itself.
# auto_reconnect=True wires up exponential backoff. But the
# server does NOT persist subscriptions across reconnects,
# you re-issue them inside the "connect" handler, which fires
# on every (re)connection.

import asyncio
import os

from limitless_sdk.websocket import WebSocketClient, WebSocketConfig

config = WebSocketConfig(
    url="wss://ws.limitless.exchange",
    auto_reconnect=True,
    reconnect_delay=5,
)
ws_client = WebSocketClient(config)

SLUGS = ["btc-100k-weekly", "us-cpi-oct-above-3"]


@ws_client.on("connect")
async def on_connect():
    print("connected, (re)subscribing")
    # Both events go in a single subscribe_market_prices call
    # because subsequent subscribe_market_prices messages REPLACE
    # the previous subscription.
    await ws_client.subscribe(
        "subscribe_market_prices",
        {"marketSlugs": SLUGS},
    )
    await ws_client.subscribe("subscribe_positions")


@ws_client.on("orderbookUpdate")
async def on_orderbook(data):
    pass  # apply delta …


@ws_client.on("exception")
async def on_exception(err):
    print("ws:", err)


async def main():
    await ws_client.connect(api_key=os.environ["LIMITLESS_API_KEY"])
    await asyncio.Event().wait()


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

// Module 07, Reconnects are automatic. YOU resubscribe.
//
// NewWebSocketClient uses socket.io under the hood, so
// heartbeats are managed for you and backoff is built in.
// Auto-reconnect is built in: the client records your subscriptions and
// replays them on every reconnect, so you subscribe once.

package main

import (
    "context"
    "log"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

var slugs = []string{"btc-100k-weekly", "us-cpi-oct-above-3"}

func subscribeAll(ctx context.Context, ws *limitless.WebSocketClient) {
    // CLOB orderbook + AMM price deltas both arrive on this subscription.
    if err := ws.Subscribe(ctx, limitless.ChannelSubscribeMarketPrices, limitless.SubscriptionOptions{
        MarketSlugs: slugs,
    }); err != nil {
        log.Println("subscribe:", err)
    }
}

func main() {
    ctx := context.Background()

    ws := limitless.NewWebSocketClient(
        limitless.WithWebSocketAPIKey(os.Getenv("LIMITLESS_API_KEY")),
        limitless.WithAutoReconnect(true),
    )
    defer ws.Disconnect()

    ws.OnOrderbookUpdate(func(u limitless.OrderbookUpdate) {
        // apply delta …
    })

    if err := ws.Connect(ctx); err != nil {
        log.Fatal(err)
    }

    // Subscribe once. The SDK records your subscriptions and replays them
    // automatically on every reconnect, so you never re-subscribe by hand.
    subscribeAll(ctx, ws)

    select {} // block forever
}