Documentation WebSockets | SocketIO

Websocket

WebSocket is a bidirectional protocol to get real-time data to help you build applications that require low latency data. The TraderMade WebSockets API provides a simple implementation that can be set up in minutes.

Connection Details

Send JSON On open (To Recv JSON)

{"userKey":"streaming_api_key", "symbol":"EURUSD,GBPUSD"}
                    

Recv JSON On message

{
  "symbol": "EURUSD",
  "ts": "1614076641",
  "bid": 1.21469,
  "ask": 1.2147,
  "mid": 1.214695
}
                    

Send JSON On open (To Recv SSV)

{"userKey":"streaming_api_key", "symbol":"EURUSD,GBPUSD", "fmt":"SSV"}
                        

Recv SSV On message

EURUSD 1614692703994 1.20232 1.20232
GBPUSD 1614692849259 1.38971 1.38974

SocketIO

SocketIO is a wrapper for websocket protocol implementation to get real-time data to help you build applications that require low latency data. The TraderMade SocketIO API can be connected in minutes using our simple implementation documentation. Our SocketIO is currently compatible with version 2 only.

Connection Details

Emit JSON On login

{userKey: "streaming_api_key"}
                    

Recv string On handshake

Welcome to the TMS Data Feed
                    

Emit JSON On symbolSub

{symbol: "USDJPY"}
                    

Recv string On subResponse

Subscribed to symbol
                    

Recv CSV On price

USDJPY 105.265 105.265 105.264999 20201015-15:18:15.215
                    

Nodejs Websocket Example

Below is an example Nodejs Websocket Client

NodeJS Websocket  Copy

const WebSocket = require ('ws');

var reconnectInterval  = 1000 * 10
var ws;

var connect = function(){

const ws = new WebSocket ('wss://marketdata.tradermade.com/feedadv');

ws.on('open', function open() {
   ws.send("{\"userKey\":\"streaming_api_key\", \"symbol\":\"GBPUSD\"}");
});

ws.on('close', function() {
  console.log('socket close : will reconnect in ' + reconnectInterval );
  setTimeout(connect, reconnectInterval)
});

ws.on('message', function incoming(data) {
  console.log(data);
});
};
connect();

Nodejs SocketIO Example

Below is an example Nodejs SocketIO Client

NodeJS SocketIO Copy

var io = require('socket.io-client');

var socket = io.connect('https://marketdata.tradermade.com', {reconnect: true});

var connected = false;


socket.on('connect', function () {
    console.log('Connected! Please CTRL+C and restart if you see this messsage more than twice');
    console.log('disconnecting and reconnecting can take upto a minute');
    console.log('.......');
    socket.emit('login', {userKey: "streaming_api_key"});
});

socket.on('disconnect', function (msg) {
    console.log(msg);
});

socket.on('handshake', function (msg) {
    console.log(msg);
    connected = true;
    socket.emit("symbolSub", {symbol: "USDJPY"});
    socket.emit("symbolSub", {symbol: "GBPUSD"});
    socket.emit("symbolSub", {symbol: "EURUSD"});

});

socket.on('subResponse', function (msg) {
    console.log(msg)

});

socket.on('message', function (msg) {
    console.log(msg)
});

socket.on('price', function (message){
    var data = message.split(" ")
    console.log(data[0] + " " + data[1] + " " + data[2] + " " + data[3] + " " + parseDate(data[4]))

});

function parseDate(dateString){
    var reggie = /(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2}).(\d{3})/;
    var dateArray = reggie.exec(dateString);
    var dateObject = new Date(
    (+dateArray[1]),
    (+dateArray[2])-1, // Careful, month starts at 0!
    (+dateArray[3]),
    (+dateArray[4]),
    (+dateArray[5]),
    (+dateArray[6])
    );
    return dateObject
}

Python Websocket Example

Below is an example Python Websocket Client

Python Websocket Copy

import websocket
import time

try:
    import thread
except ImportError:
    import _thread as thread



f = open("webSocketTester.log", "a")

def on_message(ws, message):
    print(message)
    f.write(message  +  "\n" )
    f.flush()


def on_error(ws, error):
    print(error)

def on_close(ws):
    print("### closed ###")

def on_open(ws):
    def run(*args):
        ws.send("{\"userKey\":\"streaming_api_key\", \"symbol\":\"GBPUSD\"}")
    thread.start_new_thread(run, ())


if __name__ == "__main__":
    ws = websocket.WebSocketApp("wss://marketdata.tradermade.com/feedadv",
                              on_message = on_message,
                              on_error = on_error,
                              on_close = on_close)
    ws.on_open = on_open
    ws.run_forever()

Python SocketIO Example

Below is an example Python SocketIO Client

Install Key Dependencies

python-engineio==3.14.2
python-socketio==4.3.1

Python SocketIO Copy

import socketio


# standard Python
sio = socketio.Client()

@sio.event
def connect():
    print("I'm connected!")
    sio.emit('login', {'userKey': 'streaming_api_key'})

@sio.event
def connect_error():
    print("The connection failed!")

@sio.event
def message(data):
    print('I received a message!')

@sio.on('handshake')
def on_message(data):
    print('HandShake', data)
    sio.emit('symbolSub', {'symbol': 'USDJPY'})
    sio.emit('symbolSub', {'symbol': 'GBPUSD'})
    sio.emit('symbolSub', {'symbol': 'EURUSD'})

@sio.on('price')
def on_message(data):
    print('Price Data ', data)


sio.connect('https://marketdata.tradermade.com')

Go Websocket Example

Below is an example Go Websocket Client

Go Websocket

// +build ignore

package main

import (
  "flag"
  "log"
  "net/url"
  "os"
  "os/signal"
  "time"
  "github.com/gorilla/websocket"

)


func main() {
  flag.Parse()
  log.SetFlags(0)

  messageOut := make(chan string)

  interrupt := make(chan os.Signal, 1)
  signal.Notify(interrupt, os.Interrupt)
  u := url.URL{Scheme: "wss", Host: "marketdata.tradermade.com", Path: "/feedadv",}
  log.Printf("connecting to %s", u.String())

  c, resp, err := websocket.DefaultDialer.Dial(u.String(), nil);
  if err != nil {
    log.Printf("handshake failed with status %d", resp.StatusCode)
    log.Fatal("dial:", err)
  }
  defer c.Close()

  done := make(chan struct{})

  go func() {
    defer close(done)
    for {
      _, message, err := c.ReadMessage()
      if err != nil {
        log.Println("read:", err)
        return
      }
      log.Printf("recv: %s", message)
      if string(message) == "Connected"{
        log.Printf("Send Sub Details: %s", message)
        messageOut <- "{\"userKey\":\"streaming_api_key\", \"symbol\":\"EURUSD\"}"
      }
    }
  }()

  ticker := time.NewTicker(time.Second)
  defer ticker.Stop()

  for {
    select {
    case <-done:
      return
    case m := <-messageOut:
      log.Printf("Send Message %s", m)
      err := c.WriteMessage(websocket.TextMessage, []byte(m))
      if err != nil {
        log.Println("write:", err)
        return
      }
    case t := <-ticker.C:
      err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
      if err != nil {
        log.Println("write:", err)
        return
      }
    case <-interrupt:
      log.Println("interrupt")

      // Cleanly close the connection by sending a close message and then
      // waiting (with timeout) for the server to close the connection.
      err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
      if err != nil {
        log.Println("write close:", err)
        return
      }
      select {
      case <-done:
      case <-time.After(time.Second):
      }
      return
    }
  }
}

C# Websocket Example

Below is an example C# Websocket Client

C# Websocket

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Net.WebSockets;

using Websocket.Client;

namespace TraderMadeWebSocketTest
{
    class Program
    {
        private string streaming_API_Key = "streaming_api_key";

        static void Main(string[] args)
        {
            Program prg = new Program();
            prg.Initialize();
        }

        private void Initialize()
        {
            Console.CursorVisible = false;

            try
            {
                var exitEvent = new ManualResetEvent(false);
                var url = new Uri("wss://marketdata.tradermade.com/feedadv");
                

                using (var client = new WebsocketClient(url))
                {
                    client.ReconnectTimeout = TimeSpan.FromSeconds(30);

                    client.ReconnectionHappened.Subscribe(info =>
                    {
                        Console.WriteLine("Reconnection happened, type: " + info.Type);
                    });

                    client.MessageReceived.Subscribe(msg =>
                    {
                        Console.WriteLine("Message received: " + msg);

                        if (msg.ToString().ToLower() == "connected")
                        {
                            string data = "{\"userKey\":\"" + streaming_API_Key + "\", \"symbol\":\"EURUSD,GBPUSD,USDJPY\"}";
                            client.Send(data);
                        }
                    });

                    client.Start();

                    //Task.Run(() => client.Send("{ message }"));

                    exitEvent.WaitOne();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: " + ex.ToString());
            }

            Console.ReadKey();
        }

    }
}

R Websocket Example

Below is an example R websocket Client

R Websocket

library(websocket)
library(jsonlite)

{
  ws <- WebSocket$new("wss://marketdata.tradermade.com/feedadv")
  ws$onMessage(function(event) {
    d <- event$data
    if (d != "Connected"){
        json = fromJSON(d)
        cat(" Symbol ", json$symbol, json$ts, json$bid, json$ask, json$mid)
    }
   })
   ws$onOpen(function(event) {
           ws$send("{\"userKey\":\"streaming_api_key\", \"symbol\":\"GBPUSD,EURUSD\"}")
   })
 }

PHP Websocket Example

Below is an example PHP websocket Client

PHP Websocket

<?php

require_once("vendor/autoload.php");


$client = new WebSocket\Client("wss://marketdata.tradermade.com/feedadv");


$message =  $client->receive();
echo $message;

$client->text("{\"userKey\":\"streaming_api_key\", \"symbol\":\"GBPUSD,EURUSD\"}");


while(true){
        $message =  $client->receive();

        if(strcmp($message,"connected") !== 0){
                $decoded_json = json_decode($message);
                echo $decoded_json->symbol, " ", $decoded_json->ts, " ", $decoded_json->bid, " ", $decoded_json->ask, "\n";
        }
}


?>

Java Websocket Example

Below is an example Java Websocket Client

Java Websocket

package client;

  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.WebSocket;
  import java.util.concurrent.CompletionStage;
  import java.util.concurrent.CountDownLatch;
  
  public class ClientCaller {
  
      public static void main(String[] args) throws Exception {
          CountDownLatch latch = new CountDownLatch(100);
  
          WebSocket ws = HttpClient
                  .newHttpClient()
                  .newWebSocketBuilder()
                  .buildAsync(URI.create("wss://marketdata.tradermade.com/feedadv"), new WebSocketClient(latch))
                  .join();
  //        ws.sendText("Hello!", true);
          latch.await();
      }
  
      private static class WebSocketClient implements WebSocket.Listener {
          private final CountDownLatch latch;
  
          public WebSocketClient(CountDownLatch latch) { this.latch = latch; }
  
          @Override
          public void onOpen(WebSocket webSocket) {
              System.out.println("onOpen using subprotocol " + webSocket.getSubprotocol());
              WebSocket.Listener.super.onOpen(webSocket);
              webSocket.sendText("{\"userKey\":\"streaming_api_key\", \"symbol\":\"GBPUSD\"}", true);
  
          }
  
          @Override
          public CompletionStage onText(WebSocket webSocket, CharSequence data, boolean last) {
              System.out.println("onText received " + data);
              latch.countDown();
              return WebSocket.Listener.super.onText(webSocket, data, last);
          }
  
          @Override
          public void onError(WebSocket webSocket, Throwable error) {
              System.out.println("Bad day! " + webSocket.toString());
              WebSocket.Listener.super.onError(webSocket, error);
          }
      }
  }