MetaApi WebSocket Alternative: Streaming MT4/MT5 Prices and Account Data

When building an algorithmic trading model, a prop firm dashboard, or a copy trading app, polling REST endpoints is not enough. Polling for price updates adds the polling interval to every price you see, and polling many symbols across many accounts quickly runs into a per-key rate limit (with MetaTrader API: bursts of 40, then 20 requests per second per key).

You need real-time data streaming.

The MetaApi WebSocket implementation is widely used, but it is built around their proprietary SDKs, which manage state synchronization between their cloud and your backend. For developers who want fewer dependencies and full control over the socket, a MetaApi WebSocket alternative is worth a look.

In this guide, we show how to stream live pricing and account data over a plain WebSocket with a MetaTrader price streaming API like MetaTrader API.

---

1. SDK Streaming vs a Plain WebSocket

Before the code, here is the difference in how you consume the stream.

• The SDK Way: Your Node.js or Python app receives updates through the provider's SDK listener, which keeps its own synchronized copy of the account state.
• The Plain WebSocket Way: You open one standard wss:// connection per account and receive JSON frames (QUOTE, POSITIONS, ORDERS, TRADE, HEARTBEAT) straight into your backend. There is nothing to install on your side and no EA for you to run.

Streaming architecture: WebSockets provide the real-time trigger for rapid REST execution.

---

2. Streaming Live Prices (Tick Data)

Whether you are building an MT4 WebSocket API integration or an MT5 WebSocket API integration, MetaTrader API delivers the same frame format.

To stream live prices, you do not need an SDK. Connect the account once in the dashboard, then open one standard WebSocket per account with your API key and account id, and subscribe to the symbols you want.

Endpoint Example (JavaScript / Node.js):

// Node 22 has a global WebSocket; on Node 18–20: npm i ws
const ws = new WebSocket(`wss://api.metatraderapi.net/v1/stream?apiKey=YOUR_API_KEY&id=YOUR_ACCOUNT_ID`);

ws.onopen = () => {
  console.log('Connected to the price stream');
  ws.send(JSON.stringify({ action: 'subscribe', symbol: 'EURUSD' }));   // quotes need a subscription
};

ws.onmessage = (m) => {
  const frame = JSON.parse(m.data);            // { type: 'QUOTE' | 'POSITIONS' | 'TRADE', data: ... }
  if (frame.type !== 'QUOTE') return;
  const tick = frame.data;
  // Output: EURUSD - Bid: 1.08502 | Ask: 1.08505
  console.log(`${tick.symbol} - Bid: ${tick.bid} | Ask: ${tick.ask}`);
};

A price change is pushed to your backend as it arrives (at most one QUOTE frame every 200 ms per symbol), with no polling loop. WebSocket streaming is included in every MetaTrader API seat, with no premium tier or add-on fee for real-time data.

---

3. Streaming Account State and Order Updates

For prop firm dashboards or copy trading platforms, live pricing is only half the battle. You also need to know when a trade is executed, hits a stop loss, or is modified.

Instead of running continuous REST loops against /AccountSummary and /OpenedOrders, listen to the same WebSocket: every executed deal arrives as a TRADE frame (with magic, comment, commission, swap, profit and the position it belongs to), and every change of the open positions as a POSITIONS frame. No subscription is needed for these: they are always sent. Position changes and new deals are picked up about once per second.

Endpoint Example (Python):

import asyncio
import json
import os
import websockets   # pip install "websockets>=14"

async def stream_order_updates(api_key, account_id):
    uri = f"wss://api.metatraderapi.net/v1/stream?id={account_id}"
    delay = 1
    while True:                                   # reconnect with backoff: 1, 2, 4 ... 30 s
        try:
            async with websockets.connect(uri, additional_headers={"x-api-key": api_key}) as ws:
                delay = 1
                print("Listening for trade events...")
                async for raw in ws:
                    frame = json.loads(raw)
                    if frame["type"] == "TRADE":
                        deal = frame["data"]
                        # Example logic for a copy trading master account
                        print(f"Master executed a deal on {deal['symbol']}. Triggering follower accounts...")
                        # Trigger parallel /OrderSend REST requests here
                    elif frame["type"] == "POSITIONS":
                        print("Open positions changed:", len(frame["data"]))
        except (websockets.ConnectionClosed, OSError) as e:
            print(f"stream closed ({e}), reconnecting in {delay}s")
        await asyncio.sleep(delay)
        delay = min(delay * 2, 30)

asyncio.run(stream_order_updates(os.environ["MTAPI_KEY"], os.environ["MTAPI_ID"]))

With this event-driven design your backend stays idle until an actionable event arrives, instead of spending requests on polling.

---

Conclusion: Upgrade Your Streaming Architecture

If your application depends on streaming, a plain MetaTrader price streaming API gives you raw wss:// endpoints and full control over how connections are opened, reconnected and scaled, without an SDK in between.

Already using MetaApi and considering a switch?

👉 Contact us and our engineers will look at your current setup and show you how your WebSocket streams map to MetaTrader API.

---