WebSocket streams

// JavaScript — multiple symbol subscriptions (one connection per symbol/TF pair)
const subscriptions = [
  { symbol: "XAUUSD", timeFrame: "M1" },
  { symbol: "BTCUSD", timeFrame: "M5" },
  { symbol: "EURUSD", timeFrame: "H1" },
]

const connections = subscriptions.map(({ symbol, timeFrame }) => {
  const ws = new WebSocket(
    `wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=${symbol}&timeFrame=${timeFrame}`
  )
  ws.onmessage = ({ data }) => handleCandle(JSON.parse(data))
  return ws
})

function handleCandle(candle) {
  console.log(candle.SymbolCode, candle.OpenTime, candle.ClosePrice)
}

# Python — multiple subscriptions with asyncio
import asyncio, json, websockets

API_KEY = "YOUR_API_KEY"
SUBS = [
    ("XAUUSD", "M1"),
    ("BTCUSD", "M5"),
    ("EURUSD", "H1"),
]

async def stream(symbol, timeframe):
    uri = f"wss://api.realmarketapi.com/price?apiKey={API_KEY}&symbolCode={symbol}&timeFrame={timeframe}"
    async for ws in websockets.connect(uri):
        try:
            async for message in ws:
                candle = json.loads(message)
                print(f"{candle['SymbolCode']:10} {candle['ClosePrice']}")
        except websockets.ConnectionClosed:
            continue

async def main():
    await asyncio.gather(*[stream(s, tf) for s, tf in SUBS])

asyncio.run(main())

// C# — multiple subscriptions concurrently
using System.Net.WebSockets;
using System.Text;

const string apiKey = "YOUR_API_KEY";
var subs = new[] {
    ("XAUUSD", "M1"),
    ("BTCUSD", "M5"),
    ("EURUSD", "H1"),
};

var tasks = subs.Select(async sub =>
{
    var (symbol, tf) = sub;
    var uri = new Uri($"wss://api.realmarketapi.com/price?apiKey={apiKey}&symbolCode={symbol}&timeFrame={tf}");
    using var ws = new ClientWebSocket();
    await ws.ConnectAsync(uri, CancellationToken.None);
    Console.WriteLine($"Connected: {symbol}/{tf}");
    var buf = new byte[4096];
    while (ws.State == WebSocketState.Open)
    {
        var r = await ws.ReceiveAsync(buf, CancellationToken.None);
        Console.WriteLine(Encoding.UTF8.GetString(buf, 0, r.Count));
    }
});

await Task.WhenAll(tasks);

# Ruby — multiple subscriptions with threads
require 'websocket-client-simple'
require 'json'

API_KEY = 'YOUR_API_KEY'
SUBS = [
  ['XAUUSD', 'M1'],
  ['BTCUSD', 'M5'],
  ['EURUSD', 'H1'],
]

threads = SUBS.map do |symbol, timeframe|
  Thread.new do
    url = "wss://api.realmarketapi.com/price?apiKey=#{API_KEY}&symbolCode=#{symbol}&timeFrame=#{timeframe}"
    ws  = WebSocket::Client::Simple.connect(url)
    ws.on(:message) do |msg|
      candle = JSON.parse(msg.data)
      puts "#{candle['SymbolCode']} #{candle['ClosePrice']}"
    end
    sleep 1 while ws.open?
  end
end

threads.each(&:join)

// Dart — multiple subscriptions concurrently
import 'dart:io';
import 'dart:convert';

const apiKey = 'YOUR_API_KEY';
const subs = [
  ('XAUUSD', 'M1'),
  ('BTCUSD', 'M5'),
  ('EURUSD', 'H1'),
];

Future<void> streamSymbol(String symbol, String timeFrame) async {
  final url = 'wss://api.realmarketapi.com/price?apiKey=$apiKey&symbolCode=$symbol&timeFrame=$timeFrame';
  final ws  = await WebSocket.connect(url);
  await for (final msg in ws) {
    final candle = jsonDecode(msg as String) as Map<String, dynamic>;
    print('${candle['SymbolCode']} ${candle['ClosePrice']}');
  }
}

Future<void> main() async {
  await Future.wait([for (final (s, tf) in subs) streamSymbol(s, tf)]);
}

// Node.js / Browser — basic WebSocket connection
const ws = new WebSocket(
  "wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=XAUUSD&timeFrame=M1"
)

ws.onopen    = () => console.log("[RealMarketAPI] Connected")
ws.onmessage = ({ data }) => {
  const candle = JSON.parse(data)
  console.log(candle.SymbolCode, candle.ClosePrice, candle.Bid, candle.Ask)
}
ws.onerror   = (err) => console.error("[RealMarketAPI] Error", err)
ws.onclose   = ()    => console.log("[RealMarketAPI] Disconnected")

# Python — requires: pip install websockets
import asyncio, json, websockets

API_KEY   = "YOUR_API_KEY"
SYMBOL    = "XAUUSD"
TIMEFRAME = "M1"
URI = f"wss://api.realmarketapi.com/price?apiKey={API_KEY}&symbolCode={SYMBOL}&timeFrame={TIMEFRAME}"

async def stream():
    async with websockets.connect(URI) as ws:
        print("[RealMarketAPI] Connected")
        async for message in ws:
            candle = json.loads(message)
            print(candle["SymbolCode"], candle["ClosePrice"], candle["Bid"])

asyncio.run(stream())

// C# — System.Net.WebSockets (built-in .NET)
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;

const string apiKey    = "YOUR_API_KEY";
const string symbol    = "XAUUSD";
const string timeFrame = "M1";
var uri = new Uri($"wss://api.realmarketapi.com/price?apiKey={apiKey}&symbolCode={symbol}&timeFrame={timeFrame}");

using var ws = new ClientWebSocket();
await ws.ConnectAsync(uri, CancellationToken.None);
Console.WriteLine("[RealMarketAPI] Connected");

var buffer = new byte[4096];
while (ws.State == WebSocketState.Open)
{
    var result = await ws.ReceiveAsync(buffer, CancellationToken.None);
    var json   = Encoding.UTF8.GetString(buffer, 0, result.Count);
    var candle = JsonDocument.Parse(json).RootElement;
    Console.WriteLine($"{candle.GetProperty("SymbolCode")} Close={candle.GetProperty("ClosePrice")}");
}

// Java 11+ — requires: org.java-websocket:Java-WebSocket
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;

public class WsBasic extends WebSocketClient {
    public WsBasic(URI uri) { super(uri); }

    @Override public void onOpen(ServerHandshake h)  { System.out.println("Connected"); }
    @Override public void onMessage(String msg)       { System.out.println(msg); }
    @Override public void onClose(int c, String r, boolean i) { System.out.println("Closed: " + r); }
    @Override public void onError(Exception e)        { e.printStackTrace(); }

    public static void main(String[] args) throws Exception {
        var uri = new URI("wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=XAUUSD&timeFrame=M1");
        new WsBasic(uri).connect();
    }
}

// Go — requires: github.com/gorilla/websocket
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "github.com/gorilla/websocket"
)

func main() {
    url := "wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=XAUUSD&timeFrame=M1"
    conn, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil { log.Fatal(err) }
    defer conn.Close()
    fmt.Println("[RealMarketAPI] Connected")

    for {
        _, msg, err := conn.ReadMessage()
        if err != nil { log.Println("Disconnected:", err); break }
        var candle map[string]interface{}
        json.Unmarshal(msg, &candle)
        fmt.Println(candle["SymbolCode"], candle["ClosePrice"])
    }
}

# Ruby — requires: gem install websocket-client-simple
require 'websocket-client-simple'
require 'json'

url = "wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=XAUUSD&timeFrame=M1"
ws  = WebSocket::Client::Simple.connect(url)

ws.on(:open)    { puts '[RealMarketAPI] Connected' }
ws.on(:message) do |msg|
  candle = JSON.parse(msg.data)
  puts "#{candle['SymbolCode']} #{candle['ClosePrice']} Bid:#{candle['Bid']}"
end
ws.on(:error)   { |e| puts "[RealMarketAPI] Error: #{e.message}" }
ws.on(:close)   { puts '[RealMarketAPI] Disconnected' }

loop { sleep 1 }

// Dart — built-in WebSocket support (dart:io)
import 'dart:io';
import 'dart:convert';

void main() async {
  final ws = await WebSocket.connect(
    'wss://api.realmarketapi.com/price?apiKey=YOUR_API_KEY&symbolCode=XAUUSD&timeFrame=M1',
  );
  print('[RealMarketAPI] Connected');

  await for (final message in ws) {
    final candle = jsonDecode(message as String) as Map<String, dynamic>;
    print('${candle['SymbolCode']} ${candle['ClosePrice']} Bid:${candle['Bid']}');
  }
}

// JavaScript — auto-reconnect with exponential back-off (production)
const API_KEY   = "YOUR_API_KEY"
const SYMBOL    = "XAUUSD"
const TIMEFRAME = "M1"
const WS_URL    = `wss://api.realmarketapi.com/price?apiKey=${API_KEY}&symbolCode=${SYMBOL}&timeFrame=${TIMEFRAME}`

let ws
let delay = 1_000  // start at 1 s

function connect() {
  ws = new WebSocket(WS_URL)

  ws.onopen = () => {
    console.log("Connected")
    delay = 1_000   // reset on successful connection
  }

  ws.onmessage = ({ data }) => {
    const candle = JSON.parse(data)
    console.log(candle.SymbolCode, candle.ClosePrice)
  }

  ws.onclose = () => {
    console.warn(`Disconnected. Reconnecting in ${delay}ms…`)
    setTimeout(connect, delay)
    delay = Math.min(delay * 2, 30_000)   // cap at 30 s
  }

  ws.onerror = (e) => console.error("WS error", e)
}

connect()

# Python — auto-reconnect pattern (websockets library)
import asyncio, json, websockets

API_KEY   = "YOUR_API_KEY"
SYMBOL    = "XAUUSD"
TIMEFRAME = "M1"
URI = f"wss://api.realmarketapi.com/price?apiKey={API_KEY}&symbolCode={SYMBOL}&timeFrame={TIMEFRAME}"

async def stream():
    # websockets.connect() has built-in retry with exponential back-off
    async for ws in websockets.connect(URI):
        try:
            async for message in ws:
                candle = json.loads(message)
                print(candle["SymbolCode"], candle["ClosePrice"], candle["Bid"])
        except websockets.ConnectionClosed:
            print("Disconnected — retrying…")
            continue

asyncio.run(stream())

// C# — auto-reconnect with exponential back-off
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;

const string apiKey    = "YOUR_API_KEY";
const string symbol    = "XAUUSD";
const string timeFrame = "M1";
var uri = new Uri($"wss://api.realmarketapi.com/price?apiKey={apiKey}&symbolCode={symbol}&timeFrame={timeFrame}");

int delayMs = 1_000;

while (true)
{
    try
    {
        using var ws = new ClientWebSocket();
        await ws.ConnectAsync(uri, CancellationToken.None);
        Console.WriteLine("Connected");
        delayMs = 1_000;

        var buf = new byte[4096];
        while (ws.State == WebSocketState.Open)
        {
            var r    = await ws.ReceiveAsync(buf, CancellationToken.None);
            var json = Encoding.UTF8.GetString(buf, 0, r.Count);
            var c    = JsonDocument.Parse(json).RootElement;
            Console.WriteLine($"{c.GetProperty("SymbolCode")} {c.GetProperty("ClosePrice")}");
        }
    }
    catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); }

    Console.WriteLine($"Reconnecting in {delayMs}ms…");
    await Task.Delay(delayMs);
    delayMs = Math.Min(delayMs * 2, 30_000);
}

// Java — auto-reconnect with exponential back-off
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;

public class WsReconnect extends WebSocketClient {
    private int delayMs = 1_000;

    public WsReconnect(URI uri) { super(uri); }

    @Override public void onOpen(ServerHandshake h) {
        System.out.println("Connected");
        delayMs = 1_000;
    }
    @Override public void onMessage(String msg) { System.out.println(msg); }

    @Override public void onClose(int c, String reason, boolean remote) {
        System.out.println("Closed: " + reason + ". Reconnecting in " + delayMs + "ms…");
        new Thread(() -> {
            try { Thread.sleep(delayMs); } catch (InterruptedException ignored) {}
            delayMs = Math.min(delayMs * 2, 30_000);
            reconnect();
        }).start();
    }
    @Override public void onError(Exception e) { e.printStackTrace(); }
}

# Ruby — auto-reconnect with exponential back-off
require 'websocket-client-simple'
require 'json'

API_KEY   = 'YOUR_API_KEY'
SYMBOL    = 'XAUUSD'
TIMEFRAME = 'M1'
URL = "wss://api.realmarketapi.com/price?apiKey=#{API_KEY}&symbolCode=#{SYMBOL}&timeFrame=#{TIMEFRAME}"

delay = 1.0
loop do
  begin
    ws = WebSocket::Client::Simple.connect(URL)
    ws.on(:open)    { delay = 1.0; puts 'Connected' }
    ws.on(:message) do |msg|
      candle = JSON.parse(msg.data)
      puts "#{candle['SymbolCode']} #{candle['ClosePrice']}"
    end
    ws.on(:close) { puts 'Disconnected' }
    sleep 1 while ws.open?
  rescue => e
    puts "Error: #{e.message}"
  end
  puts "Reconnecting in #{delay}s…"
  sleep delay
  delay = [delay * 2, 30.0].min
end

// Dart — auto-reconnect with exponential back-off
import 'dart:io';
import 'dart:convert';

const apiKey    = 'YOUR_API_KEY';
const symbol    = 'XAUUSD';
const timeFrame = 'M1';
const url = 'wss://api.realmarketapi.com/price?apiKey=$apiKey&symbolCode=$symbol&timeFrame=$timeFrame';

Future<void> main() async {
  var delayMs = 1000;
  while (true) {
    try {
      final ws = await WebSocket.connect(url);
      print('Connected');
      delayMs = 1000;
      await for (final message in ws) {
        final candle = jsonDecode(message as String) as Map<String, dynamic>;
        print('${candle['SymbolCode']} ${candle['ClosePrice']}');
      }
    } catch (e) {
      print('Error: $e');
    }
    print('Reconnecting in ${delayMs}ms…');
    await Future.delayed(Duration(milliseconds: delayMs));
    delayMs = (delayMs * 2).clamp(0, 30000);
  }
}