How to Become a Forex Signal Provider Without Writing a Single Line of MQL5

Step-by-step guide to becoming a MetaTrader signal provider using a REST API — no MQL5 required. Connect your MT4/MT5 account, detect trades in real time, and broadcast signals to subscribers with Python.

Published: June 2026 · Category: Signal Providers · Read time: ~11 min

Target URL: https://www.metatraderapi.net/blog/how-to-become-a-forex-signal-provider/

So you have a profitable trading strategy on MetaTrader. Your EURUSD scalp just hit TP again. Your drawdown has barely touched 4% this month. Friends are already asking: "Can I just copy your trades?"

You've heard of becoming a signal provider on MQL5.com — but that path means passing a verification process, paying listing fees, and being locked inside MetaQuotes' own ecosystem. Worse, if you want to run your own copy trading service, collect subscription fees yourself, or build any kind of product around your signals, MQL5's marketplace won't help you at all.

There is a better way. In 2025, you can become a fully independent forex signal provider using nothing but a REST API and about 60 lines of Python. No MQL5. No Expert Advisors. No MetaQuotes approval process. You own the infrastructure, the subscriber list, and the revenue.

This guide shows you exactly how — using real, working API endpoints from MetaTrader API.

What "Signal Provider" Actually Means (Technically)

A signal provider is simply a trader whose order activity — opens, closes, modifications — gets detected the moment it happens and transmitted to a list of subscriber accounts that then replicate the same trade.

The traditional way: write an Expert Advisor in MQL5 that runs inside the MT5 terminal, monitors the account, and sends data somewhere.

The modern way: connect to your MT5 account from outside the terminal via a REST API and WebSocket. Your strategy stays exactly as-is. The API watches your account in real time. When a trade fires, your server broadcasts it to however many subscriber accounts you have.

This is what MetaTrader API was built for.

What You Will Build

By the end of this guide, you will have a working signal provider backend that:

1. Connects to your master MT5 account via the MetaTrader API REST API

2. Listens for real-time trade events over a WebSocket connection

3. Detects every new order open, modification, and close the instant it happens

4. Broadcasts the signal to subscriber accounts (or a Telegram bot, webhook, email — your choice)

You will not need to install anything inside MetaTrader. No EA, no DLL, no special broker permission.

Prerequisites

• A MetaTrader 4 or MetaTrader 5 trading account (demo or live)

• An MetaTrader API account (flat-rate plans for developers and teams)

• Python 3.9+ with requests and websocket-client installed

• Your MT5 account number, password, and server name

Step 1 — Connect Your MT4/MT5 Account via /ConnectEx

The MetaTrader API REST API authenticates with your service credentials (HTTP Basic Auth) and then connects to your MT5 account using the /ConnectEx endpoint. This returns a session token (UUID) that you pass in every subsequent request.

import requests
from uuid import uuid4

# MetaTrader API service credentials — available in your dashboard after sign-up
# See: https://app.metatraderapi.net/docs
API_BASE = "https://YOUR_MetaTrader API_ENDPOINT" # provided on signup
API_USER = "your_api2trade_username"
API_PASS = "your_api2trade_password"

# Your MetaTrader 5 account details
MT5_LOGIN = 62333850 # your MT5 account number
MT5_PASS = "your_mt5_pass"
MT5_SERVER = "MetaQuotes-Demo" # server name as shown in MT5 terminal

# Generate a session ID — save this to reconnect later without re-authenticating
SESSION_ID = str(uuid4())

def connect_account():
 resp = requests.get(
 f"{API_BASE}/ConnectEx",
 auth=(API_USER, API_PASS),
 params={
 "user": MT5_LOGIN,
 "password": MT5_PASS,
 "server": MT5_SERVER,
 "id": SESSION_ID,
 }
 )
 resp.raise_for_status()
 print(f"Connected. Session ID: {SESSION_ID}")
 return SESSION_ID

session_id = connect_account()

Tip: Save SESSION_ID to a database or .env file. On future restarts you can call /ConnectByToken?id=SESSION_ID to restore the session without sending credentials again.

For MT4 accounts, your API_BASE will point to the MT4 endpoint — both are provided in your MetaTrader API dashboard after sign-up. The endpoint structure is identical across MT4 and MT5.

Step 2 — Enable Order Update Subscriptions

Before you open the WebSocket, you need to tell the API that you want to receive order update events. This is a one-time REST call using /SubscribeOrderUpdate:

def subscribe_order_updates(session_id):
 resp = requests.get(
 f"{API_BASE}/SubscribeOrderUpdate",
 auth=(API_USER, API_PASS),
 params={"id": session_id}
 )
 resp.raise_for_status()
 print("Order update subscription active.")

subscribe_order_updates(session_id)

You only need to call this once per session. From this point forward, every trade action on your master account — every open, every close, every SL/TP modification — will push a JSON event to the WebSocket.

Step 3 — Listen on the WebSocket for Real-Time Trade Events

This is where the magic happens. MetaTrader API provides a secure wss:// endpoint that streams all subscribed events as JSON in real time. For signal providers, the key WebSocket channel is OnOrderUpdate — the full endpoint URL is provided in your MetaTrader API dashboard after sign-up.

Authentication uses the same Basic Auth credentials, passed as a header on the WebSocket upgrade request.

import websocket
import json
import base64

def on_message(ws, message):
 event = json.loads(message)
 event_type = event.get("type")

 if event_type == "OnOrderUpdate":
 ticket = event.get("ticket")
 symbol = event.get("symbol")
 action = event.get("action") # "open", "close", "modify"
 volume = event.get("volume")
 price = event.get("price")

 print(f"[SIGNAL] {action.upper()} {symbol} | Vol: {volume} | Price: {price} | Ticket: {ticket}")
 broadcast_signal(event) # → your subscriber logic here

def on_error(ws, error):
 print(f"WebSocket error: {error}")

def on_close(ws, close_status_code, close_msg):
 print("WebSocket closed — reconnecting in 5s...")

def start_websocket(session_id):
 credentials = f"{API_USER}:{API_PASS}"
 b64 = base64.b64encode(credentials.encode()).decode()

 # WebSocket URL is provided in your MetaTrader API dashboard after sign-up
 ws_url = f"{API_BASE.replace('https://', 'wss://')}/OnOrderUpdate?id={session_id}"

 ws = websocket.WebSocketApp(
 ws_url,
 header={"Authorization": f"Basic {b64}"},
 on_message=on_message,
 on_error=on_error,
 on_close=on_close,
 )
 ws.run_forever(reconnect=5) # auto-reconnect every 5 seconds on disconnect

start_websocket(session_id)

When your master account opens a trade, on_message fires immediately with a payload like this:

{
 "type": "OnOrderUpdate",
 "ticket": 182334901,
 "symbol": "EURUSD",
 "action": "open",
 "volume": 0.50,
 "price": 1.08145,
 "stopLoss": 1.07890,
 "takeProfit": 1.08640,
 "comment": "my strategy"
}

Step 4 — Verify Account Status Before Broadcasting

Before replicating any signal to a subscriber account, it is good practice to verify the subscriber's account is healthy and has sufficient margin. Use /AccountSummary:

def get_account_summary(subscriber_session_id):
 resp = requests.get(
 f"{API_BASE}/AccountSummary",
 auth=(API_USER, API_PASS),
 params={"id": subscriber_session_id}
 )
 data = resp.json()
 return {
 "balance": data.get("balance"),
 "equity": data.get("equity"),
 "freeMargin": data.get("freeMargin"),
 "marginLevel": data.get("marginLevel"),
 }

summary = get_account_summary(subscriber_session_id)
print(f"Subscriber balance: {summary['balance']} | Free Margin: {summary['freeMargin']}")

A robust signal service will skip replication if freeMargin is below a threshold, protecting your subscribers from margin calls. This is exactly the kind of risk logic you can build into your own service — something the MQL5 marketplace can never offer you because it runs on their rails, not yours.

Step 5 — Execute the Replicated Trade on the Subscriber Account

Once you've verified the subscriber's account, use /OrderSendSafe to execute the replicated trade:

def replicate_signal(subscriber_session_id, signal):
 """Replicate a master trade to a subscriber account with proportional sizing."""
 # Example: subscriber uses 25% of master volume
 adjusted_volume = round(signal["volume"] * 0.25, 2)

 resp = requests.get(
 f"{API_BASE}/OrderSendSafe",
 auth=(API_USER, API_PASS),
 params={
 "id": subscriber_session_id,
 "symbol": signal["symbol"],
 "operation": signal["action"].capitalize(), # "Buy" or "Sell"
 "volume": adjusted_volume,
 "stoploss": signal.get("stopLoss", 0),
 "takeprofit": signal.get("takeProfit", 0),
 "comment": f"Signal copy — master #{signal['ticket']}",
 }
 )
 result = resp.json()
 print(f"Trade placed on subscriber account: {result}")
 return result

Note on MT4: For MT4 accounts, use /OrderSend instead of /OrderSendSafe. The parameter names are identical. See the MetaTrader API documentation for the full MT4 vs MT5 comparison.

The Full Architecture at a Glance

Here is the complete signal provider system you now have:

┌─────────────────────────────────────────────────────────┐
│ MASTER ACCOUNT (You) │
│ MT5 Live/Demo Account → MetaTrader API /ConnectEx │
│ /SubscribeOrderUpdate │
└──────────────────────┬──────────────────────────────────┘
 │ WebSocket: wss://.../OnOrderUpdate
 ▼
┌─────────────────────────────────────────────────────────┐
│ YOUR SIGNAL SERVER (Python) │
│ Receives OnOrderUpdate events in real time │
│ Applies risk filter (margin check, lot sizing) │
│ Calls /OrderSendSafe on each subscriber session │
└──────┬────────────────┬───────────────┬─────────────────┘
 ▼ ▼ ▼
 Subscriber A Subscriber B Subscriber C
 (0.25x lots) (0.50x lots) (1.00x lots)

Each subscriber can have their own lot multiplier, risk cap, or symbol filter. This is your system. You control everything.

What About Getting Paid?

This is where running your own signal service genuinely beats MQL5.

With MQL5, you get a fixed subscription fee split 70/30 — you keep 70%, MetaQuotes keeps 30%. And you cannot charge performance fees, PAMM-style profit share, or tiered pricing.

With your own API-based signal service, you can:

• Charge a monthly subscription (Stripe, PayPal, crypto — your choice)

• Charge a performance fee (e.g., 20% of profits)

• Offer a free tier (e.g., 1-hour delayed signals) and a premium tier (real-time)

• Build a subscriber dashboard that shows performance stats, live equity, drawdown history

All of this is possible because you have programmatic access to /TradeStats, /EquityHistory, and /OpenedOrders for any connected account. You can build a leaderboard, a subscriber portal, or a Telegram bot — anything.

For the dashboard and account automation side of this, see our guide: How Brokers Automate Account Management with MetaTrader API →

Monitoring Your Master Account's Open Positions

Your subscribers want to see what is currently open on your account — before they sign up. Use /OpenedOrders to expose this in real time:

def get_open_positions(session_id):
 resp = requests.get(
 f"{API_BASE}/OpenedOrders",
 auth=(API_USER, API_PASS),
 params={"id": session_id}
 )
 return resp.json()

positions = get_open_positions(session_id)
for pos in positions:
 print(f"{pos['symbol']} | {pos['type']} | Volume: {pos['volume']} | P/L: {pos['profit']}")

This data powers your public-facing "live performance" widget. Embed it on your website, Telegram channel, or Discord server to attract subscribers.

MQL5 Marketplace vs. Your Own Signal Service: A Real Comparison

| Feature | MQL5 Marketplace | Your Own API Service |

| Revenue share | 70% to you | 100% to you |

| Performance fees | ❌ Not supported | ✅ Full control |

| Subscriber data/emails | ❌ You don't own them | ✅ Your database |

| Custom lot sizing per subscriber | ❌ Fixed | ✅ Per-subscriber |

| Your own branding/domain | ❌ MQL5 brand | ✅ Yours |

| Requires MQL5 approval | ✅ Yes | ❌ None |

| EA installation required | ✅ Often yes | ❌ Never |

| MT4 + MT5 support | Limited | ✅ Both |

| Build custom subscriber dashboard | ❌ | ✅ |

Going Further: Adding WebSocket Quote Streaming

If your signal service also wants to show live prices or market data to subscribers — perhaps to display the current spread before copying a trade — you can stream real-time quotes using /Subscribe + the OnQuote WebSocket:

# Subscribe to EURUSD tick data (interval: 500ms)
requests.get(
 f"{API_BASE}/Subscribe",
 auth=(API_USER, API_PASS),
 params={"id": session_id, "symbol": "EURUSD", "interval": 500}
)

# Then open the OnQuote WebSocket channel (URL provided in your MetaTrader API dashboard)
# Events look like:
# {"type": "OnQuote", "symbol": "EURUSD", "bid": 1.08145, "ask": 1.08157, "time": "..."}

For multiple symbols at once, use /SubscribeMany with repeated symbol parameters:

GET /SubscribeMany?id=SESSION_ID&symbol=EURUSD&symbol=GBPUSD&symbol=XAUUSD&interval=500

This is how you build a live market data feed into your subscriber dashboard — without paying a separate data vendor. For a deeper dive into real-time streaming and low-latency architecture, see: Low-Latency MetaTrader Infrastructure for Brokers →

Common Questions

Can I use this with a prop firm funded account?

Yes, as long as your prop firm provides you with the MT5 login credentials and server name. You are connecting to the account as the account holder — the MetaTrader API service acts as a bridge. For prop firm-specific compliance monitoring and rule enforcement, see: Build Prop Firm Rule Enforcement on MetaTrader Accounts →

What if my subscribers use different brokers?

Each subscriber connects their own MT4/MT5 account to your server using their own MetaTrader API session. The account can be at any broker on any server — the API is broker-agnostic. You simply call /OrderSendSafe on each subscriber's session with the correct symbol name for their broker (e.g., EURUSD vs EURUSD.m).

Is this legal? Am I acting as an unregulated fund manager?

Signal providing — where subscribers manually choose to replicate trades and control their own account — is generally treated differently from fund management across most jurisdictions. However, regulatory rules vary by country. Always consult a financial compliance advisor before charging subscribers for signals. This guide covers the technical implementation only.

Can I add AI to this?

Yes. Because your signal data flows through your own Python server, you can insert any AI layer between the master account event and the subscriber execution. For a complete example of adding OpenAI-based analysis to a MetaTrader pipeline, see: How to Build an AI Forex Trading Bot →

Related Reading

If you found this useful, these guides on the MetaTrader API blog take the next steps further:

• MT5 API for Prop Trading Firms: Challenge Automation — Automate onboarding and account monitoring for challenge participants

• Build a Reliable Forex & CFD Scalping Bot with MetaTrader API — Add automated execution to your signal strategy

• MetaTrader API & CRM Integration: Salesforce Workflow Guide — Sync your subscriber data into a CRM

• Forex Broker API Integration: A Complete Developer Guide — If you want to go further and build your own brokerage layer

External resources:

• MetaTrader 5 Python Package documentation — The official MT5 Python library (local terminal only, no cloud)
• WebSocket RFC 6455 — The WebSocket standard that underpins the OnOrderUpdate stream
• ESMA Guidelines on Copy Trading — Regulatory context for European signal providers

Start Building Your Signal Service Today

Everything in this guide runs on the MetaTrader API REST API. You can be connected to your MT5 account and receiving live order events in under 10 minutes.

→ Get API access at app.metatraderapi.net

→ Read the full API documentation

→ Browse all developer guides on the MetaTrader API Blog

No Expert Advisors. No MQL5. No MetaQuotes approval process.

Just your strategy, a REST API, and complete control over your signal business.

MetaTrader®, MT4® and MT5® are registered trademarks of MetaQuotes Ltd. MetaTrader API is an independent service and is not affiliated with, authorized by, or endorsed by MetaQuotes.

FAQ

Do I need MQL5 to become a MetaTrader signal provider?

No. Using a REST API like MetaTrader API, you can detect and broadcast your MT4/MT5 trades in real time using Python, Node.js, or any HTTP-capable language — without installing any Expert Advisor or writing MQL5 code.

How does the MetaTrader API signal provider setup work?

You connect your MT5 account via /ConnectEx, subscribe to order updates via /SubscribeOrderUpdate, then listen to the MetaTrader API OnOrderUpdate WebSocket channel to receive real-time trade events. Your server then broadcasts those events to subscribers. Full endpoint details are provided in your dashboard after sign-up.

Can I become a signal provider on MT4 and MT5?

Yes. MetaTrader API supports both MetaTrader 4 and MetaTrader 5 with identical endpoint and WebSocket structures. Your platform-specific base URL is provided in your MetaTrader API dashboard after sign-up.

How do I get started with the MetaTrader API REST API?

You can sign up for an account at app.metatraderapi.net and choose a suitable plan to get your API credentials immediately.