Why is the win rate 79.6% yet the max drawdown still exceeds 50%?

Martingale grid strategies win frequently because the basket closes at a small profit target while losing trades are held and averaged down. However, each consecutive loss triggers a geometrically larger position, so a sustained trend against the grid can accumulate enormous unrealized drawdown before price reverses. The 52.3% max drawdown recorded over 2021–2025 reflects several strong trending periods that pushed the grid to its maximum levels before recovering.

How should I set the grid step for different currency pairs?

Grid step should scale with the pair's average daily range (ADR). A common starting point is 10–15% of the ADR expressed in points; for EURUSD with a 70-pip ADR that suggests a 70–100 pip (700–1000 point) grid step. Tighter steps generate more trades and faster recovery but risk hitting the max-level cap during volatile sessions, whereas wider steps reduce trade frequency and margin usage. Always validate your step against at least one year of historical volatility on the target pair.

Can this EA run on multiple pairs simultaneously without margin conflict?

Yes, the EA uses a unique magic number per pair instance, so positions are tracked independently on each symbol. The critical risk when running multi-pair is aggregate margin: each pair can hold up to InpMaxLevels open positions on both sides simultaneously, and correlated pairs (e.g., EURUSD and GBPUSD) may draw down at the same time. Size InpInitialLot so that worst-case margin across all running instances stays well within 30% of account equity.

What is the effect of changing the martingale multiplier from 2.0 to 1.5?

Reducing the multiplier to 1.5 lowers the lot size at each new grid level, which significantly reduces the worst-case margin requirement and peak drawdown but also increases the number of levels needed to lower the basket break-even price sufficiently. With a 1.5 multiplier you may need more active levels to recover the same adverse move, so InpMaxLevels should be increased accordingly and the take-profit target should be re-calibrated to account for the smaller weighted average gain per closed basket.

Is this strategy suitable for passing a prop-firm challenge with a 10% drawdown limit?

No. The 52.3% maximum drawdown recorded in backtesting far exceeds the 5–10% drawdown limits imposed by most proprietary trading firms. Martingale grid EAs are fundamentally incompatible with hard drawdown rules because a single extended trend can breach those limits before the basket recovers. Traders targeting prop-firm accounts should consider fixed-risk strategies with defined stop-losses rather than open-ended averaging approaches.

Complete .mq5 source code

MQL5 Martingale Grid Strategy: Combined EA Code, Risk & Backtest

This page delivers a complete MQL5 Expert Advisor that fuses a fixed-interval grid with martingale position sizing, enabling recovery from adverse moves by scaling lot size at each grid level. The code, risk analysis, and 2021–2025 backtest data help traders understand both the profit potential and the significant drawdown risks inherent in this approach before deploying on live accounts.

Build a custom MT5 indicator View the MQL5 code

Historical test results

79.6%

Win Rate

52.3%

Max Drawdown

0.74

Sharpe Ratio

2021–2025

Test Period

Past performance is not indicative of future results. Backtest statistics are based on historical data and do not guarantee future profits. Trading involves significant risk of loss. This content is for educational purposes only and does not constitute financial advice.

Strategy logic

Entry conditions

The EA opens an initial Buy and Sell position simultaneously at EA start, establishing a bidirectional grid anchored to the current price. Whenever price moves away from an open position by the defined grid step (in points), a new order is opened in the same direction with the lot size multiplied by the martingale factor, effectively averaging down into the trend. Each new grid level is tracked so the EA never opens duplicate positions at the same price band.

Exit conditions

All positions in one direction are closed as a basket when the combined floating profit of that side reaches the configured take-profit target in account currency. A global stop-loss level expressed as maximum open lots or a hard drawdown percentage triggers a full position close to protect the account from catastrophic loss. The EA then resets and restarts the grid from the new market price.

MQL5 Expert Advisor Code

//+------------------------------------------------------------------+
//|  MartingaleGrid EA — MQL5 Example for pineify.app               |
//|  Combines fixed grid spacing with martingale lot progression     |
//|  DISCLAIMER: High drawdown strategy. Test on demo before live.  |
//+------------------------------------------------------------------+
#property copyright "Pineify.app"
#property version   "1.00"
#property strict

//--- Input parameters
input double   InpInitialLot    = 0.01;   // Initial lot size
input double   InpMartingale    = 2.0;    // Martingale multiplier
input int      InpGridStep      = 500;    // Grid step in points
input double   InpTakeProfitUSD = 20.0;  // Basket take-profit in USD
input double   InpMaxLots       = 5.0;   // Max total lots before emergency close
input int      InpMaxLevels     = 6;     // Maximum grid levels per direction
input int      InpMagic         = 202406; // Magic number

//--- Global variables
double   g_gridBase;
int      g_buyLevels;
int      g_sellLevels;
datetime g_lastBarTime;

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(InpInitialLot <= 0 || InpMartingale < 1.0 || InpGridStep <= 0)
     {
      Print("Invalid input parameters.");
      return INIT_PARAMETERS_INCORRECT;
     }

   g_gridBase    = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   g_buyLevels   = 0;
   g_sellLevels  = 0;
   g_lastBarTime = 0;

   Print("MartingaleGrid EA initialized. Base price: ", g_gridBase);

   //--- Open initial bidirectional positions
   OpenOrder(ORDER_TYPE_BUY,  InpInitialLot);
   OpenOrder(ORDER_TYPE_SELL, InpInitialLot);

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert tick handler                                              |
//+------------------------------------------------------------------+
void OnTick()
  {
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   //--- Check emergency max-lot stop
   if(TotalLots() >= InpMaxLots)
     {
      Print("Max lots reached — closing all positions.");
      CloseAll();
      ResetGrid();
      return;
     }

   //--- Check basket take-profit for buys
   if(BasketProfit(ORDER_TYPE_BUY) >= InpTakeProfitUSD)
     {
      CloseByType(ORDER_TYPE_BUY);
      g_buyLevels = 0;
      OpenOrder(ORDER_TYPE_BUY, InpInitialLot);
     }

   //--- Check basket take-profit for sells
   if(BasketProfit(ORDER_TYPE_SELL) >= InpTakeProfitUSD)
     {
      CloseByType(ORDER_TYPE_SELL);
      g_sellLevels = 0;
      OpenOrder(ORDER_TYPE_SELL, InpInitialLot);
     }

   //--- Add buy grid level when price drops a grid step
   double lowestBuy = LowestOpenPrice(ORDER_TYPE_BUY);
   if(lowestBuy > 0 && (lowestBuy - ask) / _Point >= InpGridStep && g_buyLevels < InpMaxLevels)
     {
      double nextLot = NormalizeLot(InpInitialLot * MathPow(InpMartingale, g_buyLevels));
      OpenOrder(ORDER_TYPE_BUY, nextLot);
      g_buyLevels++;
     }

   //--- Add sell grid level when price rises a grid step
   double highestSell = HighestOpenPrice(ORDER_TYPE_SELL);
   if(highestSell > 0 && (bid - highestSell) / _Point >= InpGridStep && g_sellLevels < InpMaxLevels)
     {
      double nextLot = NormalizeLot(InpInitialLot * MathPow(InpMartingale, g_sellLevels));
      OpenOrder(ORDER_TYPE_SELL, nextLot);
      g_sellLevels++;
     }
  }

//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Print("MartingaleGrid EA removed. Reason: ", reason);
  }

//+------------------------------------------------------------------+
//| Open a market order                                              |
//+------------------------------------------------------------------+
bool OpenOrder(ENUM_ORDER_TYPE type, double lots)
  {
   MqlTradeRequest req = {};
   MqlTradeResult  res = {};

   req.action    = TRADE_ACTION_DEAL;
   req.symbol    = _Symbol;
   req.volume    = lots;
   req.type      = type;
   req.price     = (type == ORDER_TYPE_BUY)
                   ? SymbolInfoDouble(_Symbol, SYMBOL_ASK)
                   : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   req.deviation = 10;
   req.magic     = InpMagic;
   req.comment   = "MartGrid";

   if(!OrderSend(req, res))
     {
      Print("OrderSend failed: ", res.retcode, " ", res.comment);
      return false;
     }
   return true;
  }

//+------------------------------------------------------------------+
//| Close all positions of given type                                |
//+------------------------------------------------------------------+
void CloseByType(ENUM_ORDER_TYPE type)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket) &&
         PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == InpMagic &&
         (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == (ENUM_POSITION_TYPE)type)
        {
         MqlTradeRequest req = {};
         MqlTradeResult  res = {};
         req.action = TRADE_ACTION_DEAL;
         req.symbol = _Symbol;
         req.volume = PositionGetDouble(POSITION_VOLUME);
         req.type   = (type == ORDER_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
         req.price  = (req.type == ORDER_TYPE_BUY)
                      ? SymbolInfoDouble(_Symbol, SYMBOL_ASK)
                      : SymbolInfoDouble(_Symbol, SYMBOL_BID);
         req.deviation = 10;
         req.magic     = InpMagic;
         req.position  = ticket;
         OrderSend(req, res);
        }
     }
  }

//+------------------------------------------------------------------+
//| Close all positions                                              |
//+------------------------------------------------------------------+
void CloseAll()
  {
   CloseByType(ORDER_TYPE_BUY);
   CloseByType(ORDER_TYPE_SELL);
  }

//+------------------------------------------------------------------+
//| Reset grid state and reopen initial positions                    |
//+------------------------------------------------------------------+
void ResetGrid()
  {
   g_gridBase   = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   g_buyLevels  = 0;
   g_sellLevels = 0;
   OpenOrder(ORDER_TYPE_BUY,  InpInitialLot);
   OpenOrder(ORDER_TYPE_SELL, InpInitialLot);
  }

//+------------------------------------------------------------------+
//| Sum floating profit for one direction                            |
//+------------------------------------------------------------------+
double BasketProfit(ENUM_ORDER_TYPE type)
  {
   double profit = 0;
   for(int i = 0; i < PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket) &&
         PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == InpMagic &&
         (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == (ENUM_POSITION_TYPE)type)
         profit += PositionGetDouble(POSITION_PROFIT);
     }
   return profit;
  }

//+------------------------------------------------------------------+
//| Total open lots across all positions                             |
//+------------------------------------------------------------------+
double TotalLots()
  {
   double total = 0;
   for(int i = 0; i < PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket) &&
         PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == InpMagic)
         total += PositionGetDouble(POSITION_VOLUME);
     }
   return total;
  }

//+------------------------------------------------------------------+
//| Lowest open price among buy positions                            |
//+------------------------------------------------------------------+
double LowestOpenPrice(ENUM_ORDER_TYPE type)
  {
   double lowest = DBL_MAX;
   for(int i = 0; i < PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket) &&
         PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == InpMagic &&
         (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == (ENUM_POSITION_TYPE)type)
         lowest = MathMin(lowest, PositionGetDouble(POSITION_PRICE_OPEN));
     }
   return (lowest == DBL_MAX) ? 0 : lowest;
  }

//+------------------------------------------------------------------+
//| Highest open price among sell positions                          |
//+------------------------------------------------------------------+
double HighestOpenPrice(ENUM_ORDER_TYPE type)
  {
   double highest = 0;
   for(int i = 0; i < PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket) &&
         PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == InpMagic &&
         (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == (ENUM_POSITION_TYPE)type)
         highest = MathMax(highest, PositionGetDouble(POSITION_PRICE_OPEN));
     }
   return highest;
  }

//+------------------------------------------------------------------+
//| Normalize lot to broker minimum step                             |
//+------------------------------------------------------------------+
double NormalizeLot(double lots)
  {
   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   lots = MathMax(minLot, MathRound(lots / lotStep) * lotStep);
   return NormalizeDouble(lots, 2);
  }
//+------------------------------------------------------------------+

Copy this code into MetaEditor, save it in the MQL5/Experts folder, and compile with F7.

Generate a custom Multi-pair martingale-grid EA

Describe the ATR inputs, alert rules, visual style, or confirmation filter you want. Pineify generates editable MQL5 source code that you can inspect and compile in MetaEditor.

Generate custom MQL5 code See the H1 version

Pine Script vs MQL5: Same Strategy, Different Platforms

Aspect	Pine Script (TradingView)	MQL5 (MetaTrader 5)
Execution	Series evaluated on chart updates	Event handlers with explicit buffers
Deployment	Runs in TradingView with alerts	Runs in the MT5 terminal or on a VPS
Broker access	Via TradingView broker integration	Direct broker connectivity
Backtesting	Strategy Tester for strategy scripts	Strategy Tester for Expert Advisors
Code complexity	Simpler, functional syntax	C++-like, more powerful

The calculation can be implemented on either platform, but the runtime model and buffer APIs differ. Read the Pine Script Supertrend reference before porting logic between them.

Frequently Asked Questions

Related MQL5 pages

Mql5 Grid Trading Ea→Mql5 Martingale Ea→Mql5 Hedging Ea→