Building Copy Trading Systems

Copy trading lets followers replicate expert traders automatically. Here's how to build professional systems.

Copy Trading Architecture

System Components:

┌─────────────────┐     ┌──────────────────┐
│  Master Account │────▶│  Signal Server   │
│  (Provider)     │     │  (Distribution)  │
└─────────────────┘     └────────┬─────────┘
                                 │
                    ┌────────────┼────────────┐
                    │            │            │
               ┌────▼────┐ ┌────▼────┐ ┌────▼────┐
               │ Slave 1 │ │ Slave 2 │ │ Slave N │
               │(Follower)│ │(Follower)│ │(Follower)│
               └─────────┘ └─────────┘ └─────────┘

Local Trade Copier (Same VPS)

Master EA (Signal Sender):

#property strict

// File-based communication
string SIGNAL_FILE = "signals.txt";

class CMasterCopier {
private:
    int m_magic;
    string m_signal_file;
    
public:
    CMasterCopier(int magic) {
        m_magic = magic;
        m_signal_file = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Files\\" + SIGNAL_FILE;
    }
    
    void OnTradeTransaction(const MqlTradeTransaction& trans,
                            const MqlTradeRequest& request,
                            const MqlTradeResult& result) {
        // Detect new position
        if(trans.type == TRADE_TRANSACTION_DEAL_ADD) {
            if(trans.deal_type == DEAL_TYPE_BUY || trans.deal_type == DEAL_TYPE_SELL) {
                SendSignal(trans);
            }
        }
        
        // Detect position close
        if(trans.type == TRADE_TRANSACTION_HISTORY_ADD) {
            SendCloseSignal(trans);
        }
    }
    
    void SendSignal(const MqlTradeTransaction& trans) {
        string signal = StringFormat(
            "OPEN|%s|%s|%s|%.5f|%.5f|%.5f|%d",
            trans.symbol,
            trans.deal_type == DEAL_TYPE_BUY ? "BUY" : "SELL",
            DoubleToString(trans.volume, 2),
            trans.price,
            GetStopLoss(trans.position),
            GetTakeProfit(trans.position),
            trans.position
        );
        
        WriteSignalFile(signal);
    }
    
    void WriteSignalFile(string signal) {
        int handle = FileOpen(SIGNAL_FILE, FILE_WRITE|FILE_TXT);
        if(handle != INVALID_HANDLE) {
            FileWriteString(handle, signal);
            FileClose(handle);
        }
    }
};

Slave EA (Signal Receiver):

class CSlaveCopier {
private:
    double m_lot_multiplier;
    string m_signal_file;
    string m_last_signal;
    
public:
    CSlaveCopier(double lot_multiplier = 1.0) {
        m_lot_multiplier = lot_multiplier;
    }
    
    void CheckForSignals() {
        string signal = ReadSignalFile();
        
        if(signal != "" && signal != m_last_signal) {
            ProcessSignal(signal);
            m_last_signal = signal;
        }
    }
    
    void ProcessSignal(string signal) {
        string parts[];
        StringSplit(signal, '|', parts);
        
        string action = parts[0];
        string symbol = parts[1];
        string direction = parts[2];
        double volume = StringToDouble(parts[3]) * m_lot_multiplier;
        double price = StringToDouble(parts[4]);
        double sl = StringToDouble(parts[5]);
        double tp = StringToDouble(parts[6]);
        long master_position = StringToInteger(parts[7]);
        
        if(action == "OPEN") {
            ExecuteTrade(symbol, direction, volume, sl, tp, master_position);
        } else if(action == "CLOSE") {
            ClosePosition(master_position);
        }
    }
    
    void ExecuteTrade(string symbol, string direction, double volume, 
                      double sl, double tp, long master_position) {
        MqlTradeRequest request = {};
        MqlTradeResult result = {};
        
        request.action = TRADE_ACTION_DEAL;
        request.symbol = symbol;
        request.volume = NormalizeLots(symbol, volume);
        request.type = direction == "BUY" ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
        request.price = direction == "BUY" ? 
            SymbolInfoDouble(symbol, SYMBOL_ASK) : 
            SymbolInfoDouble(symbol, SYMBOL_BID);
        request.sl = sl;
        request.tp = tp;
        request.deviation = 10;
        request.magic = 123456;
        request.comment = "Copy_" + IntegerToString(master_position);
        
        OrderSend(request, result);
    }
};

Remote Copy Trading (Multi-VPS)

WebSocket Signal Server (Node.js):

const WebSocket = require('ws');
const http = require('http');

class SignalServer {
    constructor(port) {
        this.server = http.createServer();
        this.wss = new WebSocket.Server({ server: this.server });
        this.masters = new Map();
        this.slaves = new Map();
        
        this.wss.on('connection', (ws, req) => {
            ws.on('message', (message) => this.handleMessage(ws, message));
            ws.on('close', () => this.handleDisconnect(ws));
        });
        
        this.server.listen(port);
    }
    
    handleMessage(ws, message) {
        const data = JSON.parse(message);
        
        switch(data.type) {
            case 'REGISTER_MASTER':
                this.masters.set(data.accountId, ws);
                break;
                
            case 'REGISTER_SLAVE':
                if(!this.slaves.has(data.masterId)) {
                    this.slaves.set(data.masterId, []);
                }
                this.slaves.get(data.masterId).push({
                    ws: ws,
                    multiplier: data.multiplier || 1.0
                });
                break;
                
            case 'SIGNAL':
                this.broadcastSignal(data);
                break;
        }
    }
    
    broadcastSignal(signal) {
        const followers = this.slaves.get(signal.masterId) || [];
        
        followers.forEach(follower => {
            if(follower.ws.readyState === WebSocket.OPEN) {
                const adjustedSignal = {
                    ...signal,
                    volume: signal.volume * follower.multiplier
                };
                follower.ws.send(JSON.stringify(adjustedSignal));
            }
        });
    }
}

const server = new SignalServer(8080);

Risk Management for Copiers

Position Sizing Modes:

enum ENUM_COPY_MODE {
    COPY_FIXED_LOT,        // Fixed lot size
    COPY_MULTIPLIER,       // Multiply master's lots
    COPY_RISK_PERCENT,     // Match risk percentage
    COPY_EQUITY_RATIO      // Based on equity ratio
};

double CalculateCopyLots(double master_lots, double master_equity,
                         double slave_equity, ENUM_COPY_MODE mode,
                         double param) {
    switch(mode) {
        case COPY_FIXED_LOT:
            return param;
            
        case COPY_MULTIPLIER:
            return master_lots * param;
            
        case COPY_RISK_PERCENT:
            // Calculate same risk percentage
            double master_risk_percent = (master_lots * 100000 * 0.0001) / master_equity * 100;
            return (slave_equity * master_risk_percent / 100) / (100000 * 0.0001);
            
        case COPY_EQUITY_RATIO:
            return master_lots * (slave_equity / master_equity);
    }
    return 0.01;
}

Risk Limits:

class CRiskManager {
    double m_max_daily_loss;
    double m_max_drawdown;
    double m_max_position_size;
    
    bool CanOpenTrade(double lots) {
        // Check daily loss
        if(GetTodayProfit() < -m_max_daily_loss) {
            Print("Daily loss limit reached");
            return false;
        }
        
        // Check drawdown
        if(GetCurrentDrawdown() > m_max_drawdown) {
            Print("Max drawdown reached");
            return false;
        }
        
        // Check position size
        if(lots > m_max_position_size) {
            Print("Position too large");
            return false;
        }
        
        return true;
    }
};

Performance Tracking

Copier Statistics:

class CopyTradeStats:
    def __init__(self):
        self.trades = []
    
    def add_trade(self, master_result, slave_result):
        self.trades.append({
            'master_profit': master_result,
            'slave_profit': slave_result,
            'slippage': slave_result - master_result,
            'timestamp': datetime.now()
        })
    
    def get_statistics(self):
        if not self.trades:
            return {}
        
        slippages = [t['slippage'] for t in self.trades]
        
        return {
            'total_trades': len(self.trades),
            'average_slippage': sum(slippages) / len(slippages),
            'max_slippage': max(slippages),
            'copy_accuracy': len([s for s in slippages if abs(s) < 1]) / len(slippages) * 100
        }

Our Copy Trading Solutions

Viprasol develops:

• White-label copy trading platforms
• Custom trade copier EAs
• Signal distribution systems
• Performance analytics dashboards

Need a copy trading system? Contact us to discuss your requirements.