WebSocket Streams

Realtime Exchange provides two WebSocket services for real-time market data streaming:

Main WebSocket - Real-time trading data for pairs, tokens, and pools
Aggregated WebSocket - Aggregated token data with price and volume alerts

Both services use Socket.IO for reliable WebSocket connections.

Main WebSocket

Connection

import { io } from "socket.io-client";

const socket = io("wss://ws.integrated-api.testnet.realtime.exchange", {
  transports: ["websocket"],
});

socket.on("connect", () => {
  console.log("Connected:", socket.id);
});

Available Channels

Channel	Description
`subscribe:pairs`	Subscribe to pair price and candle updates
`subscribe:tokens`	Subscribe to token candle updates
`subscribe:datafeed`	TradingView-compatible OHLCV datafeed
`subscribe:token-datafeed`	Token-specific candlestick datafeed
`subscribe:trades`	Real-time trade updates for a pair
`subscribe:pool-markets`	Pool market data (price, liquidity, volume)
`subscribe:pool`	Unified pool stream (trades + candles)

Supported Intervals

1m, 2m, 3m, 5m, 10m, 15m, 20m, 30m, 1h, 2h, 4h, 1d, 1w, 1mo

Pair Subscriptions

Subscribe to real-time price and candle updates for trading pairs.

socket.emit("subscribe:pairs", {
  pairs: ["0x1234...abcd", "0x5678...efgh"],
  intervals: ["1m", "5m", "1h"]
});

Events Received

Subscription Confirmed:

socket.on("pairs:subscribed", (data) => {
  console.log("Subscribed to:", data.pairs);
});

Price Snapshot (Initial):

socket.on("pairs:price-snapshot", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

Price Update:

socket.on("pairs:price-update", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

Candle Snapshot (Initial):

socket.on("pairs:candle-snapshot", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume }, marketType }
});

Candle Update:

socket.on("pairs:candle-update", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume } }
});

Unsubscribe

socket.emit("unsubscribe:pairs", {
  pairs: ["0x1234...abcd"]
});

socket.on("pairs:unsubscribed", (data) => {
  console.log("Unsubscribed from:", data.pairs);
});

Token Subscriptions

Subscribe to candle updates for specific tokens across all pools.

socket.emit("subscribe:tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."],
  intervals: ["1m", "15m"]
});

Events Received

Subscription Confirmed:

socket.on("tokens:subscribed", (data) => {
  console.log("Subscribed to tokens:", data.tokens);
});

Candle Snapshot:

socket.on("tokens:candle-snapshot", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume } }
});

Candle Update:

socket.on("tokens:candle-update", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume, volumeUSD, txCount } }
});

Datafeed (TradingView Compatible)

Subscribe to OHLCV data for TradingView charting integration.

socket.emit("subscribe:datafeed", {
  market: "0xpoolAddress...",
  marketType: "amm", // "amm" | "clmm" | "launchpad"
  period: 5 // Period in minutes: 1, 5, 15, 60, 240, 1440, etc.
});

Period Mapping:

Period (minutes)	Interval
1	1m
5	5m
15	15m
60	1h
240	4h
1440	1d
10080	1w

Events Received

Subscription Confirmed:

socket.on("datafeed:subscribed", (data) => {
  // { market, marketType, period }
});

Datafeed Snapshot (Historical Candles):

socket.on("datafeed:snapshot", (data) => {
  // { market, marketType, period, candles: [{ time, open, high, low, close, volume }] }
});

Datafeed Update:

socket.on("datafeed:update", (data) => {
  // { market, marketType, period, data: { time, open, high, low, close, volume } }
});

Token Datafeed

Subscribe to candlestick data for individual tokens.

socket.emit("subscribe:token-datafeed", {
  token: "0xtokenAddress...",
  period: 5 // Period in minutes
});

Events Received

Subscription Confirmed:

socket.on("token-datafeed:subscribed", (data) => {
  // { token, period }
});

Snapshot:

socket.on("token-datafeed:snapshot", (data) => {
  // { token, period, candles: [{ time, open, high, low, close, volume, volumeUSD, txCount }] }
});

Update:

socket.on("token-datafeed:update", (data) => {
  // { token, period, data: { time, open, high, low, close, volume, volumeUSD, txCount } }
});

Trades Stream

Subscribe to real-time trade executions for a specific pair.

socket.emit("subscribe:trades", {
  pair: "0xpoolAddress..."
});

Events Received

Subscription Confirmed:

socket.on("trades:subscribed", (data) => {
  // { pair }
});

Trades Snapshot (Recent Trades):

socket.on("trades:snapshot", (data) => {
  // { pair, trades: [{ taker, type, price, size, timestamp, transactionHash }] }
});

New Trade:

socket.on("trades:new", (data) => {
  // { taker, type, price, size, timestamp, transactionHash }
});

Trade Data Fields:

Field	Type	Description
`taker`	string	Taker wallet address
`type`	string	Trade type: `"buy"` or `"sell"`
`price`	string	Execution price
`size`	string	Trade size in token units
`timestamp`	number	Unix timestamp
`transactionHash`	string	On-chain transaction hash

Unsubscribe

socket.emit("unsubscribe:trades");

socket.on("trades:unsubscribed", () => {
  console.log("Unsubscribed from trades");
});

Pool Markets

Subscribe to aggregated market data for a pool (price, liquidity, volume, APR).

socket.emit("subscribe:pool-markets", {
  pool: "0xpoolAddress..."
});

Events Received

Subscription Confirmed:

socket.on("pool-markets:subscribed", (data) => {
  // { pool }
});

Market Snapshot:

socket.on("pool-markets:snapshot", (data) => {
  /*
  {
    address: "0x...",
    price: "1.234567",
    liquidity: "1000000.00",
    volume24hr: "50000.00",
    apr: "12.500000",
    quoteToken: {
      marketCap: "1000000",
      address: "0x...",
      price: "1.00",
      variation1h: "0.5",
      variation24h: "-1.2"
    },
    baseToken: {
      marketCap: "500000",
      address: "0x...",
      price: "1.234567",
      variation1h: "2.1",
      variation24h: "5.5"
    }
  }
  */
});

Market Update:

socket.on("pool-markets:update", (data) => {
  // Same structure as snapshot
});

Unsubscribe

socket.emit("unsubscribe:pool-markets");

Unified Pool Stream

Subscribe to a unified stream for a pool with trades and candles.

socket.emit("subscribe:pool", {
  poolId: "0xpoolAddress...",
  candlePeriod: 5 // Period in minutes
});

Update Candle Period

socket.emit("update:candlePeriod", {
  poolId: "0xpoolAddress...",
  candlePeriod: 15 // New period
});

Unsubscribe

socket.emit("unsubscribe:pool");

Aggregated WebSocket

The Aggregated WebSocket provides token-level aggregated data across all pools with price and volume alerting.

Connection

const aggregatedSocket = io("wss://ws.integrated-api.testnet.realtime.exchange", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

aggregatedSocket.on("connected", (data) => {
  console.log("Connected:", data.clientId);
  console.log("Available events:", data.availableEvents);
});

aggregatedSocket.emit("subscribe-tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."]
});

aggregatedSocket.on("subscription-confirmed", (data) => {
  console.log("Subscribed to:", data.tokens);
});

Receive Token Updates

Initial Data:

aggregatedSocket.on("initial-aggregated-data", (data) => {
  // { tokenAddress, data: {...}, timestamp }
});

Real-time Updates:

aggregatedSocket.on("aggregated-update", (data) => {
  /*
  {
    type: "token_update",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.23,
      priceImpactPercent: 0.5,
      instantVolume: 10000,
      triggerPool: { address: "0x..." }
    }
  }
  */
});

Unsubscribe from Tokens

aggregatedSocket.emit("unsubscribe-tokens", {
  tokens: ["0xtoken1..."]
});

Price Alerts

Set alerts to be notified when a token reaches a specific price.

Set Alert

aggregatedSocket.emit("set-price-alert", {
  tokenAddress: "0xtoken...",
  threshold: 1.50, // USD price threshold
  direction: "up", // "up" | "down" | "both"
  timeframe: "1m" // "1m" | "5m" | "15m" | "1h"
});

aggregatedSocket.on("price-alert-set", (data) => {
  console.log("Alert set for", data.tokenAddress, "at $", data.threshold);
});

Alert Triggered

aggregatedSocket.on("price-alert-triggered", (data) => {
  /*
  {
    type: "price_alert",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.52,
      priceChange: 1.5,
      timeframe: "1m",
      threshold: 1.50,
      direction: "up"
    }
  }
  */
});

Remove Alert

aggregatedSocket.emit("remove-price-alert", {
  tokenAddress: "0xtoken..."
});

Volume Alerts

Set alerts for volume spikes on specific tokens.

Set Alert

aggregatedSocket.emit("set-volume-alert", {
  tokenAddress: "0xtoken...",
  thresholdUSD: 50000, // USD volume threshold
  percentageIncrease: 100, // % increase to trigger
  timeframe: "5m" // "1m" | "5m" | "15m"
});

aggregatedSocket.on("volume-alert-set", (data) => {
  console.log("Volume alert set for", data.tokenAddress);
});

Alert Triggered

aggregatedSocket.on("volume-alert-triggered", (data) => {
  /*
  {
    type: "volume_spike",
    data: {
      tokenAddress: "0x...",
      volumeUSD: 75000,
      volumeIncrease: 150,
      timeframe: "5m",
      triggerPool: "0x..."
    }
  }
  */
});

Remove Alert

aggregatedSocket.emit("remove-volume-alert", {
  tokenAddress: "0xtoken..."
});

Error Handling

Both WebSocket services emit error events when something goes wrong.

socket.on("error", (data) => {
  console.error("WebSocket error:", data.message);
});

socket.on("disconnect", (reason) => {
  console.log("Disconnected:", reason);
});

socket.on("server-shutdown", (data) => {
  console.log("Server shutting down:", data.message);
});

Complete Example

import { io } from "socket.io-client";

// Main WebSocket for trading data
const tradingSocket = io("wss://ws.integrated-api.testnet.realtime.exchange", {
  transports: ["websocket"],
});

// Aggregated WebSocket for token analytics
const aggregatedSocket = io("wss://ws.integrated-api.testnet.realtime.exchange", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

// Trading socket events
tradingSocket.on("connect", () => {
  console.log("Trading socket connected");

  // Subscribe to pair updates
  tradingSocket.emit("subscribe:pairs", {
    pairs: ["0x1234567890abcdef..."],
    intervals: ["1m", "5m"]
  });

  // Subscribe to trades
  tradingSocket.emit("subscribe:trades", {
    pair: "0x1234567890abcdef..."
  });
});

tradingSocket.on("pairs:price-update", (data) => {
  console.log(`Price update: ${data.pair} = $${data.price}`);
});

tradingSocket.on("trades:new", (trade) => {
  console.log(`New trade: ${trade.type} ${trade.size} @ ${trade.price}`);
});

// Aggregated socket events
aggregatedSocket.on("connected", (data) => {
  console.log("Aggregated socket connected:", data.clientId);

  // Subscribe to token updates
  aggregatedSocket.emit("subscribe-tokens", {
    tokens: ["0xabcdef1234567890..."]
  });

  // Set price alert
  aggregatedSocket.emit("set-price-alert", {
    tokenAddress: "0xabcdef1234567890...",
    threshold: 2.00,
    direction: "up",
    timeframe: "5m"
  });
});

aggregatedSocket.on("aggregated-update", (data) => {
  console.log(`Token update: $${data.data.priceUSD}`);
});

aggregatedSocket.on("price-alert-triggered", (alert) => {
  console.log(`Price alert! ${alert.data.tokenAddress} reached $${alert.data.priceUSD}`);
});

Overview

Markets

Tokens

Trading

Portfolio

Analytics

Launchpad

Profile

Utility

CLOB

CLOB Pools

CLOB Orders

CLOB Markets

CLOB Currencies

CLOB Users

​WebSocket Streams

​Main WebSocket

​Connection

​Available Channels

​Supported Intervals

​Pair Subscriptions

​Subscribe

​Events Received

​Unsubscribe

​Token Subscriptions

​Subscribe

​Events Received

​Datafeed (TradingView Compatible)

​Subscribe

​Events Received

​Token Datafeed

​Subscribe

​Events Received

​Trades Stream

​Subscribe

​Events Received

​Unsubscribe

​Pool Markets

​Subscribe

​Events Received

​Unsubscribe

​Unified Pool Stream

​Subscribe

​Update Candle Period

​Unsubscribe

​Aggregated WebSocket

​Connection

​Subscribe to Tokens

​Receive Token Updates

​Unsubscribe from Tokens

​Price Alerts

​Set Alert

​Alert Triggered

​Remove Alert

​Volume Alerts

​Set Alert

​Alert Triggered

​Remove Alert

​Error Handling

​Complete Example

WebSocket Streams

Main WebSocket

Connection

Available Channels

Supported Intervals

Pair Subscriptions

Subscribe

Events Received

Unsubscribe

Token Subscriptions

Subscribe

Events Received

Datafeed (TradingView Compatible)

Subscribe

Events Received

Token Datafeed

Subscribe

Events Received

Trades Stream

Subscribe

Events Received

Unsubscribe

Pool Markets

Subscribe

Events Received

Unsubscribe

Unified Pool Stream

Subscribe

Update Candle Period

Unsubscribe

Aggregated WebSocket

Connection

Subscribe to Tokens

Receive Token Updates

Unsubscribe from Tokens

Price Alerts

Set Alert

Alert Triggered

Remove Alert

Volume Alerts

Set Alert

Alert Triggered

Remove Alert

Error Handling

Complete Example