Usage Examples

note

Important: The Live Feed WebSocket endpoint is designed for backend-to-backend communication only. Frontend clients should not connect directly to this endpoint. Instead, implement a backend service that consumes the WebSocket feed and exposes data to frontend clients through appropriate REST endpoints or other secure mechanisms.

Backend Server Implementation (Node.js)

import WebSocket from 'ws';
import express from 'express';

const app = express();
const BEARER_TOKEN = 'YOUR_BEARER_TOKEN';
const WEBSOCKET_URL = 'wss://csapis.com/2.0/market/feed/l2';

// Store for active WebSocket connection
let liveWebSocket = null;

// Function to establish WebSocket connection
function connectToLiveFeed() {
  const headers = {
    Authorization: `Bearer ${BEARER_TOKEN}`
  };

  liveWebSocket = new WebSocket(WEBSOCKET_URL, { headers });

  liveWebSocket.on('open', () => {
    console.log('Connected to Capital Stake Live Feed');
  });

  liveWebSocket.on('message', (data) => {
    try {
      const message = JSON.parse(data);
      
      switch(message.type) {
        case 'tick':
          handleSnapshotTick(message.data);
          break;
        case 'tob':
          handleOrderBookTick(message.data);
          break;
        case 'tor':
          handleOrderTick(message.data);
          break;
        case 'tex':
          handleExecutionTick(message.data);
          break;
      }
    } catch (error) {
      console.error('Error parsing message:', error);
    }
  });

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

  liveWebSocket.on('close', () => {
    console.log('Connection closed, attempting reconnect...');
    setTimeout(connectToLiveFeed, 5000); // Reconnect after 5 seconds
  });
}

// Message handlers
function handleSnapshotTick(data) {
  console.log(`[TICK] ${data.s}: Close=${data.c}, Volume=${data.v}`);
  // Process and distribute to clients
}

function handleOrderBookTick(data) {
  console.log(`[TOB] ${data.s}: Buy=${data.bs?.x}, Sell=${data.ss?.x}`);
  // Process and distribute to clients
}

function handleOrderTick(data) {
  console.log(`[ORDER] ${data.s}: Price=${data.x}, Qty=${data.v}, Side=${data.sd}`);
  // Process and distribute to clients
}

function handleExecutionTick(data) {
  console.log(`[EXECUTION] ${data.s}: Price=${data.x}, Qty=${data.v}`);
  // Process and distribute to clients
}

// REST endpoint for frontend clients to consume market data
app.get('/api/market/data/:symbol', (req, res) => {
  const { symbol } = req.params;
  // Return cached/processed data from WebSocket feed
  res.json({ symbol, data: 'market data from live feed' });
});

// Initialize connection on server start
connectToLiveFeed();

app.listen(3000, () => {
  console.log('Backend server running on port 3000');
});

Backend Server Implementation (Python)

import asyncio
import json
import websockets
from flask import Flask, jsonify

app = Flask(__name__)
BEARER_TOKEN = 'YOUR_BEARER_TOKEN'
WEBSOCKET_URL = 'wss://csapis.com/2.0/market/feed/l2'

# Store for market data cache
market_data_cache = {}

async def connect_to_live_feed():
    """Connect to Capital Stake Live Feed WebSocket"""
    headers = {
        'Authorization': f'Bearer {BEARER_TOKEN}'
    }
    
    while True:
        try:
            async with websockets.connect(WEBSOCKET_URL, extra_headers=headers) as websocket:
                print('Connected to Capital Stake Live Feed')
                
                async for message in websocket:
                    try:
                        data = json.loads(message)
                        await handle_message(data)
                    except json.JSONDecodeError:
                        print('Error parsing message')
                        
        except Exception as error:
            print(f'WebSocket error: {error}')
            print('Attempting reconnect in 5 seconds...')
            await asyncio.sleep(5)

async def handle_message(message):
    """Process incoming WebSocket messages"""
    msg_type = message.get('type')
    data = message.get('data', {})
    
    if msg_type == 'tick':
        symbol = data.get('s')
        market_data_cache[symbol] = data
        print(f"[TICK] {symbol}: Close={data.get('c')}, Volume={data.get('v')}")
        
    elif msg_type == 'tob':
        symbol = data.get('s')
        market_data_cache[f'{symbol}_tob'] = data
        print(f"[TOB] {symbol}: Buy={data.get('bs', {}).get('x')}, Sell={data.get('ss', {}).get('x')}")
        
    elif msg_type == 'tor':
        print(f"[ORDER] {data.get('s')}: Price={data.get('x')}, Qty={data.get('v')}")
        
    elif msg_type == 'tex':
        print(f"[EXECUTION] {data.get('s')}: Price={data.get('x')}, Qty={data.get('v')}")

# REST endpoint for frontend clients
@app.route('/api/market/data/<symbol>', methods=['GET'])
def get_market_data(symbol):
    """Return cached market data from live feed"""
    if symbol in market_data_cache:
        return jsonify(market_data_cache[symbol])
    return jsonify({'error': 'Symbol not found'}), 404

# Start WebSocket connection in background
@app.before_first_request
def startup():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    loop.create_task(connect_to_live_feed())

if __name__ == '__main__':
    app.run(port=3000, debug=False)

Error Responses

Authentication Failed (4001)

{
  "type": "error",
  "code": 4001,
  "message": "Authentication failed"
}

Invalid Token (4002)

{
  "type": "error",
  "code": 4002,
  "message": "Invalid authentication token"
}

Connection Limit Exceeded (4003)

{
  "type": "error",
  "code": 4003,
  "message": "Connection limit exceeded"
}

Server Error (5000)

{
  "type": "error",
  "code": 5000,
  "message": "Internal server error"
}