DEV Community: Omais Ali

Building a news filter for an MQL5 EA with the built in economic calendar

Omais Ali — Fri, 30 Oct 2026 06:33:11 +0000

Many Expert Advisors should not open new trades around major economic releases. Spreads widen, prices jump and stops slip. The usual fix is a news filter, and a lot of EAs build one by downloading a calendar from a website with WebRequest and parsing it. That works until the site changes its layout.

MetaTrader 5 already has an economic calendar inside the terminal, with an MQL5 API. This tutorial uses it to block new entries for a few minutes before and after important events for the currencies of the chart symbol.

The two functions we need

CalendarValueHistory() returns the event values in a time range, optionally filtered by country code and currency. Each value is an MqlCalendarValue with an event_id and a time. It returns the number of values found, or minus one on failure.

CalendarEventById() turns an event_id into an MqlCalendarEvent, which holds the name, the importance and the time mode of the event.

One detail matters a lot: all calendar functions work in trade server time. The time field in MqlCalendarValue is server time, so compare it with TimeTradeServer(), not with your local clock.

Deciding whether an event matters

input int  InpSecondsBefore     = 1800;  // block entries 30 minutes before an event
input int  InpSecondsAfter      = 900;   // and 15 minutes after it
input bool InpIncludeModerate   = false; // also block on moderate importance events
input bool InpBlockIfNoCalendar = true;  // block when the calendar cannot be read

bool gNewsBlock = false;
bool gFilterOn  = true;

bool EventMatters(const ulong event_id, string &name)
{
   MqlCalendarEvent ev;
   if(!CalendarEventById(event_id, ev))
      return false;

   // all day and tentative events have no exact time to block around
   if(ev.time_mode != CALENDAR_TIMEMODE_DATETIME)
      return false;

   bool important = (ev.importance == CALENDAR_IMPORTANCE_HIGH) ||
                    (InpIncludeModerate && ev.importance == CALENDAR_IMPORTANCE_MODERATE);
   if(important)
      name = ev.name;
   return important;
}

Checking one currency

An event at time T should block entries from T minus InpSecondsBefore until T plus InpSecondsAfter. Turned around, the EA is blocked right now if any important event falls between now minus InpSecondsAfter and now plus InpSecondsBefore. The inputs are in seconds because datetime values in MQL5 are counted in seconds, so no conversion is needed. That is the range we ask the calendar for.

// 1 = inside a news window, 0 = clear, -1 = calendar could not be read
int CheckCurrency(const string currency, const datetime now, string &why)
{
   MqlCalendarValue values[];
   datetime from = now - InpSecondsAfter;
   datetime to   = now + InpSecondsBefore;

   ResetLastError();
   int n = CalendarValueHistory(values, from, to, NULL, currency);
   if(n < 0)
   {
      PrintFormat("Calendar read failed for %s, error %d", currency, GetLastError());
      return -1;
   }

   for(int i = 0; i < n; i++)
   {
      string name = "";
      if(EventMatters(values[i].event_id, name))
      {
         why = StringFormat("%s: %s at %s", currency, name,
                            TimeToString(values[i].time, TIME_DATE | TIME_MINUTES));
         return 1;
      }
   }
   return 0;
}

Filtering by currency rather than country is deliberate. EUR events come from the euro area and from Germany, France, Italy and others. Asking for currency "EUR" catches all of them.

Updating the block once a minute

There is no need to query the calendar on every tick. A one minute timer is plenty.

void UpdateNewsBlock()
{
   datetime now    = TimeTradeServer();
   string   base   = SymbolInfoString(_Symbol, SYMBOL_CURRENCY_BASE);
   string   profit = SymbolInfoString(_Symbol, SYMBOL_CURRENCY_PROFIT);
   string   why    = "";

   int a = CheckCurrency(base, now, why);
   int b = (profit != base) ? CheckCurrency(profit, now, why) : 0;

   bool block;
   if(a < 0 || b < 0)
   {
      block = InpBlockIfNoCalendar;
      why   = "calendar unavailable";
   }
   else
      block = (a == 1 || b == 1);

   if(block != gNewsBlock)
   {
      if(block)
         Print("News block ON, ", why);
      else
         Print("News block OFF");
      gNewsBlock = block;
   }
}

int OnInit()
{
   if(MQLInfoInteger(MQL_TESTER))
   {
      // the calendar API is not available in the Strategy Tester
      Print("News filter disabled in the tester");
      gFilterOn = false;
      return INIT_SUCCEEDED;
   }
   EventSetTimer(60);
   UpdateNewsBlock();
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
}

void OnTimer()
{
   if(gFilterOn)
      UpdateNewsBlock();
}

Using it in OnTick

The filter should only stop new entries. Trailing stops, breakeven moves and exits keep running during news, because that is exactly when they are needed.

void OnTick()
{
   ManageOpenPositions();      // always runs

   if(gFilterOn && gNewsBlock)
      return;                  // no new entries inside a news window

   CheckForEntry();
}

ManageOpenPositions() and CheckForEntry() stand for your own EA logic.

Things to know before relying on it

The calendar functions do not work in the Strategy Tester. A backtest of this EA runs without the filter, which is why OnInit() says so in the log. If the filter matters to the strategy, export the event times to a file and read that file in the tester instead.
A fresh terminal may need a little time to download calendar data. The InpBlockIfNoCalendar input decides whether a failed read blocks trading or lets it continue. Blocking is the safer default.
Symbols such as XAUUSD have a base currency with no events, so only USD events will count. Index CFDs often report the same currency for base and profit. Check what SymbolInfoString() returns on your broker before trusting the filter on non forex symbols.
Importance levels are set by the calendar provider. Before going live, print the events your filter would have blocked over the past month and check that the list matches what you expect.

That last step is cheap. Run CalendarValueHistory() over the previous 30 days in a script, pass every value through EventMatters(), and print the result. If an event you care about is missing, or the list is full of minor releases, adjust the importance setting before the EA ever sees a real release.

Adding a pause button to an MQL5 Expert Advisor with OnChartEvent

Omais Ali — Thu, 29 Oct 2026 06:29:09 +0000

Sooner or later every trader running an Expert Advisor wants to stop it from opening new trades for a while. A news release is coming, the spread looks strange, or they simply want to watch for an hour. The usual options are not great. Removing the EA from the chart also stops it managing the positions it already has. Turning off Algo Trading in the terminal stops every EA on every chart.

A pause button on the chart solves this. It blocks new entries for this EA only, while the EA keeps managing its open positions. This tutorial builds one with OBJ_BUTTON and OnChartEvent(), and makes the paused state survive a restart.

Creating the button

input long InpMagic = 7310;

const string BTN = "ctb_pause_btn";
bool gPaused = false;

string PauseKey()
{
   // global variable names are limited to 63 characters
   return StringFormat("ctb_paused_%I64d_%s_%I64d",
                       AccountInfoInteger(ACCOUNT_LOGIN), _Symbol, InpMagic);
}

void UpdateButton()
{
   ObjectSetInteger(0, BTN, OBJPROP_STATE, gPaused);
   ObjectSetString(0, BTN, OBJPROP_TEXT, gPaused ? "Resume entries" : "Pause entries");
   ObjectSetInteger(0, BTN, OBJPROP_BGCOLOR, gPaused ? clrOrange : clrSilver);
   ChartRedraw(0);
}

void CreateButton()
{
   if(ObjectFind(0, BTN) < 0)
      ObjectCreate(0, BTN, OBJ_BUTTON, 0, 0, 0);

   ObjectSetInteger(0, BTN, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
   ObjectSetInteger(0, BTN, OBJPROP_XDISTANCE, 150);  // at least the width
   ObjectSetInteger(0, BTN, OBJPROP_YDISTANCE, 30);
   ObjectSetInteger(0, BTN, OBJPROP_XSIZE, 140);
   ObjectSetInteger(0, BTN, OBJPROP_YSIZE, 28);
   ObjectSetInteger(0, BTN, OBJPROP_SELECTABLE, false);
   UpdateButton();
}

Two details matter here.

With CORNER_RIGHT_UPPER the distances are measured from the right edge of the chart to the left edge of the button, so OBJPROP_XDISTANCE has to be at least as large as OBJPROP_XSIZE or the button ends up partly off screen.

The key for the saved state includes the account number, the symbol and the magic number. If the same EA runs on two charts, each copy gets its own pause switch.

Reacting to clicks

void SetPaused(const bool paused)
{
   gPaused = paused;
   GlobalVariableSet(PauseKey(), paused ? 1.0 : 0.0);
   GlobalVariablesFlush();
   PrintFormat("New entries %s", paused ? "paused" : "resumed");
   UpdateButton();
}

void OnChartEvent(const int id, const long &lparam,
                  const double &dparam, const string &sparam)
{
   if(id == CHARTEVENT_OBJECT_CLICK && sparam == BTN)
   {
      // the terminal has already flipped OBJPROP_STATE for us
      SetPaused((bool)ObjectGetInteger(0, BTN, OBJPROP_STATE));
      return;
   }

   if(id == CHARTEVENT_OBJECT_DELETE && sparam == BTN)
      CreateButton();   // someone deleted it by hand, put it back
}

A button object toggles its own OBJPROP_STATE when clicked, so the handler reads the state instead of keeping a separate toggle. That way the variable and what the trader sees cannot drift apart.

The delete event is not sent by default. You turn it on with ChartSetInteger(0, CHART_EVENT_OBJECT_DELETE, true), which is done in OnInit() below.

Wiring it into the EA

int OnInit()
{
   ChartSetInteger(0, CHART_EVENT_OBJECT_DELETE, true);

   if(GlobalVariableCheck(PauseKey()))
      gPaused = GlobalVariableGet(PauseKey()) > 0.5;

   CreateButton();
   if(gPaused)
      Print("Starting with new entries paused");
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   ObjectDelete(0, BTN);
}

void OnTick()
{
   ManageOpenPositions();   // stops, trailing, exits: always runs

   if(gPaused)
      return;               // no new entries while paused

   CheckForEntry();
}

ManageOpenPositions() and CheckForEntry() stand for whatever your EA already does. The order inside OnTick() is the important part. Position management runs first and always. The pause only skips the entry logic. A pause button that also stopped trailing stops and exits would be more dangerous than no button at all.

The state is stored in a terminal global variable, so it survives a timeframe change, a change of inputs and a terminal restart. GlobalVariablesFlush() writes it to disk straight away instead of waiting for the terminal to close. Global variables that are not accessed are deleted after four weeks, which is fine for a pause flag.

Deleting the button in OnDeinit() keeps the chart clean when the EA is removed. On a timeframe change OnInit() runs again and recreates it with the saved state.

Testing it

Chart events are not delivered in the Strategy Tester, so try the button on a demo chart.

Attach the EA, click Pause and check the Experts log for the message.
Change the timeframe and confirm the button comes back still paused.
Restart the terminal and check again.
Open a position, pause, and confirm the trailing stop or exit still works while no new trades open.
Delete the button from the object list (Ctrl+B) and confirm it reappears.

A pause switch is a small feature, but it gives the trader a safe middle ground between leaving the EA alone and pulling it off the chart.

Sending push notifications from an MQL5 EA without getting them switched off

Omais Ali — Wed, 28 Oct 2026 06:30:35 +0000

A push notification to your phone is the simplest way to know what an Expert Advisor is doing while you are away from the terminal. MQL5 has one function for it, SendNotification(), and most EAs call it directly wherever something interesting happens.

That works until the day something goes wrong. A disconnect, a loop of rejected orders or a burst of partial fills makes the EA call SendNotification() many times in a few seconds. The terminal has strict limits on this function, and if they are broken it can disable notifications for the program. So the one moment you most need the alert is the moment it stops arriving.

This tutorial builds a small notifier that respects the limits, skips duplicates and still logs everything.

The rules from the documentation

The message can be at most 255 characters.
No more than 2 calls per second and no more than 10 calls per minute. The terminal monitors this dynamically and can disable the function when the limit is broken.
SendNotification() does not work in the Strategy Tester.
Notifications must be enabled in the terminal, with your MetaQuotes ID entered under Tools, Options, Notifications. You can check this from code with TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED).
On failure, GetLastError() returns one of 4515 (ERR_NOTIFICATION_SEND_FAILED), 4516 (ERR_NOTIFICATION_WRONG_PARAMETER), 4517 (ERR_NOTIFICATION_WRONG_SETTINGS) or 4518 (ERR_NOTIFICATION_TOO_FREQUENT).

The design follows from those rules: never send from the place where the event happens. Put the message in a queue and send from a timer at a pace the terminal accepts.

Queueing messages

#define NOTIFY_MAX_PER_MIN 8     // stay below the limit of 10
#define NOTIFY_MAX_QUEUE   50

string   gQueue[];
ulong    gSent[];                // GetTickCount64() of recent sends
string   gLastText     = "";
datetime gLastTextTime = 0;

bool NotifyAvailable()
{
   if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION))
      return false;
   return (bool)TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED);
}

void Notify(const string text, const int dedupeSeconds = 300)
{
   Print("NOTIFY: ", text);      // the log always gets the message

   if(!NotifyAvailable())
      return;

   // the same text again within a few minutes adds nothing
   if(text == gLastText && TimeLocal() - gLastTextTime < dedupeSeconds)
      return;
   gLastText     = text;
   gLastTextTime = TimeLocal();

   string msg = StringFormat("%s %I64d: %s", _Symbol,
                             AccountInfoInteger(ACCOUNT_LOGIN), text);
   if(StringLen(msg) > 255)
      msg = StringSubstr(msg, 0, 255);

   int n = ArraySize(gQueue);
   if(n >= NOTIFY_MAX_QUEUE)
   {
      ArrayRemove(gQueue, 0, 1); // drop the oldest, keep the newest
      n--;
   }
   ArrayResize(gQueue, n + 1);
   gQueue[n] = msg;
}

A few choices here are deliberate.

The symbol and account number go in front of every message. If you run several EAs or several accounts, a bare "Daily loss limit reached" on a phone screen is not enough to act on.

Duplicates are dropped by text. An EA that fails to modify a stop on every tick would otherwise produce the same alert hundreds of times. Use TimeLocal() for this check rather than TimeCurrent(), because server time stops moving when no quotes arrive, for example over the weekend.

The queue has a cap. If the terminal cannot send for a long time, you do not want a backlog of stale alerts arriving an hour later.

Sending at a safe pace

void FlushNotifications()
{
   if(ArraySize(gQueue) == 0)
      return;

   // forget sends older than 60 seconds
   ulong now  = GetTickCount64();
   int   keep = 0;
   for(int i = 0; i < ArraySize(gSent); i++)
      if(now - gSent[i] < 60000)
         gSent[keep++] = gSent[i];
   ArrayResize(gSent, keep);

   if(keep >= NOTIFY_MAX_PER_MIN)
      return;                    // wait until the window moves on

   ResetLastError();
   if(SendNotification(gQueue[0]))
   {
      ArrayResize(gSent, keep + 1);
      gSent[keep] = now;
      ArrayRemove(gQueue, 0, 1);
      return;
   }

   int err = GetLastError();
   PrintFormat("SendNotification failed, error %d", err);

   // these will never succeed, so do not retry them forever
   if(err == ERR_NOTIFICATION_WRONG_PARAMETER ||
      err == ERR_NOTIFICATION_WRONG_SETTINGS)
      ArrayRemove(gQueue, 0, 1);
}

Call it from a one second timer. That alone keeps you at no more than one message per second, and the rolling window keeps you under the per minute limit with some room to spare.

int OnInit()
{
   EventSetTimer(1);
   if(!NotifyAvailable())
      Print("Push notifications are off or not configured, alerts go to the log only");
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
}

void OnTimer()
{
   FlushNotifications();
}

If your EA already uses a timer for other work, call FlushNotifications() at the end of the existing OnTimer() instead of creating a second one. An EA can only have one timer.

What is worth a notification

The limit of 10 per minute is a good reminder that a phone alert should mean "look at this". Some events that usually earn one:

A position opened or closed, with volume, price and the reason. OnTradeTransaction() with TRADE_TRANSACTION_DEAL_ADD is the reliable place to catch this.
A trade request rejected with a retcode the EA cannot handle on its own.
A risk rule triggered, such as a daily loss limit or a maximum drawdown lock.
Lost connection that lasts longer than a minute. Check TerminalInfoInteger(TERMINAL_CONNECTED) in the timer and only alert when the state has been bad for a while, then send one more message when it recovers.
The EA being removed or the terminal closing. In OnDeinit() the timer is already gone, so call SendNotification() directly there, once, with the reason code.

Everything else belongs in the log. Normal events like a new bar or a trailing stop step will drown out the alerts that matter.

Testing it

SendNotification() does nothing in the Strategy Tester, so test on a demo account. A quick check is a script or a temporary input that queues 30 messages at once. You should see them arrive on the phone at a steady pace over a few minutes, and no 4518 errors in the Experts log. Then send the same text 30 times and confirm only one arrives.

A notifier that slows down under pressure is far more useful than one that goes silent exactly when the EA is in trouble.

Validating Expert Advisor inputs in OnInit so bad settings never reach the market

Omais Ali — Tue, 27 Oct 2026 06:23:58 +0000

Most Expert Advisors trust their inputs completely. Whatever the user types in the settings dialog goes straight into the trading logic. A risk of 10 instead of 1.0, a stop loss of 0, a fast moving average longer than the slow one: the EA starts, runs and trades on settings that make no sense.

MQL5 gives you a clean place to stop that. OnInit() runs once when the EA is attached, when inputs change and at the start of every Strategy Tester pass. Its return value decides whether the EA is allowed to run at all.

This tutorial shows how to check inputs there, how to choose the right return code, and how the same checks speed up optimization.

The return codes

OnInit() returns an int, normally one of these values from ENUM_INIT_RETCODE:

INIT_SUCCEEDED means everything is fine and the EA starts.
INIT_FAILED means initialization failed for a reason outside the inputs, such as an indicator handle that could not be created.
INIT_PARAMETERS_INCORRECT means the inputs themselves are wrong.
INIT_AGENT_NOT_SUITABLE is for tester agents that cannot run the pass, and rarely matters in normal EAs.

Any value other than INIT_SUCCEEDED stops the EA. On a live chart it is removed, and OnDeinit() runs with the reason REASON_INITFAILED. The user sees nothing unless you tell them, so always log why.

A small rejection helper

Keeping the message and the return code in one place makes the checks short and consistent.

int Reject(const string why)
{
   PrintFormat("Input error, EA not started: %s", why);
   if(!MQLInfoInteger(MQL_TESTER))
      Alert("EA not started: ", why);
   return INIT_PARAMETERS_INCORRECT;
}

The Alert is skipped in the tester, because a popup for every rejected optimization pass would be unbearable.

Checking the inputs themselves

These are rules that hold on any account and any symbol. Write them as plainly as you can.

input double InpRiskPercent = 1.0;    // risk per trade, percent of balance
input int    InpStopPoints  = 300;    // stop loss distance in points
input int    InpTakePoints  = 600;    // take profit distance in points
input int    InpFastPeriod  = 12;     // fast moving average period
input int    InpSlowPeriod  = 26;     // slow moving average period
input int    InpStartHour   = 8;      // trading window start, server time
input int    InpEndHour     = 20;     // trading window end, server time
input long   InpMagic       = 240101; // magic number

int OnInit()
{
   if(InpRiskPercent <= 0.0 || InpRiskPercent > 5.0)
      return Reject("InpRiskPercent must be above 0 and no more than 5");

   if(InpStopPoints <= 0)
      return Reject("InpStopPoints must be positive, the EA never trades without a stop");

   if(InpTakePoints < 0)
      return Reject("InpTakePoints cannot be negative, use 0 for no take profit");

   if(InpFastPeriod < 1 || InpSlowPeriod < 1)
      return Reject("moving average periods must be at least 1");

   if(InpFastPeriod >= InpSlowPeriod)
      return Reject("InpFastPeriod must be shorter than InpSlowPeriod");

   if(InpStartHour < 0 || InpStartHour > 23 || InpEndHour < 0 || InpEndHour > 23)
      return Reject("trading hours must be between 0 and 23");

   if(InpMagic <= 0)
      return Reject("InpMagic must be a positive number");

   return CheckEnvironment();
}

The upper limit on risk is a deliberate guard against typing 10 when you meant 1.0. Pick a ceiling that suits the strategy and say so in the message.

Checking inputs against the symbol

Some inputs are only valid on certain symbols or accounts. A stop of 30 points is fine on one broker and below the minimum distance on another. These checks use symbol properties, so they belong in a second function.

int CheckEnvironment()
{
   long stopsLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   if(stopsLevel > 0 && InpStopPoints <= stopsLevel)
      return Reject(StringFormat("InpStopPoints %d is inside the broker minimum of %d points on %s",
                                 InpStopPoints, (int)stopsLevel, _Symbol));

   if(InpTakePoints > 0 && stopsLevel > 0 && InpTakePoints <= stopsLevel)
      return Reject(StringFormat("InpTakePoints %d is inside the broker minimum of %d points on %s",
                                 InpTakePoints, (int)stopsLevel, _Symbol));

   double minVol = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   if(minVol <= 0.0)
   {
      PrintFormat("Could not read volume limits for %s", _Symbol);
      return INIT_FAILED;
   }

   return INIT_SUCCEEDED;
}

Notice the different return code for the volume check. If the terminal cannot give us symbol data, the inputs are not the problem, so INIT_FAILED is the honest answer.

A stops level of 0 usually means the broker uses a floating minimum distance, so the startup check cannot catch everything. Keep checking the distance again just before each order or modify.

Why this matters in optimization

Optimization is where input validation pays for itself. Suppose you optimize the fast period from 5 to 50 and the slow period from 10 to 100. A large share of those combinations has the fast period equal to or longer than the slow one. Without validation, every one of them runs a full test that produces nonsense.

With the check above, those passes return INIT_PARAMETERS_INCORRECT and stop immediately. The tester marks them in the results instead of simulating them, so the optimization finishes faster and the results table only ranks combinations that make sense.

Use enums instead of magic integers

The cheapest validation is the one the user cannot get wrong. If an input chooses between modes, declare an enum and the settings dialog will show a drop down list instead of a free number field.

enum ENUM_EXIT_MODE
{
   EXIT_FIXED_TP  = 0,  // Fixed take profit
   EXIT_TRAILING  = 1,  // Trailing stop
   EXIT_OPPOSITE  = 2   // Opposite signal
};

input ENUM_EXIT_MODE InpExitMode = EXIT_FIXED_TP;  // exit method

The comment after each enum value is what the user sees in the list, which doubles as documentation.

Practical notes

Input variables are read only inside the EA. If you need to adjust a value, for example rounding a lot size to the symbol step, copy it into a global variable in OnInit() and use the copy.
Print the final accepted settings once in OnInit(). When someone sends you a log, you will know exactly what the EA was running with.
Write the reason in the message, not just the input name. "InpFastPeriod must be shorter than InpSlowPeriod" saves a support question. "Invalid input" creates one.
Validation in OnInit() runs again whenever the user changes inputs on a running EA, so the same rules protect live edits too.

An EA that refuses to start with a clear message is far better than one that starts happily and trades on a typo.

Writing a custom optimization criterion in MQL5 with OnTester()

Omais Ali — Mon, 26 Oct 2026 06:27:55 +0000

The MetaTrader 5 Strategy Tester can rank optimization passes by balance, profit factor, expected payoff, drawdown, recovery factor or Sharpe ratio. Each of those built in criteria has the same weakness: it will happily rank a pass with 14 trades and one lucky winner above a pass with 400 steady trades.

The fix is to write your own criterion. MQL5 lets an Expert Advisor define an OnTester() function that runs once at the end of every test pass and returns a single number. If you choose "Custom max" as the optimization criterion, the tester ranks passes by that number.

This tutorial builds a criterion that rejects passes you would never trade, and then scores the rest in a way that rewards robustness instead of luck.

The basics

OnTester() takes no parameters and returns a double. Inside it, TesterStatistics() gives you the same figures you see in the tester report.

double OnTester()
{
   double trades = TesterStatistics(STAT_TRADES);
   double profit = TesterStatistics(STAT_PROFIT);
   return profit;
}

Returning plain profit like this reproduces the default balance criterion, which is not very useful. The value comes from what you add.

Step one: hard filters

Some passes should never win, however good their headline number. Return 0 for them so they sink to the bottom of the results.

input int    InpMinTrades     = 100;   // minimum trades for a pass to count
input double InpMaxDDPercent  = 25.0;  // maximum relative equity drawdown

double OnTester()
{
   double trades     = TesterStatistics(STAT_TRADES);
   double lossTrades = TesterStatistics(STAT_LOSS_TRADES);
   double profit     = TesterStatistics(STAT_PROFIT);
   double ddPercent  = TesterStatistics(STAT_EQUITY_DDREL_PERCENT);

   if(trades < InpMinTrades)        return 0.0;  // too few trades to judge
   if(lossTrades < 1)               return 0.0;  // no losers usually means a broken test
   if(profit <= 0.0)                return 0.0;
   if(ddPercent > InpMaxDDPercent)  return 0.0;

   return profit;
}

The minimum trade count is the most important line. Small samples produce extreme statistics in both directions, and the optimizer is very good at finding them.

A pass with zero losing trades is also worth rejecting. In real strategies it almost always means the stop loss was never hit because of a modelling problem, a grid or martingale that has not met its bad day yet, or a test period that is far too short.

Step two: score what is left

Profit on its own ignores how much pain it took to earn it. Recovery factor, which is net profit divided by maximum drawdown, is a better starting point because it rewards return per unit of drawdown.

On top of that, it helps to shrink the score for passes that only just cleared the trade count filter. A simple way to do that without any fancy statistics is to divide by a factor that approaches 1 as the trade count grows.

double OnTester()
{
   double trades     = TesterStatistics(STAT_TRADES);
   double lossTrades = TesterStatistics(STAT_LOSS_TRADES);
   double profit     = TesterStatistics(STAT_PROFIT);
   double ddPercent  = TesterStatistics(STAT_EQUITY_DDREL_PERCENT);
   double recovery   = TesterStatistics(STAT_RECOVERY_FACTOR);

   if(trades < InpMinTrades)        return 0.0;
   if(lossTrades < 1)               return 0.0;
   if(profit <= 0.0)                return 0.0;
   if(ddPercent > InpMaxDDPercent)  return 0.0;

   // 100 trades divides the score by 1.5, 400 trades by 1.125
   double sampleFactor = 1.0 + 50.0 / trades;

   return recovery / sampleFactor;
}

The exact constant is a judgement call. The point is that two passes with the same recovery factor should not be ranked equally when one is based on four times as many trades.

Step three: check what the optimizer is really choosing

Once you switch to a custom criterion, look at the top 20 passes rather than only the best one. You want to see:

Neighbouring parameter values scoring similarly. If the best pass is surrounded by zeros, it is a spike, not a plateau.
Trade counts well above your minimum, not clustered right on it.
Drawdown comfortably under your limit, not just under it.

If the top of the list is dominated by passes that barely clear the filters, the filters are doing their job and the strategy may simply not have enough edge.

Practical notes

OnTester() also runs in a single test, not only in optimization. The value is shown in the report as the OnTester result, which is handy for checking your formula on one known pass.
Keep the criterion inputs in the EA so you can change thresholds without recompiling, but exclude them from the optimization itself.
If you use forward testing in the optimizer, compare the custom score of the backtest and forward parts of the same pass. A large drop is the clearest warning sign you will get.
Do not divide by a statistic that can be zero. Recovery factor and profit factor need care when there are no losing trades, which is one more reason for the filter above.

A custom criterion does not make a strategy better. It stops the optimizer from rewarding the passes most likely to fall apart live.

Moving a stop to breakeven in MQL5 without rejected modifies or hidden losses

Omais Ali — Sun, 25 Oct 2026 06:30:03 +0000

Moving the stop loss to breakeven once a trade is in profit is one of the most requested Expert Advisor features. It also produces a surprising number of bug reports: the stop never moves, the journal fills with errors, or the trade closes "at breakeven" and still shows a small loss.

This tutorial builds a breakeven routine that measures profit from the right price, respects the broker's distance rules, only ever tightens the stop, and covers trading costs.

Measure profit from the price you would close at

A buy position closes at the bid. A sell position closes at the ask. If you measure a buy against the ask, or a sell against the bid, the spread gets counted as profit and the stop moves too early. On a wide spread symbol that can mean the stop is moved before the trade is really in profit at all.

Breakeven is not the entry price

If the stop sits exactly at the open price, a trade that comes back and hits it still loses the commission and any swap it has collected. So "breakeven" should usually be the entry plus a small offset in your favour, large enough to cover commission and a little slippage. For a buy that is above the entry, for a sell below it.

On netting accounts there is one more catch. If the EA adds to a position, POSITION_PRICE_OPEN becomes the volume weighted average price of the whole position, so the breakeven level moves with every addition. That is usually what you want, but test it on purpose.

Helpers

The two helpers convert points to a price distance and round a price to the symbol's tick size. Rounding to the tick size rather than to the number of digits matters on indices and metals where the tick is larger than one point.

#include <Trade\Trade.mqh>
CTrade trade;

input int   InpTriggerPoints = 200;   // profit in points before the stop moves
input int   InpOffsetPoints  = 30;    // points beyond entry to lock in, covers costs
input ulong InpMagic         = 20261025;

double PointsToPrice(const string sym, const int pts)
{
   double point = SymbolInfoDouble(sym, SYMBOL_POINT);
   return pts / (1.0 / point);        // pts times point
}

double RoundToTick(const string sym, const double price)
{
   double tick   = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE);
   int    digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
   if(tick <= 0.0)
      return NormalizeDouble(price, digits);
   return NormalizeDouble(MathRound(price / tick) / (1.0 / tick), digits);
}

Respect the stops level and the freeze level

Two broker settings decide whether a modify request is even allowed.

SYMBOL_TRADE_STOPS_LEVEL is the minimum distance in points between the current price and a new stop. Place the stop closer and the request is rejected with invalid stops.
SYMBOL_TRADE_FREEZE_LEVEL forbids modifying a position whose existing stop loss or take profit is already within that distance of the current price. The position is frozen until price moves away.

Checking both before sending saves a rejected request and a noisy log.

bool ModifyAllowed(const string sym, const long type, const double newSl,
                   const double curSl, const double curTp, const MqlTick &tick)
{
   double stopsDist  = PointsToPrice(sym, (int)SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL));
   double freezeDist = PointsToPrice(sym, (int)SymbolInfoInteger(sym, SYMBOL_TRADE_FREEZE_LEVEL));
   double price      = (type == POSITION_TYPE_BUY) ? tick.bid : tick.ask;

   // the new stop must be far enough from the closing price
   if(MathAbs(price - newSl) <= stopsDist)
      return false;

   // existing levels inside the freeze distance block any modify
   if(freezeDist > 0.0)
   {
      if(curSl > 0.0 && MathAbs(price - curSl) <= freezeDist) return false;
      if(curTp > 0.0 && MathAbs(price - curTp) <= freezeDist) return false;
   }
   return true;
}

The breakeven routine

The loop walks backwards through positions, skips anything that does not carry the EA's magic number, and only sends a modify when the stop would actually improve. That last check is what stops the journal from filling with TRADE_RETCODE_NO_CHANGES on every tick.

void ManageBreakeven()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0)
         continue;
      if(PositionGetInteger(POSITION_MAGIC) != (long)InpMagic)
         continue;

      string sym  = PositionGetString(POSITION_SYMBOL);
      long   type = PositionGetInteger(POSITION_TYPE);
      double open = PositionGetDouble(POSITION_PRICE_OPEN);
      double sl   = PositionGetDouble(POSITION_SL);
      double tp   = PositionGetDouble(POSITION_TP);

      MqlTick tick;
      if(!SymbolInfoTick(sym, tick))
         continue;

      double trigger = PointsToPrice(sym, InpTriggerPoints);
      double offset  = PointsToPrice(sym, InpOffsetPoints);
      double target  = 0.0;

      if(type == POSITION_TYPE_BUY)
      {
         if(tick.bid - open < trigger)
            continue;                              // not far enough in profit
         target = RoundToTick(sym, open + offset);
         if(sl > 0.0 && sl >= target)
            continue;                              // already at or past breakeven
      }
      else
      {
         if(open - tick.ask < trigger)
            continue;
         target = RoundToTick(sym, open - offset);
         if(sl > 0.0 && sl <= target)
            continue;
      }

      if(!ModifyAllowed(sym, type, target, sl, tp, tick))
         continue;                                 // try again on a later tick

      if(!trade.PositionModify(ticket, target, tp))
         PrintFormat("Breakeven modify failed on %I64u: %u %s",
                     ticket, trade.ResultRetcode(), trade.ResultRetcodeDescription());
      else
         PrintFormat("Breakeven set on %I64u at %s", ticket, DoubleToString(target, _Digits));
   }
}

void OnTick()
{
   ManageBreakeven();
}

A few details worth calling out.

The take profit is passed back unchanged. PositionModify sets both levels, so sending 0 for the take profit would silently remove it.
The comparison against the existing stop works in one direction only. The stop can move toward profit, never back toward risk.
If the trigger is smaller than the offset plus the stops level, the routine will keep finding the move not allowed. Keep the trigger comfortably larger than the offset.
PrintFormat uses _Digits for display only. If the EA trades several symbols, read SYMBOL_DIGITS for each one.

Choosing the offset

A reasonable starting point is the commission for a round trip expressed in points, plus a few points for slippage. On a raw spread account charging a fixed commission per lot, work out how many points of price movement that commission equals for your typical lot size, and use that as the floor. On a commission free account the offset can be small, but rarely zero.

Testing it

Run the Strategy Tester in visual mode on a volatile day and watch the stop jump exactly once per position.
Check the journal for repeated modify errors. One or two invalid stops messages near news are normal; hundreds mean a check is missing.
Test a sell as carefully as a buy. Most breakeven bugs live in the side the developer tested less.
Try a symbol with a nonzero freeze level, or temporarily force one in code, to make sure frozen positions are skipped instead of retried in a tight loop.

Breakeven sounds like one line of logic. Done properly it is a small set of rules about prices, distances and costs, and getting them right is what makes the feature trustworthy.

Closing every position your MQL5 EA owns without skipping any

Omais Ali — Sat, 24 Oct 2026 06:30:13 +0000

Sooner or later every Expert Advisor needs a "close everything" routine. A daily loss limit is hit, the weekend is coming, or the trader presses a panic button. It sounds like five lines of code, and that is exactly why it so often ships with bugs that only show up when real money is on the line.

This tutorial builds a close routine that does not skip positions, only touches positions the EA owns, retries sensibly and tells you when something is left open.

The classic bug: looping forward while closing

Here is the version many people write first.

for(int i = 0; i < PositionsTotal(); i++)
{
   ulong ticket = PositionGetTicket(i);
   trade.PositionClose(ticket);
}

Say there are four positions. The loop closes the one at index 0. The list shrinks, so the position that was at index 1 is now at index 0. The loop moves on to index 1 and closes what used to be index 2. You end up closing roughly half of the positions and leaving the rest open, with no error at all.

A common fix is to count down from the last index. That works, but there is a cleaner pattern that also helps with retries: take a snapshot of the tickets first, then close them one by one by ticket.

Step 1: collect the tickets this EA owns

#include <Trade\Trade.mqh>

input long InpMagic = 20261024;

CTrade trade;

int CollectMyTickets(ulong &tickets[])
{
   ArrayResize(tickets, 0);
   int total = PositionsTotal();
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);   // also selects the position
      if(ticket == 0)
         continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;                           // not ours, leave it alone
      int n = ArraySize(tickets);
      ArrayResize(tickets, n + 1);
      tickets[n] = ticket;
   }
   return ArraySize(tickets);
}

Nothing is closed inside this loop, so the index shifting problem cannot happen. The magic number filter matters: a trader may run several EAs or trade manually on the same account, and a panic button that closes someone else's positions is its own kind of disaster. Add a symbol filter here too if the EA should only manage its own chart symbol.

Step 2: decide which errors are worth retrying

Not every failure deserves another attempt. A requote or a moved price usually succeeds a moment later. A closed market or disabled trading will not.

bool IsRetryable(uint rc)
{
   return rc == TRADE_RETCODE_REQUOTE       ||
          rc == TRADE_RETCODE_PRICE_CHANGED ||
          rc == TRADE_RETCODE_PRICE_OFF     ||
          rc == TRADE_RETCODE_TIMEOUT       ||
          rc == TRADE_RETCODE_CONNECTION;
}

Step 3: close one ticket with limited retries

bool CloseTicket(ulong ticket, int maxAttempts)
{
   for(int attempt = 1; attempt <= maxAttempts; attempt++)
   {
      if(!PositionSelectByTicket(ticket))
         return true;                        // already closed, by us or by a stop

      string sym = PositionGetString(POSITION_SYMBOL);
      trade.SetTypeFillingBySymbol(sym);

      trade.PositionClose(ticket);
      uint rc = trade.ResultRetcode();

      if(rc == TRADE_RETCODE_DONE)
         return true;

      if(rc == TRADE_RETCODE_DONE_PARTIAL)
         continue;                           // remainder is still open, go again

      PrintFormat("Close %I64u attempt %d failed: %u %s",
                  ticket, attempt, rc, trade.ResultRetcodeDescription());

      if(!IsRetryable(rc))
         return false;

      Sleep(300);
   }
   return !PositionSelectByTicket(ticket);
}

A few details are doing real work here.

The position is selected again on every attempt. Between attempts it may have been closed by its own stop loss or take profit, and trying to close a ticket that no longer exists only produces confusing errors.
CTrade reads a fresh price on every PositionClose call, so a retry after a requote uses the current Bid or Ask rather than the stale one.
The filling mode is set per symbol, because a multi symbol EA can hold positions on symbols with different filling rules.
A partial fill does not count as success. The loop goes around again and closes whatever volume is left.

Step 4: close everything and report what is left

int CloseAllMine()
{
   ulong tickets[];
   int count = CollectMyTickets(tickets);
   int failed = 0;

   for(int i = 0; i < count; i++)
   {
      if(!CloseTicket(tickets[i], 3))
         failed++;
   }

   if(failed > 0)
      PrintFormat("CloseAllMine: %d of %d positions still open", failed, count);

   return failed;
}

int OnInit()
{
   trade.SetExpertMagicNumber(InpMagic);
   trade.SetDeviationInPoints(20);
   return INIT_SUCCEEDED;
}

The return value is the important part. The caller now knows whether the account is actually flat. A daily loss guard, for example, should keep blocking new entries and try again on the next tick or timer event if anything is still open, instead of assuming the job is done.

Do not forget pending orders

Closing positions while leaving pending orders in place often means the EA is back in the market a few minutes later. Use the same snapshot idea with OrdersTotal, OrderGetTicket and ORDER_MAGIC, and remove each one with trade.OrderDelete(ticket). Usually it is best to delete pending orders first, so nothing new can fill while you are closing.

A note on hedging accounts

On a hedging account, if the EA holds a buy and a sell of the same symbol, trade.PositionCloseBy(ticket, oppositeTicket) closes one against the other and saves paying the spread twice. It is an optimisation, not a requirement, but worth knowing when an EA builds hedged baskets.

How to test it

On a demo account, open four or five positions with the EA's magic number and one manual position. Run the routine and check that every EA position is closed and the manual one is untouched. Then run it again when the market is closed and confirm that it stops quickly, logs TRADE_RETCODE_MARKET_CLOSED and reports the positions as still open rather than retrying forever.

Detecting stale quotes in an MQL5 Expert Advisor before you trade on them

Omais Ali — Fri, 23 Oct 2026 06:22:22 +0000

An Expert Advisor only ever sees the last price the terminal received. Most of the time that is fine. But when the feed freezes, the market closes for the night, or the symbol has no liquidity for a few minutes, your EA keeps reading the same old Bid and Ask and happily calculates signals and stop distances from a price that no longer exists.

This article shows a small, reusable check that tells your EA how old the current quote is and whether it is safe to act on.

Where the quote time comes from

SymbolInfoTick fills an MqlTick structure. Its time field is the server time of the last price update, and time_msc gives the same moment in milliseconds.

MqlTick tick;
if(!SymbolInfoTick(_Symbol, tick))
{
   Print("SymbolInfoTick failed, error ", GetLastError());
   return;
}
Print("Last quote at ", TimeToString(tick.time, TIME_DATE|TIME_SECONDS));

To know how old that quote is, compare it with the current trade server time. TimeTradeServer is estimated from your local clock and the known server offset, so it keeps moving even when no ticks arrive. That is exactly what we need.

A quote age function

// Returns the age of the last quote in seconds, or a negative value on failure.
long QuoteAgeSeconds(const string symbol)
{
   MqlTick tick;
   if(!SymbolInfoTick(symbol, tick))
      return -1;
   if(tick.time == 0)
      return -1;
   return (long)(TimeTradeServer() - tick.time);
}

Do not use TimeCurrent for this. TimeCurrent returns the time of the last tick received for any symbol in Market Watch, so on a frozen feed it can freeze too, and the age will always look close to zero.

Is the market actually open?

A quote that is two hours old on Saturday is normal. The same age on Tuesday afternoon is a problem. Before raising an alarm, check whether the symbol has a trade session right now.

bool InTradeSession(const string symbol)
{
   datetime serverNow = TimeTradeServer();
   MqlDateTime now;
   TimeToStruct(serverNow, now);
   datetime secondsToday = serverNow % 86400;   // seconds since midnight, server time

   datetime from, to;
   for(uint i = 0; SymbolInfoSessionTrade(symbol, (ENUM_DAY_OF_WEEK)now.day_of_week, i, from, to); i++)
   {
      if(secondsToday >= from && secondsToday < to)
         return true;
   }
   return false;
}

SymbolInfoSessionTrade returns the session start and end as seconds from the start of the day, and you loop over the session index until it returns false. Some symbols have two or three sessions per day with a break in between.

Putting it together

input int InpMaxQuoteAgeSec = 30;   // treat quotes older than this as stale

bool QuoteIsFresh()
{
   if(!InTradeSession(_Symbol))
      return false;                  // market closed, do not trade

   long age = QuoteAgeSeconds(_Symbol);
   if(age < 0)
      return false;                  // could not read the tick

   if(age > InpMaxQuoteAgeSec)
   {
      static datetime lastWarn = 0;
      if(TimeTradeServer() - lastWarn > 300)
      {
         PrintFormat("%s quote is %d seconds old, skipping signals", _Symbol, age);
         lastWarn = TimeTradeServer();
      }
      return false;
   }
   return true;
}

void OnTick()
{
   if(!QuoteIsFresh())
      return;
   // signal and order logic here
}

The warning is rate limited so a long freeze does not flood the Experts log.

Why OnTick is not enough on its own

If the feed is completely dead, OnTick will not fire at all, so the check above never runs. For EAs that manage open positions, also run the same check from OnTimer and log or alert when the quote has been stale for longer than your threshold during a trading session. That way you hear about a frozen feed while it is happening, not the next morning.

int OnInit()
{
   EventSetTimer(10);
   return INIT_SUCCEEDED;
}

void OnTimer()
{
   if(InTradeSession(_Symbol) && QuoteAgeSeconds(_Symbol) > InpMaxQuoteAgeSec)
      Print("Feed looks frozen on ", _Symbol);
}

void OnDeinit(const int reason)
{
   EventKillTimer();
}

Picking the threshold

There is no single right number. Major forex pairs tick several times a second during the London and New York sessions, so 30 seconds without a quote is already suspicious. An exotic pair or a thin CFD during the Asian session can legitimately go a minute or more without a tick. Measure the normal gaps on your broker for the symbols you trade and set the threshold a few times above that.

Testing it

The Strategy Tester generates ticks continuously, so you will rarely see a stale quote there. To test the logic, run the EA on a demo chart for a symbol whose session ends while you watch, or temporarily lower InpMaxQuoteAgeSec to a few seconds on a quiet symbol and confirm the skip message appears.

A stale quote check is a few dozen lines of code, and it prevents a whole class of strange trades that are very hard to explain after the fact.

Knowing why a position closed in MQL5 with OnTradeTransaction

Omais Ali — Thu, 22 Oct 2026 06:21:27 +0000

A common question in Expert Advisor code is "did my trade just hit its stop loss, its take profit, or did someone close it by hand?" Many EAs answer it by comparing the list of open positions on every tick and guessing. That works until two things happen on the same tick, or the EA restarts in the middle.

MQL5 gives you a better tool: OnTradeTransaction. The terminal calls it for every change on the account, and once a deal is added to history you can read exactly why it happened.

The event you care about

A trade request produces several transactions: the order is added, updated, removed, a deal is added, the position changes. For "why did this position close", the one to watch is TRADE_TRANSACTION_DEAL_ADD. A deal is the actual execution, and it carries a reason code.

input long InpMagic = 240101; // the magic number this EA trades with

void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
      return;

   ulong deal = trans.deal;
   if(deal == 0 || !HistoryDealSelect(deal))
   {
      PrintFormat("Deal %I64u not in history yet, will reconcile later", deal);
      return;
   }

   if(HistoryDealGetInteger(deal, DEAL_MAGIC) != InpMagic)
      return;

   ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal, DEAL_ENTRY);
   if(entry != DEAL_ENTRY_OUT && entry != DEAL_ENTRY_OUT_BY && entry != DEAL_ENTRY_INOUT)
      return; // an opening deal, not a close

   ENUM_DEAL_REASON reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(deal, DEAL_REASON);
   ulong  positionId = HistoryDealGetInteger(deal, DEAL_POSITION_ID);
   double net = HistoryDealGetDouble(deal, DEAL_PROFIT)
              + HistoryDealGetDouble(deal, DEAL_SWAP)
              + HistoryDealGetDouble(deal, DEAL_COMMISSION);

   PrintFormat("Position %I64u closed by %s, volume %.2f, net %.2f",
               positionId, ReasonText(reason),
               HistoryDealGetDouble(deal, DEAL_VOLUME), net);

   OnPositionClosed(positionId, reason, net);
}

A few notes on that code:

The magic number filter matters. Without it, a manual trade or another EA on the same account will run through your logic.
DEAL_ENTRY_OUT_BY covers close by an opposite position, and DEAL_ENTRY_INOUT covers a reversal on netting accounts, where one deal closes and opens in the same step.
Net result is profit plus swap plus commission. Using DEAL_PROFIT alone makes a scratch trade look like a small win.

Turning the reason code into something readable

string ReasonText(ENUM_DEAL_REASON r)
{
   switch(r)
   {
      case DEAL_REASON_SL:     return "stop loss";
      case DEAL_REASON_TP:     return "take profit";
      case DEAL_REASON_SO:     return "stop out";
      case DEAL_REASON_EXPERT: return "expert advisor";
      case DEAL_REASON_CLIENT: return "manual (desktop)";
      case DEAL_REASON_MOBILE: return "manual (mobile)";
      case DEAL_REASON_WEB:    return "manual (web)";
      default:                 return "other (" + IntegerToString(r) + ")";
   }
}

This is where the event pays for itself. Once you know the reason, the EA can behave differently:

After a stop loss, start a cooldown before the next entry.
After a take profit, allow the next signal as normal.
After a stop out, stop trading completely and alert, because the risk model has already failed.
After a manual close, respect it. Do not reopen the same trade on the next tick just because the signal is still true.

That last one is the bug I see most often. The trader closes a position on their phone, and the EA immediately opens it again.

Partial closes

If a position is partly closed, you still get a DEAL_ENTRY_OUT deal, but the position stays open with less volume. Check whether the position still exists before you treat it as finished:

void OnPositionClosed(ulong positionId, ENUM_DEAL_REASON reason, double net)
{
   if(PositionSelectByTicket(positionId))
   {
      PrintFormat("Position %I64u partly closed, %.2f lots remain",
                  positionId, PositionGetDouble(POSITION_VOLUME));
      return;
   }
   // fully closed: update stats, cooldowns, daily loss counters here
}

On hedging accounts the position ticket equals the position identifier, so PositionSelectByTicket works with the value from DEAL_POSITION_ID.

The limits you must design around

OnTradeTransaction is not a guaranteed delivery system, and two cases break EAs that trust it blindly:

The EA was not running. If the terminal was closed, or the EA was removed and attached again, every close in that time happened without an event. On startup, read recent history with HistorySelect and rebuild your state from deals instead of from memory.
The queue can overflow. Transactions are queued for the EA, and if the EA is busy for a long time, old events can be dropped. Keep the handler short, and do heavy work elsewhere.

So the pattern that holds up is: react to events for speed, and reconcile from history on start and every few minutes for correctness. If the two disagree, history wins.

Testing it

The Strategy Tester calls OnTradeTransaction too, so stop loss and take profit reasons can be checked there. Manual reasons cannot, so test those on a demo account: open a position with the EA, close it from the mobile app, and confirm the journal shows "manual (mobile)" and that the EA does not reopen it.

Once the EA knows why each trade ended, a lot of guesswork in the rest of the code goes away.

Why your MQL5 EA reads zero or garbage from indicators on the first ticks

Omais Ali — Wed, 21 Oct 2026 06:22:35 +0000

A bug I see in many MT5 Expert Advisors looks like a strategy problem at first. The EA opens a trade right after it is attached to a chart, or right after the terminal restarts, and the entry makes no sense. The journal shows a moving average of 0, or a value like 1.7976931348623157e+308. A few minutes later everything works normally.

The cause is almost always the way indicator data is read. In MQL5, indicators are not functions that return a value. They are separate calculation objects that you create once and read from later, and they need time to calculate. Here is how I structure indicator access in every EA now.

1. Create handles once, in OnInit

Functions like iMA, iRSI and iATR return a handle, not a value. The terminal starts calculating the indicator in the background when you create it.

If you call iMA inside OnTick, the terminal usually hands back the same handle for identical parameters, so it may look harmless, but you pay a lookup on every tick, you make it easy to leak handles when parameters change, and you hide the fact that the first read after creation can fail. Create every handle in OnInit, check it, and fail the initialization if it is invalid. An EA that cannot build its indicators should not run at all.

2. Check that the data is ready before reading it

Right after creation, the indicator may not have calculated any bars yet. BarsCalculated(handle) returns how many bars are ready, or a negative value while it is still working. CopyBuffer will return a negative value or fewer values than you asked for, and GetLastError often reports 4806 (ERR_INDICATOR_DATA_NOT_FOUND).

The wrong reaction is to ignore the return value and use whatever is in the array. The array then holds zeros from initialization or leftovers from a previous tick, and your crossover logic happily compares them.

The right reaction is to treat "not ready" as a normal state: skip this tick and try again on the next one.

3. Read closed bars, and know your array direction

Bar 0 is the bar that is still forming. Its indicator value changes with every tick, so a signal on bar 0 can appear and vanish within the same minute. For most strategies, read from bar 1, the last closed bar.

CopyBuffer fills the array oldest first unless the array is set as a series. I always call ArraySetAsSeries(array, true) before copying, so index 0 means the most recent value I requested. Mixing the two conventions is a classic source of signals that fire one bar late or in the wrong direction.

4. Handle empty values

Some indicators, especially custom ones that draw arrows or gaps, write EMPTY_VALUE on bars where they have nothing to say. That is the huge number from the journal above. Compare against EMPTY_VALUE before using a value, otherwise a stop loss or a threshold check can be calculated from it.

5. Release handles in OnDeinit

Call IndicatorRelease for every handle when the EA is removed or reinitialized. It keeps the terminal clean when you switch timeframes or change inputs during testing.

Putting it together

input int InpFastPeriod = 20;
input int InpSlowPeriod = 50;

int fastHandle = INVALID_HANDLE;
int slowHandle = INVALID_HANDLE;

int OnInit()
{
   fastHandle = iMA(_Symbol, PERIOD_CURRENT, InpFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
   slowHandle = iMA(_Symbol, PERIOD_CURRENT, InpSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);

   if(fastHandle == INVALID_HANDLE || slowHandle == INVALID_HANDLE)
   {
      Print("Could not create indicator handles, error ", GetLastError());
      return INIT_FAILED;
   }
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   if(fastHandle != INVALID_HANDLE) IndicatorRelease(fastHandle);
   if(slowHandle != INVALID_HANDLE) IndicatorRelease(slowHandle);
}

// Copies 'count' closed bar values (starting at bar 1) into out[].
// out[0] is the last closed bar. Returns false if data is not ready.
bool ReadClosedBars(const int handle, const int count, double &out[])
{
   int ready = BarsCalculated(handle);
   if(ready < count + 1)
      return false;

   ArraySetAsSeries(out, true);
   int copied = CopyBuffer(handle, 0, 1, count, out);
   if(copied != count)
   {
      PrintFormat("CopyBuffer returned %d of %d values, error %d",
                  copied, count, GetLastError());
      return false;
   }

   for(int i = 0; i < count; i++)
      if(out[i] == EMPTY_VALUE || out[i] == 0.0)
         return false;

   return true;
}

void OnTick()
{
   double fast[], slow[];

   if(!ReadClosedBars(fastHandle, 2, fast) ||
      !ReadClosedBars(slowHandle, 2, slow))
      return;   // indicator not ready yet, try on the next tick

   bool crossUp   = fast[1] <= slow[1] && fast[0] > slow[0];
   bool crossDown = fast[1] >= slow[1] && fast[0] < slow[0];

   if(crossUp)
      Print("Fast EMA crossed above slow EMA on the last closed bar");
   if(crossDown)
      Print("Fast EMA crossed below slow EMA on the last closed bar");
}

The zero check in the loop is a deliberate choice for a moving average, which can never be zero on a real price series. For an oscillator where zero is a legitimate value, remove it and rely on BarsCalculated and the copied count.

A note on other timeframes and symbols

If the handle is created on another timeframe or symbol, that history may not be loaded yet when the EA starts. BarsCalculated still protects you, but it can take longer. I also check SeriesInfoInteger(symbol, timeframe, SERIES_SYNCHRONIZED) before trusting a higher timeframe value, and log when the EA is waiting, so "no trades for the first two minutes" is explained in the journal instead of looking like a bug.

Testing it

The Strategy Tester rarely shows this problem, because history is prepared before the test starts. To reproduce it, attach the EA to a chart of a symbol you have not opened recently, or restart the terminal with the EA running, and watch the first lines of the Experts tab. With the guard in place you should see the EA wait rather than act on empty data.

Most "random bad trades after a restart" I have traced came down to one unchecked CopyBuffer call. It is a few lines of code to fix, and it removes a whole class of bugs that only appear on live charts.

Why your multi symbol MQL5 EA misses trades on every symbol except the chart one

Omais Ali — Tue, 20 Oct 2026 06:17:17 +0000

A common request I get is "one EA, attached to one chart, trading eight pairs". It is a good design, because one EA is easier to manage and can control total risk in one place. But the first version almost always has the same bug: it trades the chart symbol fine and misses or delays signals on the others.

Here is why, and how I structure these EAs now.

1. OnTick only fires for the chart symbol

OnTick runs when the symbol of the chart the EA is attached to gets a new tick. If the EA sits on EURUSD and GBPJPY moves, nothing happens until EURUSD ticks again. In a quiet EURUSD hour that can be many seconds.

The fix is to drive the logic from a timer instead:

string Symbols[] = {"EURUSD", "GBPJPY", "XAUUSD"};

int OnInit()
{
   for(int i = 0; i < ArraySize(Symbols); i++)
      if(!SymbolSelect(Symbols[i], true))
         Print("Cannot select ", Symbols[i]);
   EventSetTimer(1);
   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
}

void OnTimer()
{
   for(int i = 0; i < ArraySize(Symbols); i++)
      ProcessSymbol(Symbols[i]);
}

SymbolSelect matters too. A symbol that is not in Market Watch does not receive quotes, so the EA reads stale prices without any error.

2. History for other symbols may not be ready

For the chart symbol, the terminal keeps history loaded. For the others, the first CopyRates call can return fewer bars than you asked for, or fail, while the terminal downloads data. Check it before using the numbers:

bool DataReady(const string sym, ENUM_TIMEFRAMES tf, int need)
{
   if(!SeriesInfoInteger(sym, tf, SERIES_SYNCHRONIZED))
      return false;
   MqlRates r[];
   return CopyRates(sym, tf, 0, need, r) == need;
}

If it returns false, skip that symbol this cycle and try again on the next timer event. Do not fall back to zeros.

3. New bar detection has to be per symbol

A single lastBar variable is the classic mistake. Keep one per symbol and timeframe:

datetime LastBar[];

bool IsNewBar(int idx, const string sym, ENUM_TIMEFRAMES tf)
{
   datetime t = iTime(sym, tf, 0);
   if(t == 0) return false;
   if(t == LastBar[idx]) return false;
   LastBar[idx] = t;
   return true;
}

Resize LastBar to the number of symbols in OnInit.

4. Symbol properties differ, so read them per symbol

Gold, an index and a forex pair have different digits, tick sizes, minimum lots and stops levels. Any code that uses _Point, _Digits or Symbol() inside the loop is reading the chart symbol, not the one being traded. Use SymbolInfoDouble(sym, SYMBOL_POINT), SYMBOL_VOLUME_MIN, SYMBOL_VOLUME_STEP and friends for every calculation.

5. Control risk across all symbols, not per symbol

The advantage of one EA is that it can see total exposure. Before opening a new position, sum the risk of everything the EA already holds (by magic number) and refuse the trade if the total would cross your limit. Correlated pairs like EURUSD and GBPUSD can turn three "small" trades into one big one.

6. Test it like it will run

The Strategy Tester does support multi symbol EAs, but only the symbols you actually request get history. Run at least one test in "Every tick based on real ticks" mode, and compare the trade list per symbol with what you expect from the chart. Missing trades on the non chart symbols are the first sign that one of the issues above is still there.

Built this way, one EA can handle a whole basket reliably. Built the quick way, it trades one pair well and the rest by luck.

Detecting a new bar in MQL5 without missing one or firing twice

Omais Ali — Mon, 19 Oct 2026 06:17:13 +0000

Most Expert Advisors make their decisions once per bar, not on every tick. That sounds simple, and the usual snippet looks like this:

datetime lastBar = 0;

void OnTick()
{
   datetime current = iTime(_Symbol, PERIOD_CURRENT, 0);
   if(current == lastBar) return;
   lastBar = current;
   // new bar logic
}

It works on a chart in a quiet market. It breaks in four situations I see again and again in client code.

1. iTime can return 0

Right after the terminal starts, or when history for the symbol is still loading, iTime returns 0. The code above then stores 0, and on the next tick it sees a "new bar" that is really just the data arriving. Guard against it:

datetime current = iTime(_Symbol, PERIOD_CURRENT, 0);
if(current == 0) return;   // no data yet, try again on the next tick

2. The first tick after attaching

When you attach the EA, lastBar is 0, so the very first tick counts as a new bar even if the bar is already half finished. If your entry logic assumes it is running at the open of a bar, it will trade on a partial candle. Decide what you want explicitly. Usually that means recording the current bar in OnInit and waiting for the next one:

int OnInit()
{
   lastBar = iTime(_Symbol, PERIOD_CURRENT, 0);
   return(INIT_SUCCEEDED);
}

3. Gaps and quiet symbols

New bar logic is driven by ticks. If a symbol has no ticks for twenty minutes, an M5 EA skips several bars and then wakes up once. Code that counts bars ("exit after 6 bars") will be wrong. Count time instead, by comparing the bar open time of the entry with the current one using iBarShift, so skipped bars are still counted.

4. Multiple timeframes

An EA that trades M15 but filters on H1 often reuses one lastBar variable for both, or checks H1 with iTime on every M15 bar and assumes it changed. Keep one tracker per timeframe:

class CNewBar
{
   ENUM_TIMEFRAMES m_tf;
   datetime        m_last;
public:
   CNewBar(ENUM_TIMEFRAMES tf) : m_tf(tf), m_last(0) {}
   bool Check()
   {
      datetime t = iTime(_Symbol, m_tf, 0);
      if(t == 0 || t == m_last) return false;
      bool first = (m_last == 0);
      m_last = t;
      return !first;   // the first call only primes the tracker
   }
};

CNewBar barM15(PERIOD_M15), barH1(PERIOD_H1);

Testing it

Run the EA in the Strategy Tester with "Every tick based on real ticks" on a symbol with weekend gaps, and print a line every time Check() returns true. Then count the lines against the number of bars in the test window. If the numbers do not match, you have found the bug before your account did.

How do you handle new bar detection in your own EAs?