Want to develop your own trading indicators or EAs in MT4 but always get stuck on how to capture the lowest price of a candlestick? The MQL4 Low function is the key to achieving this, yet its usage and its difference from “iLow()” often confuse beginners. This article will guide you from zero, thoroughly explaining the core syntax for obtaining MT4 candlestick lows and providing practical examples to help you easily master this essential MT4 algorithmic trading syntax skill and take the first step toward automated trading.
In the MQL4 language, `Low` is not a traditional “function”, but a predefined time series array. You can think of it as a container filled with historical price data, specifically storing the lowest price of each candlestick. This array is built into MQL4 and can be used directly in your indicator, EA (Expert Advisor), or script without any additional declaration.
The syntax of the `Low[]` array is very straightforward. It uses an index value to access the lowest price of a specific candlestick. This index begins at 0 and represents different points in time:
This array stores price data in `double` format. For example, if you want to declare a variable to store the previous candlestick’s low, you can write:
double previousBarLow = Low[1];
Understanding this indexing rule is fundamental in learning MQL4 algorithmic trading syntax, because the same logic applies to other time series arrays such as `Open[]`, `High[]`, `Close[]`, and `Volume[]`.
Accessing the lowest price of different candlesticks is very simple, you only need to change the index value inside the brackets `[]`. Here are some common examples:
Use a loop to read the lows of the last 10 candlesticks:
for(int i = 1; i <= 10; i++)
{
Print(“The lowest price of the candlestick “, i, ” bars ago is: “, Low[i]);
This code prints the lowest price of each candlestick from the most recently closed bar going back 10 bars.
Now that the theory is clear, let’s move on to real application! After understanding the MT4 lowest-price indicator syntax, you can apply it to many trading strategies. Below are several practical examples to help you better understand how to use the `Low` array in real trading scenarios.
This simple indicator draws a small arrow at the lowest price of each candlestick, allowing you to visually identify recent support levels. This is very useful for observing price action or identifying potential entry points.
//+——————————————————————+
//| MarkLowestPoints.mq4 |
//| Copyright 2025, CashbackIsland |
//+——————————————————————+
#property copyright “Copyright 2025, CashbackIsland”
#property link “”
#property version “1.00”
#property strict
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 clrGold
//—- indicator buffers
extrn int LookbackPeriod = 20; // Set the number of candlesticks to mark
double ArrowBuffer[];
//+——————————————————————+
//| Custom indicator initialization function |
//+——————————————————————+
int OnInit()
{
//—- indicator buffers mapping
SetIndexBuffer(0, ArrowBuffer);
SetIndexStyle(0, DRAW_ARROW, STYLE_SOLID, 2);
SetIndexArrow(0, 233); // Set the arrow style
SetIndexLabel(0, “Lowest Point”);
//—- initialization done
return(INIT_SUCCEEDED);
}
//+——————————————————————+
//| Custom indicator iteration function |
//+——————————————————————+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//—-
int limit = rates_total – prev_calculated;
if(prev_calculated > 0) limit++;
for(int i = 0; i < limit && i < LookbackPeriod; i++)
{
ArrowBuffer[i] = Low[i]; // Place the arrow at the candlestick’s lowest price
}
//—- return value of prev_calculated for next call
return(rates_total);
}
//+——————————————————————+
Many trading strategies are based on price breakouts. For instance, when the price falls below the previous candlestick’s low, it may be a bearish signal. The following source code will trigger a pop-up alert when the price breaks below the previous low.
// Simple breakout alert EA example (place inside the OnTick() function)
void OnTick()
{
// Use a static variable to ensure the alert is sent only once
static datetime lastAlertTime = 0;
// Get the current price and the previous candlestick’s low
double currentPrice = Bid;
double previousLow = Low[1];
// Check the condition: current price breaks below the previous low,
// and the alert has not been triggered within the current candlestick
if(currentPrice < previousLow && Time[0] != lastAlertTime)
{
Alert(“Price Alert: “, Symbol(), ” current price “, currentPrice,
” has broken below the previous low “, previousLow, “!”);
lastAlertTime = Time[0]; // Update alert time to avoid repeated triggers
}
}
Once you have mastered `Low[]`, you can combine it with `High[]`, `Open[]`, and `Close[]` to perform deeper candlestick analysis. For example, calculating the length of the lower wick is very useful when assessing buying support strength in the market.
By analyzing these values, you can develop more complex trading logic, such as a strategy that “goes long when a hammer candle with a long lower wick appears”. If you want to learn more introductory concepts about MQL4, you can refer to the relevant teaching guides.
Once you have a basic understanding of the MQL4 Low function, you will soon encounter its “sibling” function `iLow()`. Although both can obtain the lowest price, their use cases and functionalities are vastly different. Understanding their differences is an important step in moving from a beginner to an advanced developer.
The core difference between the two lies in the flexibility of their data sources:
Choosing between `Low[]` and `iLow()` depends entirely on the needs of your strategy:
✅ Use `Low[]` when:
✅ You should use `iLow()` when:
In summary, `Low[]` solves “current” chart needs, while `iLow()` solves “any” chart needs. For beginners, mastering `Low[]` first and then gradually exploring the powerful capabilities of `iLow()` is a more stable learning path. If you are interested in developing more advanced EA trading systems, `iLow()` will be an indispensable tool.
A: Yes. `Low[0]` represents the lowest price of the current candlestick (which has not yet closed). As long as new tick data arrives, this value will update accordingly. Once the candlestick closes, the value of `Low[0]` becomes fixed and will shift to `Low[1]` when a new candlestick forms.
A: You need to loop through the `Low[]` array. You can simplify the process by using the built-in MQL4 `Lowest()` function. For example, to find the lowest price among the past 20 candlesticks starting from the previous bar, you can write: `int lowestBarIndex = Lowest(NULL, 0, MODE_LOW, 20, 1);` This returns the index of the candlestick that contains the lowest price, and you can then obtain that value using `Low[lowestBarIndex]`.
A: Functionally, there is no difference, but the execution logic is not the same. A script typically runs only once and then stops, so the `Low` values it reads are merely a snapshot of that moment. An EA, however, runs continuously inside the `OnTick()` function. Each time new market data arrives, `OnTick()` is triggered, allowing the EA to continuously obtain the latest `Low[0]` price for real-time decision-making.
A: If the index exceeds the amount of historical data currently loaded on the chart, reading `Low[i]` will return either 0 or an invalid value. When processing loops, it is best practice to check how many candlesticks the chart contains using variables such as `Bars` or `rates_total` to avoid accessing invalid data. This is an important habit in proper program design.
In summary, the `MQL4 Low` function (or more precisely, the `Low[]` array) is a fundamental tool that every MT4 algorithmic trading developer must master. Through this article, you have learned its basic syntax, how to read the lowest prices of candlesticks across different periods, practical application examples, and the key differences between Low[] and `iLow()`. Mastering the core syntax of MT4 lowest-price indicators is not difficult; the key lies in understanding the indexing logic behind them and practicing consistently. Now is the time to open your MetaEditor, review the official MQL4 documentation, and start writing your first indicator or trading strategy!
