TraderMade Docs

const WebSocket = require('ws');

var reconnectInterval = 1000 * 10
var ws;

var connect = function(){

const ws = new WebSocket('wss://stream.tradermade.com/feedAdv');

ws.on('open', function open() {
    ws.send("{\"action\":\"login\",\"key\":\"{{api_key}}\",\"fmt\":\"JSON\"}");
});

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

ws.on('message', function incoming(data) {
    console.log(data.toString());
    var json = JSON.parse(data);
    if (json.type === "login_ok") {
        ws.send("{\"action\":\"subscribe\",\"symbols\":[\"GBPUSD:QUOTE\"]}");
    }
});
};
connect();

// +build ignore

package main

import (
    "encoding/json"
    "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: "stream.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{})

    err = c.WriteMessage(websocket.TextMessage, []byte(`{"action":"login","key":"{{api_key}}","fmt":"JSON"}`))
    if err != nil {
        log.Fatal("write login:", err)
    }

    go func() {
        defer close(done)
        for {
            _, message, err := c.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("recv: %s", message)

            var msg map[string]interface{}
            if json.Unmarshal(message, &msg) == nil {
                if msg["type"] == "login_ok" {
                    log.Printf("Send Sub Details")
                    messageOut <- `{"action":"subscribe","symbols":["EURUSD:QUOTE"]}`
                }
            }
        }
    }()

    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 <-ticker.C:
            // keep-alive tick
        case <-interrupt:
            log.Println("interrupt")
            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
        }
    }
}

using System;
using System.Threading;
using System.Text.Json;
using Websocket.Client;

namespace TraderMadeWebSocketTest
{
    class Program
    {
        private string streaming_API_Key = "{{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://stream.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);
                        string loginData = "{\"action\":\"login\",\"key\":\"" + streaming_API_Key + "\",\"fmt\":\"JSON\"}";
                        client.Send(loginData);
                    });

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

                        try
                        {
                            var json = JsonDocument.Parse(msg.ToString());
                            var root = json.RootElement;

                            if (root.TryGetProperty("type", out var type) && type.GetString() == "login_ok")
                            {
                                string data = "{\"action\":\"subscribe\",\"symbols\":[\"EURUSD:QUOTE\",\"GBPUSD:QUOTE\",\"USDJPY:QUOTE\"]}";
                                client.Send(data);
                            }
                        }
                        catch { }
                    });

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

            Console.ReadKey();
        }
    }
}

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://stream.tradermade.com/feedAdv"), new WebSocketClient(latch))
                .join();
        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("{\"action\":\"login\",\"key\":\"{{api_key}}\",\"fmt\":\"JSON\"}", true);
        }

        @Override
        public CompletionStage onText(WebSocket webSocket, CharSequence data, boolean last) {
            System.out.println("onText received " + data);
            String s = data.toString();
            if (s.contains("\"type\":\"login_ok\"")) {
                webSocket.sendText("{\"action\":\"subscribe\",\"symbols\":[\"GBPUSD:QUOTE\"]}", true);
            }
            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);
        }
    }
}

require_once("vendor/autoload.php");

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

$client->text("{\"action\":\"login\",\"key\":\"{{api_key}}\",\"fmt\":\"JSON\"}");

$message = $client->receive();
echo $message . "\n";

$client->text("{\"action\":\"subscribe\",\"symbols\":[\"GBPUSD:QUOTE\"]}");

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

        if(isset($decoded_json->t) && $decoded_json->t === "QUOTE"){
                echo $decoded_json->t, " ", $decoded_json->s, " ", $decoded_json->ts, " ", $decoded_json->b, " ", $decoded_json->a, " ", $decoded_json->bv, " ", $decoded_json->av, "\n";
        } else {
                echo $message . "\n";
        }
}

library(websocket)
library(jsonlite)

{
    ws <- WebSocket$new("wss://stream.tradermade.com/feedAdv", autoConnect = FALSE)
    ws$onMessage(function(event) {
        d <- event$data
        json <- fromJSON(d)
        if (!is.null(json$type) && json$type == "login_ok") {
            ws$send("{\"action\":\"subscribe\",\"symbols\":[\"GBPUSD:QUOTE\",\"EURUSD:QUOTE\"]}")
        } else if (!is.null(json$t) && json$t == "QUOTE") {
            cat(" Symbol", json$s, json$ts, json$b, json$a, json$bv, json$av, json$t, "\n")
        } else {
            cat(d, "\n")
        }
    })
    ws$onOpen(function(event) {
        ws$send("{\"action\":\"login\",\"key\":\"{{api_key}}\",\"fmt\":\"JSON\"}")
    })
    ws$connect()
}