Forex Trading Bot Development: Complete Guide for MT4/MT5

MetaTrader Platform Architecture

//+------------------------------------------------------------------+
//|                                          ForexTradingBot.mq4     |
//|                                   Professional EA Template        |
//+------------------------------------------------------------------+
#property copyright "Your Company"
#property version   "1.00"
#property strict

// Input Parameters
input double LotSize = 0.1;           // Trading Lot Size
input int StopLoss = 50;              // Stop Loss in Pips
input int TakeProfit = 100;           // Take Profit in Pips
input int MAPeriod = 14;              // Moving Average Period
input int RSIPeriod = 14;             // RSI Period
input int MagicNumber = 12345;        // EA Magic Number

// Global Variables
double pips;
int slippage = 3;

//+------------------------------------------------------------------+
//| Expert initialization function                                     |
//+------------------------------------------------------------------+
int OnInit()
{
    // Calculate pip value based on symbol digits
    if(Digits == 5 || Digits == 3)
        pips = Point * 10;
    else
        pips = Point;
        
    Print("Forex Trading Bot initialized successfully");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                   |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    Print("Forex Trading Bot stopped. Reason: ", reason);
}

//+------------------------------------------------------------------+
//| Expert tick function - called on every price change               |
//+------------------------------------------------------------------+
void OnTick()
{
    // Check if trading is allowed
    if(!IsTradeAllowed()) return;
    
    // Check for existing orders
    if(CountOrders() > 0) return;
    
    // Calculate indicators
    double ma = iMA(Symbol(), 0, MAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
    double rsi = iRSI(Symbol(), 0, RSIPeriod, PRICE_CLOSE, 0);
    
    // Buy Signal: Price above MA and RSI below 30
    if(Ask > ma && rsi < 30)
    {
        OpenBuyOrder();
    }
    
    // Sell Signal: Price below MA and RSI above 70
    if(Bid < ma && rsi > 70)
    {
        OpenSellOrder();
    }
}

//+------------------------------------------------------------------+
//| Open Buy Order Function                                            |
//+------------------------------------------------------------------+
void OpenBuyOrder()
{
    double sl = Ask - StopLoss * pips;
    double tp = Ask + TakeProfit * pips;
    
    int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 
                          slippage, sl, tp, 
                          "Forex Bot Buy", MagicNumber, 0, clrGreen);
    
    if(ticket < 0)
        Print("Buy order failed. Error: ", GetLastError());
    else
        Print("Buy order opened. Ticket: ", ticket);
}

//+------------------------------------------------------------------+
//| Open Sell Order Function                                           |
//+------------------------------------------------------------------+
void OpenSellOrder()
{
    double sl = Bid + StopLoss * pips;
    double tp = Bid - TakeProfit * pips;
    
    int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 
                          slippage, sl, tp, 
                          "Forex Bot Sell", MagicNumber, 0, clrRed);
    
    if(ticket < 0)
        Print("Sell order failed. Error: ", GetLastError());
    else
        Print("Sell order opened. Ticket: ", ticket);
}

//+------------------------------------------------------------------+
//| Count Open Orders Function                                         |
//+------------------------------------------------------------------+
int CountOrders()
{
    int count = 0;
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                count++;
        }
    }
    return count;
}

//+------------------------------------------------------------------+
//|                                          ForexBotMT5.mq5          |
//|                              Professional MT5 Expert Advisor      |
//+------------------------------------------------------------------+
#property copyright "Your Company"
#property version   "1.00"

#include 
#include 
#include 

// Input Parameters
input group "Trading Settings"
input double InpLotSize = 0.1;        // Lot Size
input int InpStopLoss = 50;           // Stop Loss (points)
input int InpTakeProfit = 100;        // Take Profit (points)

input group "Indicator Settings"
input int InpFastMA = 12;             // Fast MA Period
input int InpSlowMA = 26;             // Slow MA Period
input int InpRSIPeriod = 14;          // RSI Period

// Global Objects
CTrade trade;
CPositionInfo positionInfo;
CSymbolInfo symbolInfo;

// Indicator Handles
int handleFastMA;
int handleSlowMA;
int handleRSI;

//+------------------------------------------------------------------+
//| Expert initialization function                                     |
//+------------------------------------------------------------------+
int OnInit()
{
    // Initialize symbol info
    if(!symbolInfo.Name(_Symbol))
    {
        Print("Failed to initialize symbol info");
        return(INIT_FAILED);
    }
    
    // Create indicator handles
    handleFastMA = iMA(_Symbol, PERIOD_CURRENT, InpFastMA, 0, MODE_EMA, PRICE_CLOSE);
    handleSlowMA = iMA(_Symbol, PERIOD_CURRENT, InpSlowMA, 0, MODE_EMA, PRICE_CLOSE);
    handleRSI = iRSI(_Symbol, PERIOD_CURRENT, InpRSIPeriod, PRICE_CLOSE);
    
    if(handleFastMA == INVALID_HANDLE || handleSlowMA == INVALID_HANDLE || handleRSI == INVALID_HANDLE)
    {
        Print("Failed to create indicator handles");
        return(INIT_FAILED);
    }
    
    // Set trade parameters
    trade.SetExpertMagicNumber(123456);
    trade.SetDeviationInPoints(10);
    trade.SetTypeFilling(ORDER_FILLING_IOC);
    
    Print("Bot Forex MT5 initialized successfully");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                               |
//+------------------------------------------------------------------+
void OnTick()
{
    // Check for new bar
    if(!IsNewBar()) return;
    
    // Update symbol info
    symbolInfo.RefreshRates();
    
    // Get indicator values
    double fastMA[], slowMA[], rsi[];
    ArraySetAsSeries(fastMA, true);
    ArraySetAsSeries(slowMA, true);
    ArraySetAsSeries(rsi, true);
    
    CopyBuffer(handleFastMA, 0, 0, 3, fastMA);
    CopyBuffer(handleSlowMA, 0, 0, 3, slowMA);
    CopyBuffer(handleRSI, 0, 0, 3, rsi);
    
    // Check for open positions
    if(PositionsTotal() > 0) return;
    
    // Buy Signal: Fast MA crosses above Slow MA, RSI below 70
    if(fastMA[1] > slowMA[1] && fastMA[2] <= slowMA[2] && rsi[1] < 70)
    {
        ExecuteBuy();
    }
    
    // Sell Signal: Fast MA crosses below Slow MA, RSI above 30
    if(fastMA[1] < slowMA[1] && fastMA[2] >= slowMA[2] && rsi[1] > 30)
    {
        ExecuteSell();
    }
}

//+------------------------------------------------------------------+
//| Execute Buy Order                                                  |
//+------------------------------------------------------------------+
void ExecuteBuy()
{
    double ask = symbolInfo.Ask();
    double sl = ask - InpStopLoss * symbolInfo.Point();
    double tp = ask + InpTakeProfit * symbolInfo.Point();
    
    if(trade.Buy(InpLotSize, _Symbol, ask, sl, tp, "MT5 Bot Buy"))
        Print("Buy order executed successfully");
    else
        Print("Buy order failed: ", trade.ResultRetcodeDescription());
}

//+------------------------------------------------------------------+
//| Execute Sell Order                                                 |
//+------------------------------------------------------------------+
void ExecuteSell()
{
    double bid = symbolInfo.Bid();
    double sl = bid + InpStopLoss * symbolInfo.Point();
    double tp = bid - InpTakeProfit * symbolInfo.Point();
    
    if(trade.Sell(InpLotSize, _Symbol, bid, sl, tp, "MT5 Bot Sell"))
        Print("Sell order executed successfully");
    else
        Print("Sell order failed: ", trade.ResultRetcodeDescription());
}

//+------------------------------------------------------------------+
//| Check for new bar                                                  |
//+------------------------------------------------------------------+
bool IsNewBar()
{
    static datetime lastBarTime = 0;
    datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
    
    if(currentBarTime != lastBarTime)
    {
        lastBarTime = currentBarTime;
        return true;
    }
    return false;
}

//+------------------------------------------------------------------+
//| Calculate Dynamic Lot Size Based on Risk Percentage              |
//+------------------------------------------------------------------+
double CalculateLotSize(double riskPercent, int stopLossPips)
{
    double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount = accountBalance * (riskPercent / 100);
    
    // Get tick value for the symbol
    double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    
    // Calculate pip value
    double pipValue = tickValue * (point / tickSize);
    
    // Calculate lot size
    double lotSize = riskAmount / (stopLossPips * pipValue);
    
    // Apply lot constraints
    double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    
    // Normalize lot size
    lotSize = MathFloor(lotSize / lotStep) * lotStep;
    lotSize = MathMax(minLot, MathMin(maxLot, lotSize));
    
    return NormalizeDouble(lotSize, 2);
}

//+------------------------------------------------------------------+
//| Check Maximum Drawdown and Adjust Trading                        |
//+------------------------------------------------------------------+
bool CheckDrawdownLimit(double maxDrawdownPercent)
{
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double equity = AccountInfoDouble(ACCOUNT_EQUITY);
    
    double currentDrawdown = ((balance - equity) / balance) * 100;
    
    if(currentDrawdown >= maxDrawdownPercent)
    {
        Print("Maximum drawdown reached: ", currentDrawdown, "%");
        return false;  // Stop trading
    }
    
    return true;  // Continue trading
}

//+------------------------------------------------------------------+
//| Daily Loss Limit Check                                            |
//+------------------------------------------------------------------+
bool CheckDailyLossLimit(double maxDailyLossPercent)
{
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double dailyProfit = 0;
    
    datetime todayStart = StringToTime(TimeToString(TimeCurrent(), TIME_DATE));
    
    // Calculate today's closed profit/loss
    HistorySelect(todayStart, TimeCurrent());
    int totalDeals = HistoryDealsTotal();
    
    for(int i = 0; i < totalDeals; i++)
    {
        ulong ticket = HistoryDealGetTicket(i);
        dailyProfit += HistoryDealGetDouble(ticket, DEAL_PROFIT);
    }
    
    double dailyLossPercent = (dailyProfit / balance) * 100;
    
    if(dailyLossPercent <= -maxDailyLossPercent)
    {
        Print("Daily loss limit reached: ", dailyLossPercent, "%");
        return false;
    }
    
    return true;
}

// Moving Average Crossover Signal Detection
int GetMACrossSignal(int fastPeriod, int slowPeriod)
{
    double fastMA_current = iMA(_Symbol, PERIOD_CURRENT, fastPeriod, 0, MODE_EMA, PRICE_CLOSE, 0);
    double fastMA_prev = iMA(_Symbol, PERIOD_CURRENT, fastPeriod, 0, MODE_EMA, PRICE_CLOSE, 1);
    double slowMA_current = iMA(_Symbol, PERIOD_CURRENT, slowPeriod, 0, MODE_EMA, PRICE_CLOSE, 0);
    double slowMA_prev = iMA(_Symbol, PERIOD_CURRENT, slowPeriod, 0, MODE_EMA, PRICE_CLOSE, 1);
    
    // Bullish crossover
    if(fastMA_current > slowMA_current && fastMA_prev <= slowMA_prev)
        return 1;  // Buy signal
    
    // Bearish crossover
    if(fastMA_current < slowMA_current && fastMA_prev >= slowMA_prev)
        return -1;  // Sell signal
    
    return 0;  // No signal
}

//+------------------------------------------------------------------+
//| Multi-Indicator Signal Generator                                  |
//+------------------------------------------------------------------+
int GetMultiIndicatorSignal()
{
    int buySignals = 0;
    int sellSignals = 0;
    
    // EMA Analysis
    double ema20 = iMA(_Symbol, PERIOD_CURRENT, 20, 0, MODE_EMA, PRICE_CLOSE, 0);
    double ema50 = iMA(_Symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE, 0);
    
    if(ema20 > ema50) buySignals++;
    else sellSignals++;
    
    // RSI Analysis
    double rsi = iRSI(_Symbol, PERIOD_CURRENT, 14, PRICE_CLOSE, 0);
    
    if(rsi < 30) buySignals++;
    else if(rsi > 70) sellSignals++;
    
    // MACD Analysis
    double macdMain = iMACD(_Symbol, PERIOD_CURRENT, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 0);
    double macdSignal = iMACD(_Symbol, PERIOD_CURRENT, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 0);
    
    if(macdMain > macdSignal) buySignals++;
    else sellSignals++;
    
    // Stochastic Analysis
    double stochK = iStochastic(_Symbol, PERIOD_CURRENT, 14, 3, 3, MODE_SMA, 0, MODE_MAIN, 0);
    
    if(stochK < 20) buySignals++;
    else if(stochK > 80) sellSignals++;
    
    // Generate final signal (require majority)
    if(buySignals >= 3) return 1;   // Strong buy
    if(sellSignals >= 3) return -1;  // Strong sell
    
    return 0;  // No clear signal
}

//+------------------------------------------------------------------+
//| Check if current time is within trading session                   |
//+------------------------------------------------------------------+
bool IsWithinTradingSession(int startHour, int endHour)
{
    datetime currentTime = TimeCurrent();
    MqlDateTime timeStruct;
    TimeToStruct(currentTime, timeStruct);
    
    int currentHour = timeStruct.hour;
    
    // Handle overnight sessions
    if(startHour < endHour)
    {
        return (currentHour >= startHour && currentHour < endHour);
    }
    else
    {
        return (currentHour >= startHour || currentHour < endHour);
    }
}

//+------------------------------------------------------------------+
//| Check for London/NY overlap - highest volume period              |
//+------------------------------------------------------------------+
bool IsLondonNYOverlap()
{
    return IsWithinTradingSession(13, 17);  // 13:00-17:00 GMT
}

//+------------------------------------------------------------------+
//| Avoid trading during major news releases                          |
//+------------------------------------------------------------------+
bool IsNewsTime()
{
    MqlDateTime timeStruct;
    TimeToStruct(TimeCurrent(), timeStruct);
    
    // Avoid NFP Friday (first Friday of month, around 13:30 GMT)
    if(timeStruct.day_of_week == 5 && timeStruct.day <= 7)
    {
        if(timeStruct.hour >= 12 && timeStruct.hour <= 15)
            return true;
    }
    
    return false;
}