Examples

Browser JavaScript Example

// Browser WebSocket automatically sets Origin and User-Agent headers
const ws = new WebSocket('wss://api.monday.trade/v4/public/ws');

ws.onopen = () => {
  console.log('WebSocket connected');
  
  // Subscribe to K-line data
  ws.send(JSON.stringify({
    id: 1,
    method: 'SUBSCRIBE',
    params: {
      chainId: 143,
      instrument: '0x73ada1ea346cc3908f41cf67a040f0acd7808be0',
      expiry: 4294967295,
      interval: '1m',
      type: 'kline'
    }
  }));
  
  // Subscribe to order book
  ws.send(JSON.stringify({
    id: 2,
    method: 'SUBSCRIBE',
    params: {
      chainId: 143,
      instrument: '0x73ada1ea346cc3908f41cf67a040f0acd7808be0',
      expiry: 4294967295,
      type: 'orderBook'
    }
  }));
};

ws.onmessage = (event) => {
  const message = JSON.parse(event.data);
  
  if (message.id) {
    // Subscription response
    console.log('Subscription response:', message);
  } else if (message.stream) {
    // Data stream message
    console.log('Stream update:', message.stream, message.data);
    
    switch (message.stream) {
      case 'kline':
        // Handle K-line data
        break;
      case 'orderBook':
        // Handle order book data
        break;
      case 'instrument':
        // Handle instrument information
        break;
      case 'portfolio':
        // Handle portfolio notifications
        break;
      case 'blockNumChanged':
        // Handle block number changes
        break;
      case 'marketListChanged':
        // Handle market list changes
        break;
    }
  } else if (event.data === 'pong') {
    // Heartbeat response
    console.log('Heartbeat received');
  }
};

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

ws.onclose = () => {
  console.log('WebSocket closed');
  // Implement reconnection logic here
};

// Send heartbeat
setInterval(() => {
  if (ws.readyState === WebSocket.OPEN) {
    ws.send('ping');
  }
}, 30000);

Node.js TypeScript Example

import WebSocket from 'ws';

// Extract origin from URL for Origin header
const url = 'wss://api.monday.trade/v4/public/ws';
const urlObj = new URL(url);
const origin = `${urlObj.protocol}//${urlObj.host}`;

const ws = new WebSocket(url, {
  headers: {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Origin': origin,
  }
});

ws.on('open', () => {
  console.log('WebSocket connected');
  
  // Subscribe to K-line data
  ws.send(JSON.stringify({
    id: 1,
    method: 'SUBSCRIBE',
    params: {
      chainId: 143,
      instrument: '0x73ada1ea346cc3908f41cf67a040f0acd7808be0',
      expiry: 4294967295,
      interval: '1m',
      type: 'kline'
    }
  }));
  
  // Subscribe to order book
  ws.send(JSON.stringify({
    id: 2,
    method: 'SUBSCRIBE',
    params: {
      chainId: 143,
      instrument: '0x73ada1ea346cc3908f41cf67a040f0acd7808be0',
      expiry: 4294967295,
      type: 'orderBook'
    }
  }));
});

ws.on('message', (data: Buffer) => {
  const message = JSON.parse(data.toString());
  
  if (message.id) {
    // Subscription response
    console.log('Subscription response:', message);
  } else if (message.stream) {
    // Data stream message
    console.log('Stream update:', message.stream, message.data);
    
    switch (message.stream) {
      case 'kline':
        // Handle K-line data
        break;
      case 'orderBook':
        // Handle order book data
        break;
      case 'instrument':
        // Handle instrument information
        break;
      case 'portfolio':
        // Handle portfolio notifications
        break;
      case 'blockNumChanged':
        // Handle block number changes
        break;
      case 'marketListChanged':
        // Handle market list changes
        break;
    }
  } else if (data.toString() === 'pong') {
    // Heartbeat response
    console.log('Heartbeat received');
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});

ws.on('close', () => {
  console.log('WebSocket closed');
  // Implement reconnection logic here
});

// Send heartbeat
setInterval(() => {
  if (ws.readyState === WebSocket.OPEN) {
    ws.send('ping');
  }
}, 30000);

Python Example with Reconnection

import json
import time
import websocket
import threading
from typing import Dict, Set

class MondayWebSocket:
    def __init__(self, url: str):
        self.url = url
        self.ws = None
        self.subscriptions: Set[int] = set()
        self.reconnect_delay = 1
        self.max_reconnect_delay = 60
        self.running = False
        
    def on_message(self, ws, message):
        try:
            if message == 'pong':
                print('Heartbeat received')
                return
                
            data = json.loads(message)
            
            if 'id' in data:
                # Subscription response
                print(f'Subscription response: {data}')
                if data.get('result') == 'success':
                    self.subscriptions.add(data['id'])
            elif 'stream' in data:
                # Data stream message
                print(f'Stream update: {data["stream"]}')
                self.handle_stream_message(data)
        except Exception as e:
            print(f'Error processing message: {e}')
    
    def handle_stream_message(self, message: Dict):
        stream_type = message.get('stream')
        if stream_type == 'kline':
            print(f'K-line data: {message.get("data")}')
        elif stream_type == 'orderBook':
            print(f'Order book data received')
        elif stream_type == 'instrument':
            print(f'Instrument data received')
        elif stream_type == 'portfolio':
            print(f'Portfolio update: {message.get("data")}')
        elif stream_type == 'blockNumChanged':
            print(f'Block number changed: {message.get("data")}')
        elif stream_type == 'marketListChanged':
            print(f'Market list changed')
    
    def on_error(self, ws, error):
        print(f'WebSocket error: {error}')
    
    def on_close(self, ws, close_status_code, close_msg):
        print('WebSocket closed')
        self.ws = None
        if self.running:
            self.reconnect()
    
    def on_open(self, ws):
        print('WebSocket connected')
        self.reconnect_delay = 1
        # Resubscribe to all previous subscriptions
        self.subscribe_kline()
        self.subscribe_orderbook()
    
    def subscribe_kline(self):
        if self.ws:
            message = {
                "id": 1,
                "method": "SUBSCRIBE",
                "params": {
                    "chainId": 143,
                    "instrument": "0x73ada1ea346cc3908f41cf67a040f0acd7808be0",
                    "expiry": 4294967295,
                    "interval": "1m",
                    "type": "kline"
                }
            }
            self.ws.send(json.dumps(message))
    
    def subscribe_orderbook(self):
        if self.ws:
            message = {
                "id": 2,
                "method": "SUBSCRIBE",
                "params": {
                    "chainId": 143,
                    "instrument": "0x73ada1ea346cc3908f41cf67a040f0acd7808be0",
                    "expiry": 4294967295,
                    "type": "orderBook"
                }
            }
            self.ws.send(json.dumps(message))
    
    def send_heartbeat(self):
        if self.ws and self.ws.sock and self.ws.sock.connected:
            self.ws.send('ping')
    
    def reconnect(self):
        while self.running:
            print(f'Reconnecting in {self.reconnect_delay} seconds...')
            time.sleep(self.reconnect_delay)
            
            try:
                self.connect()
                break
            except Exception as e:
                print(f'Reconnection failed: {e}')
                self.reconnect_delay = min(self.reconnect_delay * 2, self.max_reconnect_delay)
    
    def connect(self):
        self.ws = websocket.WebSocketApp(
            self.url,
            on_open=self.on_open,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
            header={
                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
                'Origin': 'https://api.monday.trade'
            }
        )
        
        # Start heartbeat thread
        def heartbeat():
            while self.running:
                time.sleep(30)
                self.send_heartbeat()
        
        heartbeat_thread = threading.Thread(target=heartbeat, daemon=True)
        heartbeat_thread.start()
        
        # Run WebSocket in a separate thread
        self.ws.run_forever()
    
    def start(self):
        self.running = True
        self.connect()
    
    def stop(self):
        self.running = False
        if self.ws:
            self.ws.close()

# Usage
if __name__ == '__main__':
    ws_client = MondayWebSocket('wss://api.monday.trade/v4/public/ws')
    try:
        ws_client.start()
    except KeyboardInterrupt:
        ws_client.stop()

Changelog

• Support for K-line, order book, instrument information, portfolio, and common event subscriptions

• Heartbeat mechanism support

• Multi-chain subscription support