How to Build a Daily Max Loss Protection System in MT5
Table of Contents
- Introduction
- What Is Daily Max Loss Protection
- Why Daily Max Loss Protection Matters for Traders and Investors
- Core Concepts
- Step-by-Step Guide
- Practical Tips for Better Results
- Common Mistakes to Avoid
- Frequently Asked Questions
- Conclusion
Introduction
On a volatile Thursday morning last month, the EUR/USD pair slipped 120 pips within ten minutes after an unexpected European Central Bank announcement. A day‑trader who had three half‑lot positions open at 08:00 GMT saw equity tumble from $10,000 to $9,750 before the protective script could intervene. The loss, modest in absolute terms, erased an entire day’s profit and forced a manual shutdown of the platform.
MetaTrader 5 (MT5) does not embed a daily loss ceiling by default. When a trader relies solely on manual monitoring, a single news shock can push an account into a margin call, especially in the CFTC‑regulated CFD market where leverage magnifies exposure. The following guide demonstrates how to build daily max loss protection that watches equity, closes or scales back positions, and blocks new orders once a preset loss threshold is reached. A complete code outline, testing workflow, and deployment checklist are provided so risk stays in check without sacrificing the ability to capture intraday opportunities.
What Is Daily Max Loss Protection?
Daily max loss protection is an automated rule set that caps the total dollar (or account‑currency) loss a trader can incur in a single trading day. The rule monitors real‑time equity, compares it to a pre‑defined loss limit, and triggers one of three actions—full close, partial liquidation, or order blocking—once the limit is breached.
For instance, a trader with a $20,000 account may set a $300 daily cap. If cumulative losses hit $300 at 09:45 GMT, the script instantly closes all open positions and disables further order entry until the next trading session begins.
Why Daily Max Loss Protection Matters for Traders and Investors
Professional prop desks, retail forex hobbyists, and CFD swing traders all face the same threat: a single adverse price move can erase weeks of profit. The Federal Reserve’s recent rate‑policy volatility has amplified intraday swings across S&P 500 futures and major currency pairs, making a loss‑cap more valuable than ever.
Leaving a daily loss ceiling off the table leaves the account exposed to margin calls from brokers regulated by the SEC or FCA. A well‑designed cap reduces the probability of forced liquidation, preserves capital for the next session, and aligns daily risk with the broader risk‑per‑trade framework that systematic traders already employ.
Equity‑Based Daily Loss Threshold — mechanism explained
The threshold is calculated as Initial Equity – Daily Loss Limit. When real‑time equity falls to or below this value, the script activates.
Scenario: A trader starts the day with $15,000 equity and sets a $250 loss limit. The trigger point is $14,750. At 10:12 GMT, a rapid GBP/JPY move pushes equity to $14,749. The script detects the breach and initiates the closure routine.
MQL5 Event‑Driven Script for Auto‑Close — mechanism explained
MQL5 provides the OnTick() event, which fires on every price update. By placing the equity check inside OnTick(), the system reacts within milliseconds, far quicker than a manual monitor.
Scenario: The same GBP/JPY trader’s script runs OnTick(). As soon as the tick that brings equity below $14,750 arrives, the script loops through all open positions, sends OrderClose() commands, and logs the action. The entire process completes before the next tick, limiting further loss.
Trailing Stop‑Loss Integration with Daily Cap — mechanism explained
A trailing stop can protect profits while the daily cap guards against catastrophic loss. The script first evaluates the daily loss condition; if the cap is not breached, it updates each position’s trailing stop based on a configurable distance (e.g., 30 pips).
Scenario: A swing trader holds a long EUR/USD position with a 30‑pip trailing stop. The market rallies, moving the stop up to lock in $120 profit. Later, a sudden reversal threatens the account. The daily cap check runs first; if the loss limit is still safe, the trailing stop continues to trail, otherwise the script bypasses the trailing update and proceeds to close.
Partial Position Liquidation Logic — mechanism explained
Instead of a blunt full close, the script can liquidate the largest losing position first, preserving a buffer for other trades. The logic sorts open orders by unrealized loss and closes them sequentially until the remaining equity sits just above the threshold.
Scenario: A day‑trader holds three positions: EUR/USD loss $180, USD/JPY loss $70, and AUD/CAD profit $30. The daily limit is $250, and equity sits $260 above the trigger. The script closes the EUR/USD position ($180 loss) first, leaving $80 margin before the cap, then halts new orders for the rest of the day.
Risk‑Per‑Day Calculator Using Account Leverage — mechanism explained
Leverage magnifies both profit and loss. The calculator derives a daily loss limit that respects the trader’s leverage ratio (e.g., 1:100) and desired risk percentage of the account.
Scenario: With $10,000 equity, 1:100 leverage, and a 2 % risk appetite, the calculator suggests a $200 daily loss cap. The script reads this value from an external .ini file, allowing the trader to adjust risk without recompiling the code.
Step-by-Step Guide
Below is a practical implementation roadmap. Code fragments are presented in plain MQL5 syntax; they can be copied directly into MetaEditor.
Step 1 — Define the loss threshold and parameters
Open a new MQL5 file in the MetaEditor. Declare global variables for DailyLossLimit, InitialEquity, and Leverage. Retrieve the current equity with AccountInfoDouble(ACCOUNT_EQUITY) and store it at the start of each trading day (midnight server time).
mql5
double DailyLossLimit = 250.0; // user‑defined in account currency
datetime DayStart = 0;
double InitialEquity = 0.0;
double Leverage = 0.0;
Add a function ResetDailyCounters() that runs on the first tick after midnight, resetting DayStart, InitialEquity, and Leverage. The function also reads the loss limit from an .ini file so the trader can tweak it without recompiling.
mql5
void ResetDailyCounters()
{
if(TimeCurrent() >= DayStart + 86400) // 24‑hour check
{
DayStart = TimeCurrent();
InitialEquity = AccountInfoDouble(ACCOUNT_EQUITY);
Leverage = AccountInfoDouble(ACCOUNT_LEVERAGE);
// Load DailyLossLimit from external file
DailyLossLimit = (double)FileReadDouble("settings.ini", "DailyLossLimit");
}
}
Step 2 — Implement the equity‑monitoring routine
Inside OnTick(), compute the current equity and compare it to the trigger level. If equity stays above the threshold, the script proceeds to update trailing stops; otherwise, it calls the loss‑protection routine.
mql5
void OnTick()
{
ResetDailyCounters();
double TriggerLevel = InitialEquity - DailyLossLimit;
double CurrentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
if(CurrentEquity <= TriggerLevel)
ExecuteLossProtection();
else
UpdateTrailingStops(30); // 30‑pip distance
}
UpdateTrailingStops() calculates the new stop price based on the current market price and the defined distance, then sends an OrderModify() request for each open position.
Step 3 — Build the loss‑protection engine
The engine decides whether to close positions fully, partially, or to block new orders. It respects the partial‑liquidation logic described earlier.
mql5
bool TradingHalted = false;
void ExecuteLossProtection()
{
// Sort positions by unrealized loss descending
int total = PositionsTotal();
if(total == 0) return;
// Simple bubble‑sort for illustration
for(int i=0; i<total-1; i++)
{
for(int j=i+1; j<total; j++)
{
double loss_i = PositionGetDouble(POSITION_PRICE_OPEN, i) - SymbolInfoDouble(Symbol(), SYMBOL_BID);
double loss_j = PositionGetDouble(POSITION_PRICE_OPEN, j) - SymbolInfoDouble(Symbol(), SYMBOL_BID);
if(loss_i < loss_j) // larger loss first
SwapPositions(i, j);
}
}
// Close positions until equity > trigger
double TriggerLevel = InitialEquity - DailyLossLimit;
double CurrentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
for(int k=0; k<total && CurrentEquity <= TriggerLevel; k++)
{
ulong ticket = PositionGetTicket(k);
if(!PositionClose(ticket))
Print("Failed to close ticket ", ticket);
CurrentEquity = AccountInfoDouble(ACCOUNT_EQUITY);
}
TradingHalted = true;
}
SwapPositions() is a helper that exchanges the order of two positions in the internal array; the exact implementation depends on the developer’s preferred data structure.
Step 4 — Block new orders after the cap is hit
In the OnTrade() event, reject any new order requests while TradingHalted is true, returning an error code to the platform.
mql5
void OnTrade()
{
if(TradingHalted)
{
// Reject new market orders
if(OrderSend(...) == false)
Print("Order rejected: daily loss limit reached.");
}
}
Step 5 — Test in the MT5 Strategy Tester
Compile the script and open the Strategy Tester. Choose a representative period that includes high‑volatility days—such as the week surrounding a Federal Reserve announcement. Verify that the script closes positions exactly when equity crosses the threshold, and that it respects the partial‑liquidation order. Adjust DailyLossLimit and trailing‑stop distance based on observed behavior. Pay special attention to slippage during news spikes; the tester can simulate realistic fill prices by enabling “Use real ticks”.
Step 6 — Deploy to a live account with a demo first
Start with a small demo account that mirrors the leverage and margin settings of your live account. Monitor the script’s logs for any missed ticks or unexpected order rejections. Once confidence builds, copy the compiled .ex5 file to the live terminal’s MQL5\Experts folder and enable auto‑trading. Keep the external .ini file in the same directory so you can adjust the loss limit on the fly.
Practical Tips for Better Results
- Synchronize the day reset with broker server time. Many brokers operate on GMT+2; a midnight reset in UTC may misalign with the actual trading session, causing the script to think the day has already started.
- Store parameters in an external
.inifile. This lets you tweak the loss limit without recompiling, useful when volatility spikes after a CFTC policy update. - Combine the daily cap with a per‑trade stop‑loss. The cap protects against aggregate loss, while individual stops limit each trade’s downside. Together they form a two‑layer safety net.
- Watch for spread widening during news. A sudden jump in the EUR/USD spread can cause the equity check to fire earlier than expected, so factor typical spread cost into the loss limit.
- Log every action with timestamps. A detailed audit trail simplifies dispute resolution with brokers regulated by the SEC or FCA and helps you fine‑tune the algorithm.
- Run a forward‑testing period of at least 30 days. This captures a range of market regimes, from low‑volatility drift to high‑impact news, and reveals any hidden timing issues.
- Consider a “grace period” after the cap is hit. A short 5‑minute window allows pending orders to settle before the script blocks new entries, reducing the chance of rejected market orders during rapid price moves.
- Validate the script on multiple symbols. Liquidity and tick frequency differ between, say, EUR/USD and a thinly traded exotic pair; testing across a basket ensures the logic holds under varying conditions.
- Monitor free margin, not just equity. Margin requirements can change during the day, especially when the broker adjusts leverage on volatile instruments. Keeping an eye on free margin helps you avoid surprise calls even if the daily loss cap has not been reached.
Common Mistakes to Avoid
- Hard‑coding the loss limit. Market conditions evolve; a static value can become either too tight, choking legitimate trades, or too lax, allowing excessive drawdown.
- Neglecting the weekend reset. Equity may stay below the trigger after a weekend gap, causing the script to block trading unnecessarily on Monday. Reset logic must fire on the first tick of the new server day.
- Relying solely on the daily cap without per‑trade stops. A single large loss can still breach the cap instantly, leading to a full account wipeout before the script reacts. Pairing the cap with individual stop‑losses mitigates this risk.
- Testing only on historical data without accounting for slippage. Real‑time execution may differ, especially during low‑liquidity periods on S&P 500 index futures. Include realistic slippage assumptions in the tester.
- Forgetting to handle partial fills. If an order is only partially filled, the script must calculate unrealized loss based on the actual volume, not the intended lot size. Ignoring this can produce inaccurate equity readings.
- Overlooking broker‑specific margin rules. Some brokers apply higher margin requirements for CFD positions during news events. The script should reference
ACCOUNT_MARGINto ensure the cap does not conflict with broker‑imposed limits.
How do I set a daily max loss limit in MT5?
Create an MQL5 script that records the account’s equity at the start of each trading day, subtracts your chosen loss amount, and compares the result to real‑time equity on every tick. When equity falls to or below the trigger, the script closes positions or blocks new orders.
What is the best way to automate daily loss protection in MT5?
Use an event‑driven OnTick() handler combined with a separate OnTrade() filter that rejects order requests after the loss threshold is breached. This dual‑layer approach ensures both existing positions are closed and new entries are prevented.
Why does my daily loss protection script stop working after a weekend?
If the script does not reset InitialEquity and the daily counter at the first tick after the weekend, the trigger level remains based on Friday’s equity. The script then believes the cap is already hit and blocks trading for the entire Monday session.
When should I reset the daily loss counter in MT5?
Reset at the broker’s server midnight, not the local clock. Use TimeCurrent() to detect the first tick after the new server day and re‑initialize InitialEquity and any flags.
Can I combine a daily max loss limit with a trailing stop?
Yes. Place the trailing‑stop update after the daily‑loss check in OnTick(). If the cap is not breached, the script adjusts each position’s stop price; if the cap is hit, the trailing‑stop routine is skipped and the script proceeds to close or liquidate.
Is a daily max loss limit enough to prevent margin calls?
A daily cap reduces the probability of a margin call, but it does not guarantee safety. Extreme gaps, overnight swaps, or broker‑specific margin requirements can still trigger a call if the account’s free margin falls below the required level. Complement the cap with adequate margin buffers and per‑trade risk limits.
Conclusion
The core lesson is simple: an automated equity‑based daily loss cap gives you a hard stop on aggregate drawdown, preserving capital for the next session while letting you stay in the market during normal volatility. Your next step is to copy the code skeleton into MetaEditor, configure the loss limit to match your risk appetite, and run a 30‑day forward test on a demo account that mirrors your live leverage.
Remember, no script can eliminate risk entirely. Use the daily max loss system as part of a broader risk‑management framework that includes position sizing, stop‑losses, and ongoing market analysis. Trade responsibly, and let the protection mechanism do the heavy lifting when markets turn sharp.
—
This article is for educational purposes only and does not constitute investment advice. Trading and investing carry risk of loss; never invest more than you can afford to lose.
Last reviewed: August 2026
