WebSocket API

1. Getting Started

wss://realtime.insightsentry.com/live

wss://realtime.insightsentry.com/newsfeed

CLI Quick Start

The insight CLI streams messages as NDJSON:

npm install -g @insightsentry/mcp

# Quotes and series for multiple symbols
insight stream_live --symbols "NASDAQ:AAPL,NASDAQ:MSFT" --type both \
  --bar_type minute --bar_interval 1 --max_messages 100 --duration_seconds 30 --quiet

# Append news messages to a file for 30 minutes
insight stream_newsfeed --content "earnings" --output_file ./news.ndjson --append \
  --duration_seconds 1800

Run without flags for guided setup. See Insight Tool for authentication, output, and duration options.

AI Agent Collection

For AI clients, use collect_live or collect_newsfeed. See Insight Tool for arguments and response fields.

Authentication

Authenticate with your dashboard API key. The request format differs by endpoint:

{
  "api_key": "<your_websocket_api_key>"
}

Connection Lifecycle & Limits

Open the socket, then send the endpoint's authentication/subscription JSON within five minutes. While an accepted request is being connected, either endpoint can send:

{
  "event": "connection_status",
  "status": "connecting",
  "message": "Connecting..."
}

This is progress information, not proof that the subscription is ready. Wait for the following message before treating the request as active:

{
  "event": "subscription_status",
  "status": "active",
  "operation": "initial",
  "subscription_count": 2
}

operation is initial for the first accepted request and update after a replacement. For market data, subscription_count counts active quote/series stream legs, so one both request counts as two. Newsfeed reports one active subscription.

• Initial request timeout: You must send a valid subscription message within 5 minutes of connecting. Idle connections that never authenticate are closed automatically.
• Connection limit: You can keep up to your plan's allowed concurrent connections open per account. Market data may replace an older local connection and send it connection_evicted. Otherwise, including when the older connection is on another server, the new socket is rejected with max_connection_reached. Newsfeed rejects the new socket when the limit is reached. See Section 6 for details.

2. Subscribing to Data Feeds

Market Data Subscription

After connecting to the market data endpoint, send a JSON message to authenticate and subscribe to data feeds.

Required Message Format:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "quote"}
  ]
}

{
  "api_key": "<your_websocket_api_key>",
  "slow_consumer_policy": "adaptive",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "quote"}
  ]
}

Subscription Parameters

Each subscription object in the array can include these parameters:

Example Subscription Message:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "minute", "bar_interval": 1, "dp": 500},
    {"code": "NASDAQ:TSLA", "type": "quote"}
  ]
}

Modifying Subscriptions

Send the complete desired subscription list to replace the current set.

Example - Updating Subscriptions:

To change from the previous example to track both minute bars and quotes for AAPL:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "both", "bar_type": "minute", "bar_interval": 1, "dp": 500}
  ]
}

NASDAQ:TSLA is removed because it is absent from the replacement. If the new streams cannot be activated, the server can keep the previous set active and return subscription_unavailable with subscriptions_unchanged: true. Follow that error's action; do not assume the update took effect.

Subscription Rules & Limits

Newsfeed Subscription & Filters

For all news, send only api_key. You may also filter by exact source, related symbol, and terms contained in the article content:

{
  "api_key": "<your_websocket_api_key>",
  "source": "Reuters",
  "related_symbols": "NASDAQ:AAPL, MSFT",
  "content": "earnings acquisition"
}

• source is a case-insensitive exact match.
• related_symbols accepts comma- or space-separated symbols. A symbol without an exchange prefix, such as AAPL, matches that ticker across exchanges.
• content accepts comma- or space-separated, case-insensitive terms; an item matches when its content contains at least one term.
• Different filter fields are combined, so an item must satisfy every populated field.

Sending another valid newsfeed request replaces the filters, emits an operation: "update" status, and replays up to 10 recent items matching the new filters before continuing with live items.

3. Response Data Formats

Messages are JSON objects. Their fields depend on the subscription type.

For complete field descriptions, see the corresponding REST API documentation: /symbols/:symbol/series, /symbols/quotes, or /newsfeed.

Status Messages

The top-level event field identifies market-data updates and connection progress without conflicting with the nested trade-direction type field. Consider the request ready only after subscription_status reports status: "active".

{
  "event": "subscription_status",
  "status": "active",
  "operation": "initial",
  "subscription_count": 1
}

A market-data request may emit validation errors for individual legs and then an active status for the valid remainder. Use subscription_count to confirm how many stream legs were accepted. If no valid legs remain, the server sends no_valid_symbols and does not send an active status for that request.

Dispatch successful market data using event: "quote_update" or event: "series_update". These discriminators are additive: all existing quote and series fields remain present, so clients that currently recognize messages by shape continue to work while migrating.

If adaptive delivery was requested and the client falls behind, the server sends a delivery status before the compacted market snapshot:

{
  "event": "delivery_status",
  "mode": "conflated",
  "dropped_updates": 42,
  "max_rate_hz": 1
}

dropped_updates counts skipped updates in this delivery. max_rate_hz is the current delivery rate (1, 2, or 4 Hz). Quote updates combine changed fields; series updates contain the newest complete bar. Initial history is sent separately. A client that cannot keep reading may still be disconnected.

{
  "event": "delivery_status",
  "mode": "realtime",
  "dropped_updates": 0
}

mode: "realtime" means full-frequency delivery has resumed.

Series Data (type: "series")

Series data provides OHLCV (Open, High, Low, Close, Volume) bar information and tick data.

{
  "event": "series_update",
  "code": "NASDAQ:AAPL",
  "bar_end": 1733432399.0,
  "last_update": 1733432399820,
  "bar_type": "1m",
  "series": [
    {
      "time": 1733432340.0,
      "open": 242.89,
      "high": 243.09,
      "low": 242.82,
      "close": 243.08,
      "volume": 533779.0
    }
  ]
}

Quote Data (type: "quote")

Quote data provides real-time market information including current prices, trading volume, and bid/ask spreads.

Each WebSocket message is one direct quote object. Quote updates are sparse: fields that are not present in an update may be omitted, so merge updates by code when maintaining a current quote snapshot.

{
  "event": "quote_update",
  "code": "NASDAQ:AAPL",
  "status": "PRE",
  "lp_time": 1757061117.0,
  "volume": 47549429.0,
  "last_price": 239.42,
  "change_percent": -0.15,
  "change": -0.36,
  "ask": 239.47,
  "bid": 239.42,
  "ask_size": 2.0,
  "bid_size": 1.0,
  "prev_close_price": 238.47,
  "open_price": 238.45,
  "low_price": 236.74,
  "high_price": 239.8999,
  "market_cap": 3558428648118.0,
  "currency_code": "USD",
  "delay_seconds": 0
}

Newsfeed Data

News items are sent as direct JSON objects. published_at is Unix epoch time in seconds; the other fields are omitted when unavailable.

{
  "link": "https://example.com/news/article",
  "source": "Reuters",
  "title": "Example company reports quarterly results",
  "content": "The company reported its latest quarterly results...",
  "published_at": 1757061265,
  "related_symbols": ["NASDAQ:AAPL"]
}

4. Additional Parameters

See Common Parameters for adjustments and sessions. Subscription examples follow.

Extended Market Hours (extended)

The extended parameter applies to many US and Global stock markets.

• extended: true (default) - Includes pre-market and after-hours trading data where available. For US equities, this covers 4:00 AM - 9:30 AM ET (pre-market) and 4:00 PM - 8:00 PM ET (after-hours).
• extended: false - Only includes regular trading hours data.
• Note: Not all markets support extended hours trading. Setting extended: true for markets without extended hours will return only regular session data.
• Futures subscriptions always include the available extended session.

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "minute", "bar_interval": 1, "extended": false}
  ]
}

24-Hour Session (24h)

Set 24h: true on series subscriptions to request the 24-hour session. For aboth subscription, it applies only to the series leg; the quote leg uses extended hours. Only NYSE, NASDAQ, AMEX, and CBOE are supported. Other exchanges ignore the parameter. Quote-only subscriptions accept the legacy field but treat it as extended: true.

• 24h defaults to false.
• When 24h: true is effective, it takes precedence over extended.

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "day", "bar_interval": 1, "24h": true}
  ]
}

Split Adjustment (split)

For non-futures instruments, controls whether price history is adjusted for stock splits. This flag is ignored for futures symbols.

• split: true (default) - Historical prices are adjusted for splits.
• split: false - Returns unadjusted prices. When set to false, dadj is forced to false as well — dividend adjustment requires split adjustment.

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "day", "bar_interval": 1, "split": false}
  ]
}

Dividend Adjustment (dadj)

For non-futures instruments, you can request dividend-adjusted price series. This flag is ignored for futures symbols.

• dadj: true - Applies dividend adjustments to all price values. Requires split: true (the default).
• dadj: false (default) - Shows prices without dividend adjustment.

Note: If you send split: false together with dadj: true, the server forces dadj back to false.

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "day", "bar_interval": 1, "dadj": true}
  ]
}

Back-Adjustment (badj)

For continuous futures contracts (e.g., ES1!, NQ1!), you can request back-adjusted price series to remove price gaps between contract rollovers. This flag is ignored for non-futures symbols.

• badj: true (default) - Applies back-adjustment to smooth price gaps at contract rollovers.
• badj: false - Shows unadjusted prices with natural contract rollover gaps.

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "CME_MINI:ES1!", "type": "series", "bar_type": "day", "bar_interval": 1, "badj": false}
  ]
}

Settlement Price (settlement)

For futures contracts, controls whether historical data uses settlement prices for the close value. This flag is ignored for non-futures symbols.

• settlement: true - Uses settlement prices as the close price where applicable.
• settlement: false (default) - Uses the regular close price (last traded price).

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "CME_MINI:ES1!", "type": "series", "bar_type": "day", "bar_interval": 1, "settlement": true}
  ]
}

Initial Data Points (dp)

Control how many historical data points you receive when first connecting or reconnecting to a symbol. The dp parameter accepts a number from 1 to 30,000 and defaults to 1. Values above 1 round up to the next 500.

When you connect (or reconnect), the first series data message contains the most recent dp bars in the series property, followed by real-time updates with single bars.

• Plans with at least 10 symbol units: up to 30,000 data points.
• Other Plans: up to 1,000 data points.
• If you specify a value higher than your plan allows, it will be automatically clamped to your plan's maximum.

Example:

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "minute", "bar_interval": 1, "dp": 500}
  ]
}

5. Maintaining Connection & Best Practices

Re-subscribe and Wait for Activation

Control Ping/Pong

Both endpoints send a WebSocket control Ping every 10 seconds. Your client must return a control Pong before the next deadline or the server closes the socket with heartbeat_timeout. Mature WebSocket libraries reply automatically; keep that behavior enabled and avoid blocking the library's I/O loop.

Market-Data Server Time

After a /live subscription is active, the server sends a JSON timestamp about every 15 seconds. /newsfeed does not send this message.

Message format:

{"server_time": 1741397070281}

The value is Unix epoch time in milliseconds. Use it to estimate delivery lag, allowing for clock skew. Do not use the absence of market updates as a liveness signal because markets can be inactive.

Read Continuously

Keep reading while processing data separately. Slow clients may be disconnected with slow_consumer. Adaptive delivery can skip intermediate updates, but does not replace continuous reading.

Reconnection Best Practices

Reconnect after transient failures using bounded exponential backoff.

6. Error Handling

When possible, the server sends a JSON error before rejecting a request or closing the connection. Your client must still handle a close without an error message because the socket may already be unavailable.

WebSocket errors use one common envelope. Keep the established error value for program logic, follow action for recovery, and include the opaque reference_id when contacting support.

{
  "error": "invalid_message",
  "message": "The message must be a valid JSON subscription request.",
  "reference_id": "550e8400-e29b-41d4-a716-446655440000",
  "retryable": false,
  "action": "fix_request"
}

Error Fields

Common Examples

An invalid or outdated dashboard WebSocket API key:

{
  "error": "invalid_apikey",
  "message": "The API key is invalid or no longer current. Check the current WebSocket API key in your dashboard.",
  "reference_id": "550e8400-e29b-41d4-a716-446655440000",
  "retryable": false,
  "action": "update_credentials"
}

A temporary subscription failure that requires a reconnect:

{
  "error": "subscription_unavailable",
  "message": "One or more requested subscriptions are temporarily unavailable. Please reconnect. If this persists, contact support with the reference ID.",
  "reference_id": "550e8400-e29b-41d4-a716-446655440000",
  "retryable": true,
  "action": "reconnect"
}

A validation error can include the affected symbol while the socket stays open:

{
  "error": "invalid_bar_interval",
  "message": "Invalid bar_interval for second interval. Allowed values: 1, 5, 10, 15, 30, 45",
  "symbol": "NASDAQ:AAPL",
  "reference_id": "550e8400-e29b-41d4-a716-446655440000",
  "retryable": false,
  "action": "fix_request"
}

Error Codes

HTTP 429 Before Upgrade

Excessive connection attempts can be rejected before the WebSocket upgrade. In that case, handle the HTTP 429 Too Many Requests response and its Retry-After header instead of waiting for a WebSocket message.

{
  "error": "rate_limited",
  "message": "Too many connection attempts were received from this network. Wait 2 seconds before trying again and review your reconnect logic.",
  "reference_id": "550e8400-e29b-41d4-a716-446655440000",
  "retryable": true,
  "action": "wait_and_retry",
  "retry_after_seconds": 2
}

• Use error, retryable, and action for decisions; treat message as display text.
• When action requests a reconnect, use exponential backoff and stop retrying after a reasonable client-side limit.
• Store the reference_id with your own request context for support diagnostics.

7. Code Examples

The examples use Python's websockets library, which answers control Pings automatically.

Quick Start

Connect once, wait for activation, and read messages. Add your data handling in the indicated location.

# pip install "websockets>=14"
import asyncio
import json
import logging
import os

import websockets

URI = "wss://realtime.insightsentry.com/live"
ACTIVATION_TIMEOUT_SECONDS = 5 * 60
REQUEST = {
    "api_key": os.environ["INSIGHTSENTRY_WEBSOCKET_API_KEY"],
    "subscriptions": [
        {
            "code": "NASDAQ:AAPL",
            "type": "both",
            "bar_type": "minute",
            "bar_interval": 1,
            "dp": 500,
        },
    ],
}


def message_summary(message):
    if message.get("event") == "series_update":
        return f"series update for {message.get('code', 'unknown symbol')}"
    if "published_at" in message:
        return "news item"
    if message.get("event") == "quote_update":
        return f"quote update for {message.get('code', 'unknown symbol')}"
    return None


async def main():
    activated = False
    reported_first_data = False
    activation_deadline = asyncio.get_running_loop().time() + ACTIVATION_TIMEOUT_SECONDS

    async with websockets.connect(
        URI,
        open_timeout=10,
        close_timeout=5,
    ) as websocket:
        await websocket.send(json.dumps(REQUEST))

        while True:
            timeout = None
            if not activated:
                timeout = max(
                    0.0,
                    activation_deadline - asyncio.get_running_loop().time(),
                )
            try:
                raw_message = await asyncio.wait_for(websocket.recv(), timeout=timeout)
            except asyncio.TimeoutError as error:
                raise RuntimeError("Subscription did not become active in time") from error

            if raw_message == "pong":
                continue

            try:
                message = json.loads(raw_message)
            except json.JSONDecodeError:
                logging.warning("Ignored an unexpected non-JSON WebSocket message")
                continue

            if error_code := message.get("error"):
                logging.warning(
                    "WebSocket error=%s action=%s reference_id=%s",
                    error_code,
                    message.get("action"),
                    message.get("reference_id"),
                )
                if message.get("action") == "wait_and_retry":
                    continue
                return

            if (
                message.get("event") == "subscription_status"
                and message.get("status") == "active"
            ):
                activated = True
                logging.info("Subscription active")
                continue

            summary = message_summary(message)
            if summary is not None and not reported_first_data:
                logging.info("Received %s", summary)
                reported_first_data = True


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    asyncio.run(main())

Advanced Reconnect Client

This client separates reads from processing and adds an activation deadline, bounded retries, and error handling. It stops if processing falls behind. Keep handlers asynchronous or offload blocking work.

# pip install "websockets>=14"
import asyncio
import json
import logging
import os
import random
import time

import websockets
from websockets.exceptions import ConnectionClosed, InvalidStatus

URI = "wss://realtime.insightsentry.com/live"
API_KEY = os.environ["INSIGHTSENTRY_WEBSOCKET_API_KEY"]
REQUEST = {
    "api_key": API_KEY,
    "subscriptions": [
        {
            "code": "NASDAQ:AAPL",
            "type": "both",
            "bar_type": "minute",
            "bar_interval": 1,
            "dp": 500,
        },
    ],
}

MAX_ATTEMPTS = 10
BASE_DELAY_SECONDS = 0.5
MAX_DELAY_SECONDS = 30.0
STABLE_AFTER_SECONDS = 60.0
ACTIVATION_TIMEOUT_SECONDS = 5 * 60
DATA_QUEUE_CAPACITY = 1024
PARTIAL_VALIDATION_ERRORS = {
    "invalid_symbol",
    "invalid_bar_interval",
    "invalid_currency_code",
    "invalid_unit_code",
}


class StopRetrying(Exception):
    pass


class ReconnectRequested(Exception):
    def __init__(self, delay_seconds: float, stable: bool):
        self.delay_seconds = delay_seconds
        self.stable = stable


def number(value, default=0.0):
    try:
        return max(0.0, float(value))
    except (TypeError, ValueError):
        return default


def is_stable(activated_at):
    return activated_at is not None and time.monotonic() - activated_at >= STABLE_AFTER_SECONDS


async def resend_after(websocket, delay_seconds):
    await asyncio.sleep(delay_seconds)
    await websocket.send(json.dumps(REQUEST))


def enqueue_data(data_queue, message):
    if (
        message.get("event") not in ("quote_update", "series_update")
        and "published_at" not in message
    ):
        return

    try:
        data_queue.put_nowait(message)
    except asyncio.QueueFull as error:
        raise StopRetrying(
            "local data queue is full; fix the consumer before reconnecting"
        ) from error


async def consume_data(data_queue):
    processed_messages = 0
    while True:
        message = await data_queue.get()
        try:
            # Replace this counter with your storage or processing call.
            # Await async work here, or use asyncio.to_thread for blocking work.
            processed_messages += 1
            if processed_messages == 1 or processed_messages % 1000 == 0:
                logging.info("Processed %d data messages", processed_messages)
        finally:
            data_queue.task_done()


async def connect_once(data_queue):
    activated_at = None
    retry_task = None
    request_retry_attempt = 0
    request_needs_fix = False
    activation_deadline = time.monotonic() + ACTIVATION_TIMEOUT_SECONDS

    async with websockets.connect(
        URI,
        open_timeout=10,
        close_timeout=5,
    ) as websocket:
        await websocket.send(json.dumps(REQUEST))

        try:
            while True:
                timeout = None
                if activated_at is None:
                    timeout = max(0.0, activation_deadline - time.monotonic())
                try:
                    raw_message = await asyncio.wait_for(websocket.recv(), timeout=timeout)
                except asyncio.TimeoutError:
                    if request_needs_fix:
                        raise StopRetrying("activation failed because the request must be fixed")
                    raise ReconnectRequested(0.0, False)

                if raw_message == "pong":
                    continue

                try:
                    message = json.loads(raw_message)
                except json.JSONDecodeError:
                    logging.warning("Ignored an unexpected non-JSON WebSocket message")
                    continue

                if error_code := message.get("error"):
                    action = message.get("action")
                    reference_id = message.get("reference_id")
                    logging.warning(
                        "WebSocket error=%s action=%s reference_id=%s",
                        error_code,
                        action,
                        reference_id,
                    )

                    if action == "wait_and_retry":
                        # The current upgraded request resumes automatically.
                        continue

                    if action == "retry_request":
                        request_retry_attempt += 1
                        if request_retry_attempt >= MAX_ATTEMPTS:
                            raise StopRetrying(
                                f"request retry limit reached; reference_id={reference_id}"
                            )
                        if retry_task is None or retry_task.done():
                            if retry_task is not None:
                                await asyncio.gather(retry_task, return_exceptions=True)
                            cap = min(
                                BASE_DELAY_SECONDS * (2 ** (request_retry_attempt - 1)),
                                MAX_DELAY_SECONDS,
                            )
                            delay = max(
                                number(message.get("delay_seconds")),
                                random.uniform(cap / 2, cap),
                            )
                            retry_task = asyncio.create_task(resend_after(websocket, delay))
                        continue

                    if action == "reconnect":
                        delay = number(message.get("retry_after_seconds"))
                        raise ReconnectRequested(delay, is_stable(activated_at))

                    if action == "reconnect_after_fixing_consumer":
                        raise StopRetrying(
                            "consumer must be fixed before reconnecting; "
                            f"reference_id={reference_id}"
                        )

                    if action == "fix_request" and error_code in PARTIAL_VALIDATION_ERRORS:
                        # Other valid legs may still produce an active status.
                        request_needs_fix = True
                        continue

                    if not message.get("retryable", False):
                        raise StopRetrying(
                            f"{error_code}; reference_id={reference_id}; action={action}"
                        )
                    raise StopRetrying(
                        f"unsupported retry action={action}; reference_id={reference_id}"
                    )

                if (
                    message.get("event") == "subscription_status"
                    and message.get("status") == "active"
                ):
                    if activated_at is None:
                        activated_at = time.monotonic()
                    if retry_task is not None:
                        retry_task.cancel()
                        await asyncio.gather(retry_task, return_exceptions=True)
                        retry_task = None
                    request_retry_attempt = 0
                    request_needs_fix = False
                    logging.info(
                        "Subscription active (%s)",
                        message.get("operation", "unknown"),
                    )
                    continue

                enqueue_data(data_queue, message)
        except ConnectionClosed as closed:
            received_close = closed.rcvd
            logging.info(
                "WebSocket closed code=%s reason=%s",
                received_close.code if received_close is not None else None,
                received_close.reason if received_close is not None else None,
            )
        finally:
            if retry_task is not None:
                retry_task.cancel()
                await asyncio.gather(retry_task, return_exceptions=True)

    return is_stable(activated_at)


def http_status(error):
    response = getattr(error, "response", None)
    return getattr(response, "status_code", None)


def http_error_payload(error):
    response = getattr(error, "response", None)
    body = getattr(response, "body", None)
    if not body:
        return {}

    try:
        payload = json.loads(body)
    except (json.JSONDecodeError, TypeError, UnicodeDecodeError):
        return {}
    return payload if isinstance(payload, dict) else {}


def retry_after(error):
    response = getattr(error, "response", None)
    headers = getattr(response, "headers", {}) or {}
    return number(headers.get("Retry-After"))


async def run_connections(data_queue):
    attempt = 0

    while attempt < MAX_ATTEMPTS:
        stable = False
        server_delay = 0.0

        try:
            stable = await connect_once(data_queue)
        except StopRetrying:
            raise
        except ReconnectRequested as requested:
            stable = requested.stable
            server_delay = requested.delay_seconds
        except InvalidStatus as error:
            status = http_status(error)
            payload = http_error_payload(error)
            reference_id = payload.get("reference_id")
            logging.warning(
                "WebSocket upgrade rejected HTTP %s error=%s reference_id=%s",
                status,
                payload.get("error"),
                reference_id,
            )
            if status != 429:
                raise StopRetrying(
                    f"WebSocket upgrade failed with HTTP {status}; "
                    f"reference_id={reference_id}"
                )
            server_delay = max(
                retry_after(error),
                number(payload.get("retry_after_seconds")),
            )
        except Exception:
            logging.exception("WebSocket connection failed")

        if stable:
            attempt = 0
        attempt += 1
        if attempt >= MAX_ATTEMPTS:
            break

        cap = min(BASE_DELAY_SECONDS * (2 ** (attempt - 1)), MAX_DELAY_SECONDS)
        client_delay = random.uniform(cap / 2, cap)
        delay = max(server_delay, client_delay)
        logging.info("Reconnecting in %.2f seconds (attempt %d)", delay, attempt + 1)
        await asyncio.sleep(delay)

    raise RuntimeError("WebSocket reconnect limit reached")


async def run():
    data_queue = asyncio.Queue(maxsize=DATA_QUEUE_CAPACITY)
    consumer_task = asyncio.create_task(consume_data(data_queue))
    connection_task = asyncio.create_task(run_connections(data_queue))
    try:
        done, _ = await asyncio.wait(
            {consumer_task, connection_task},
            return_when=asyncio.FIRST_COMPLETED,
        )
        if connection_task in done:
            await connection_task
            raise RuntimeError("Connection loop stopped unexpectedly")
        await consumer_task
        raise RuntimeError("Data consumer stopped unexpectedly")
    finally:
        for task in (consumer_task, connection_task):
            task.cancel()
        await asyncio.gather(consumer_task, connection_task, return_exceptions=True)


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    asyncio.run(run())

Using the Same Loop for Newsfeed

Replace the URI and request in either example with the values below. News items have a published_at field instead of a market-data code field.

URI = "wss://realtime.insightsentry.com/newsfeed"
REQUEST = {
    "api_key": API_KEY,
    "related_symbols": "NASDAQ:AAPL, MSFT",
    "content": "earnings acquisition",
}

8. FAQ