WebSocket API Documentation

{"message": "Connecting...", "server": "<server_location>"}

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    // Array of subscription objects
  ]
}

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

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "type": "series", "bar_type": "minute", "bar_interval": 1, "max_dp": 100},
    {"code": "NASDAQ:AAPL", "type": "quote"}
    // NASDAQ:TSLA quote subscription is removed as it's not in the new list
  ]
}

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

{
        "last_update": 1757061265540,
        "total_items": 1,
        "data": [
          {
            "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
          }
        ]
      }

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

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

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

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

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

{
  "api_key": "<your_websocket_api_key>",
  "subscriptions": [
    {"code": "NASDAQ:AAPL", "bar_type": "minute", "bar_interval": 1, "max_dp": 5000}
  ]
}

{"server_time": 1741397070281}

import asyncio
import websockets
import json

async def websocket_client():
    uri = 'wss://realtime.insightsentry.com/live'

    async with websockets.connect(uri) as websocket:
        # Start ping task
        ping_task = asyncio.create_task(send_ping(websocket))

        try:
            async for message in websocket:
                if message == 'pong':
                    print('Received pong from server')
                    continue
                # Handle other messages here

        except websockets.exceptions.ConnectionClosed:
            print('WebSocket connection closed')
        finally:
            ping_task.cancel()

async def send_ping(websocket):
    while True:
        try:
            await asyncio.sleep(20)
            await websocket.send('ping')
        except asyncio.CancelledError:
            break

# Run the client
asyncio.run(websocket_client())

{
  "message": "api_key field is missing."
}

{
  "error": "invalid_bar_interval",
  "message": "Invalid bar_interval for second interval. Allowed values: 1, 5, 10, 15, 30, 45",
  "symbol": "NASDAQ:AAPL"
}

{
  "api_key": "your-websocket-api-key",
  "expiration": 1747580931
}

import time
import requests
from typing import Optional, Dict, Any
from dataclasses import dataclass

BASE_URL = 'https://insightsentry.p.rapidapi.com'

@dataclass
class WebSocketKey:
    key: str
    expires_at: int

async def get_valid_websocket_key() -> str:
    stored_key = await database.get_websocket_key()

    now = int(time.time())
    buffer_time = 24 * 60 * 60  # 24 hours

    if stored_key and stored_key.expires_at > (now + buffer_time):
        return stored_key.key

    response = requests.get(
        f'{BASE_URL}/v2/websocket-key',
        headers={
            'x-rapidapi-key': 'YOUR_RAPID_API_KEY'
        }
    )

    response.raise_for_status()
    data = response.json()

    await database.save_websocket_key(WebSocketKey(
        key=data['api_key'],
        expires_at=data['expiration']
    ))

    return data['api_key']

# pip install requests
# pip install websockets
# pip install asyncio
import requests
import websockets
import json
import asyncio

# If you've subscribed directly on our website, you don't need to refresh the API key as your API key can be used for both Rest API and WebSocket API.

###### RapidAPI specific code START ######
# Below API Key management only applies if you've subscribed via RapidAPI
url = "https://insightsentry.p.rapidapi.com/v2/websocket-key"

# Replace with your actual API key
apiKey = "YOUR_API_KEY_HERE"
headers = {
	"x-rapidapi-key": apiKey,
	"x-rapidapi-host": "insightsentry.p.rapidapi.com"
}

response = requests.get(url, headers=headers)

json_response = response.json()
print(json_response)

### Important ###
# Save the api_key somewhere in your database or file and then reuse it later
# Since the api_key's expiration is after one week, please refresh it accordingly
# You can retrieve only up to 10 Websocket API keys per day
# This is just an example to show how to get the api_key
api_key = json_response.get("api_key")

###### RapidAPI specific code END ######


async def handle_messages(websocket):
    async for message in websocket:
        if message == "pong": # skip pong
            continue

        # can safely assume that the message is a JSON string
        try:
            data = json.loads(message)

            # Check if json contains 'code'
            if 'code' in data:
                # Do something with the Quote or Series data
                if 'series' in data:
                    # Handle Series data
                    print(data)
                else:
                    # Handle Quote data
                    print(data)

            else:
                # "server_time" is for checking latency and connection status. If it's not received within 30 seconds, there may be a connection issue
                # "message" is for initial connection and error messages
                print(data)
        except json.JSONDecodeError as e:
            print(f"Failed to decode JSON: {e}")
            print(f"Raw message: {message}")

async def send_ping(websocket):
    """Send ping messages every 15 seconds to keep connection alive"""
    while True:
        try:
            await asyncio.sleep(15)
            await websocket.send('ping')
        except Exception as e:
            print(f"Ping failed: {e}")
            break

async def connect_and_subscribe():
    uri = "wss://realtime.insightsentry.com/live"

    try:
        async with websockets.connect(uri) as websocket:
            print("Connected to websocket")

            # Send subscription message
            subMsg = json.dumps({
                "api_key": api_key,
                "subscriptions": [
                    # Subscribe to either "series" or "quote" types
                    # With 1 Symbol Subscription you can subscribe to 1 "series" or 10 "quote"
                    {
                        "code": "NASDAQ:AAPL",
                        "type": "quote"
                    },
                    {
                        "code": "CME_MINI:ES1!",
                        "type": "quote"
                    }
                    #,
                    # {
                    #     "code": "NASDAQ:GOOGL",
                    #     "type": "series",
                    #     "bar_type": "second",
                    #     "extended": false, # to receive only regular trading hours data
                    #     "bar_interval": 1,
                    #     "max_dp": 100 # optional: receive 100 most recent bars on connect/reconnect
                    # },
                    # {
                    #     "code": "NASDAQ:AAPL",
                    #     "type": "series",
                    #     "bar_type": "tick",
                    #     "bar_interval": 1,
                    #     "max_dp": 500 # optional: request a specific amount of initial series history
                    # }
                ]
            })
            await websocket.send(subMsg)

            # Periodically sending 'ping' can help to keep connection sticky
            ping_task = asyncio.create_task(send_ping(websocket))

            try:
                # Handle incoming messages
                await handle_messages(websocket)
            finally:
                # Cancel ping task when done
                ping_task.cancel()
                try:
                    await ping_task
                except asyncio.CancelledError:
                    pass

    except websockets.exceptions.ConnectionClosed as e:
        print(f"Connection closed: {e}")
        raise
    except Exception as e:
        print(f"Connection error: {e}")
        raise

async def run_with_retry():
    attempt = 0
    while True:
        try:
            attempt += 1
            await connect_and_subscribe()
            break
        except Exception as e:
            wait_time = min(0.1 + (attempt - 1) * 0.5, 5)  # Start at 100ms, increase by 500ms, cap at 5 seconds
            print(f"Reconnecting in {wait_time} seconds...")
            await asyncio.sleep(wait_time)

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