EA Development (MQL4/MQL5), MT4/MT5 Expert Advisors

Debug MQL4 Code in MT4: Complete Step-by-Step Guide

Posted by

Debugging Expert Advisors (EAs) can feel frustrating when trades don’t trigger, logic seems broken, or results don’t match your expectations. Knowing how to debug mql4 code in mt4 expert advisors turns that frustration into a clear, systematic process.

In this guide, you’ll learn practical, repeatable methods to find and fix bugs using MetaEditor, MT4 Strategy Tester, log files, and clean coding practices. Whether you’re just starting with MQL4 or you’ve already built several EAs, this walkthrough will help you debug faster and ship more stable trading robots.

H2: Understanding the Basics Before You Debug

H3: What Is an MT4 Expert Advisor (EA)?

An Expert Advisor is an automated trading program written in MQL4 that runs inside the MetaTrader 4 platform. It can:

Open, modify, and close trades.
Monitor price feeds in real time.
Apply custom indicators or logic.
Manage risk based on your rules.

Because an EA runs automatically, even a small bug can repeat many times and cause big losses. That’s why a solid debugging process is essential.

H3: How MQL4 Code Runs Inside MT4

Most EAs are driven by special functions:

OnInit() – runs once when the EA is loaded.
OnDeinit() – runs when the EA is removed or the terminal shuts down.
OnTick() – runs every time a new tick (price update) arrives.

Your trade logic, risk checks, and indicator calculations usually live inside OnTick(). If something goes wrong here, it may affect every tick, so debugging this flow is one of your main tasks.

H3: Common Bug Types in Expert Advisors

Some of the most common issues include:

Logic errors – wrong conditions, misplaced if or else, incorrect comparisons.
Order handling errors – failing OrderSend, wrong magic numbers, or ticket mix-ups.
Timeframe/symbol errors – using the wrong symbol or timeframe in functions.
Initialization errors – indicators not created, buffers not set, or parameters not checked.
Performance problems – heavy loops or repeated calculations slowing down MT4.

Knowing these categories helps you guess where to look when something misbehaves.

H2: Essential Setup for Debugging in MetaTrader 4

H3: Enabling the MetaEditor and Connecting to MT4

MetaEditor is the official editor for MQL4. To start:

Open MT4.
Click the MetaEditor icon (or press F4).
Make sure MT4 and MetaEditor are connected. When you compile in MetaEditor, the EA becomes available in MT4’s Navigator → Expert Advisors.

This integration is what lets you edit, compile, and test in a tight loop.

H3: Compiling Your MQL4 Code Without Errors

Before debugging logic, you must compile without syntax errors:

In MetaEditor, open your .mq4 file.
Press F7 to compile.
Fix all Errors first; Warnings can often be tolerated, but ideally, you should resolve them too.

Compilation checks:

Missing semicolons.
Incorrect variable types.
Wrong function signatures.
Unrecognized identifiers.

A clean compile doesn’t mean there are no bugs, but it’s your first gate.

H3: Organizing Your Project Files and Folder Structure

MT4 expects files in specific folders:

MQL4/Experts – for EAs.
MQL4/Indicators – for custom indicators.
MQL4/Include – for shared .mqh files.

Keep your project tidy:

Separate reusable logic into .mqh includes.
Group related EAs in subfolders.
Use clear file names, e.g., EA_MeanReversion.mq4, RiskManagement.mqh.

A clean structure makes debugging easier when your EA grows.

H2: Core Techniques: how to debug mql4 code in mt4 expert advisors

This is where you start actively investigating what your code is doing.

H3: Using Print() Statements for Simple Logging

The simplest debugging tool is the Print() function. Example:

Print("Ask = ", Ask, "  Bid = ", Bid);
Print("Current lot size: ", Lots, "  StopLoss: ", sl, "  TakeProfit: ", tp);

These messages appear in the Experts tab (and sometimes in the logs folder). You can:

Confirm whether a piece of code is reached.
See variable values at key moments.
Track the flow of logic with labeled messages like Print("Step 1: Entry checks passed");.

Use Print() generously during development, then remove or reduce them later.

H3: Tracing Variable Values and EA Flow with Logs

MT4 logs help you reconstruct what happened:

Experts tab – shows EA-specific messages.
Journal tab – shows platform-wide events.
Log files are stored under the logs folder in your MT4 data directory.

A useful pattern is to tag logs:

Print("[CHECK_ENTRY] Condition met, trying to open BUY order");
Print("[ERROR_ORDER] OrderSend failed, error = ", GetLastError());

This way, you can filter quickly and follow the sequence of events.

H3: Handling Errors and Return Codes in Trade Functions

Trade functions like OrderSend and OrderModify return values you must check:

int ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, sl, tp, "EA Test", Magic, 0, clrNONE);
if(ticket < 0)
{
   int err = GetLastError();
   Print("OrderSend failed with error #", err);
   // Optional: handle or retry depending on error
}

By logging error codes, you can search what they mean in the MQL4 documentation (for reference, see the official docs on the MetaQuotes site). This is a crucial part of learning how to debug mql4 code in mt4 expert advisors responsibly and safely.

Using the MT4 Strategy Tester for Deeper Debugging

Backtesting Your Expert Advisor Step by Step

The Strategy Tester lets you run your EA on historical data:

Press Ctrl+R in MT4.
Select your EA, symbol, and timeframe.
Choose the date range and model.
Click Start.

Backtesting lets you:

See whether trades would have opened.
Check if the EA respects stop loss and take profit.
Verify your logic across many market conditions.

Visual Mode vs Non-Visual Mode in Strategy Tester

Non-Visual Mode is faster and good for performance and statistical debugging.
Visual Mode shows price charts and trade arrows in real time.

In Visual Mode, you can:

Watch when trades open and close.
Pause and rewind the simulation.
Confirm whether conditions match what you coded.

This makes it easier to spot mismatches between expectation and reality.

Checking Trade History, Journal, and Report Tabs

After a test:

Results tab – lists each trade.
Graph tab – shows the balance/equity curve.
Report tab – summarizes performance metrics.
Journal tab – records system and error messages.

Look for:

Unexpected gaps in trading.
Repeated errors (e.g., invalid stops, not enough money).
Patterns in losing trades that indicate logic issues.

Debugging with MetaEditor: Breakpoints and Step Execution

Running the Built-in Debugger in MetaEditor

MetaEditor has a built-in debugger that lets you:

Run the EA in debug mode.
Pause execution at specific lines.
Inspect variables.

Typical steps:

In MetaEditor, open your EA.
Set a breakpoint by clicking in the margin next to a line.
Click the Debug button or press F5.
Select the symbol and timeframe to debug.

The EA then starts under the debugger.

Setting Breakpoints and Watching Variables

Breakpoints allow you to stop your EA when:

A certain function runs.
A suspected buggy line is reached.
You want to inspect values right before a trade.

Once stopped, you can:

Hover over variables to see values.
Use the Watch window to track specific variables.
Step line by line to understand the order of execution.

Stepping Through OnTick, OnInit, and OnDeinit Logic

You can step through:

OnInit() to ensure parameters, indicators, and variables initialize correctly.
OnTick() to verify entry conditions, trade placement, and risk calculations.
OnDeinit() to ensure cleanup is done properly.

Stepping line by line is slower than using Print(), but it gives you extremely precise control over the debugging process.

Diagnosing Common EA Issues in MQL4

EA Not Opening Trades

If the EA never opens trades:

Check whether AutoTrading is enabled.
Confirm that the EA is attached to the correct chart and timeframe.
Add logs to verify if your entry conditions ever evaluate as true.
Ensure OrderSend is actually called (log before and after the call).
Check that lot size, stop loss, and take profit obey broker rules.

EA Opening Too Many or Wrong Trades

When trades are out of control:

Verify that you use a magic number to identify EA orders.
Add conditions to prevent repeated entries on the same bar, if needed.
Confirm that you close orders only once and don’t reopen immediately.
Check your if conditions for logical mistakes (e.g., using || instead of &&).

EA Crashes, Freezes, or Stops Unexpectedly

Crashes can come from:

Division by zero.
Accessing arrays out of range.
Overly heavy loops in OnTick().
Infinite loops or recursion.

Add checks like:

if(volume != 0)
   ratio = price / volume;
else
   Print("Warning: volume is zero, skipping ratio calculation");

And always confirm array indexes are within bounds.

Best Practices for Clean and Debuggable MQL4 Code

Writing Readable, Modular Functions

Split your EA into small functions:

bool CheckEntryConditions();
void OpenBuyOrder();
void OpenSellOrder();
void ManageOpenPositions();

This makes your code:

Easier to read.
Easier to debug.
Easier to reuse.

Using Constants, Enums, and Meaningful Names

Avoid “magic numbers” directly in code. Use:

#define MAGIC_EA_ID 123456
#define MAX_TRADES  5

Use descriptive variable names like maxRiskPerTrade instead of r or x. This reduces confusion when you come back to the code weeks or months later.

Commenting and Versioning Your EA Code

Add comments that explain why, not just what:

// Prevent multiple entries on the same bar
if(lastEntryTime == Time[0]) return;

Use version numbers in the file header and consider basic version control (e.g., Git or even renamed files with dates) to track changes.

Advanced Debugging Methods and Tools

Logging to Files for Long-Term Analysis

For complex EAs, Print() might not be enough. You can write to files:

int handle = FileOpen("EA_Log.csv", FILE_CSV|FILE_WRITE|FILE_READ, ';');
if(handle != INVALID_HANDLE)
{
   FileSeek(handle, 0, SEEK_END);
   FileWrite(handle, TimeToStr(TimeCurrent(), TIME_DATE|TIME_SECONDS), Bid, Ask, Lots);
   FileClose(handle);
}

This lets you:

Analyze logs later in Excel.
Collect large amounts of data without cluttering the Experts tab.
Keep permanent records of EA behavior.

Using Global Variables of the Terminal for State Tracking

MT4 has Global Variables of the Terminal, visible via Tools → Global Variables:

GlobalVariableSet("EA_LastTradeTime", TimeCurrent());
double value = GlobalVariableGet("EA_LastTradeTime");

These variables persist even if MT4 restarts, so they’re handy for:

Tracking state between sessions.
Debugging multi-session behavior.
Sharing simple flags across charts.

Profiling Performance and Optimizing Slow EAs

If MT4 becomes slow:

Look for heavy calculations inside OnTick().
Cache indicator values instead of recalculating them every tick.
Avoid nested loops over large histories.

Optimization isn’t just about speed; a faster EA is easier to debug because it behaves more predictably under load.

Testing on Demo Accounts Before Going Live

Attaching the EA to Charts and Monitoring Behavior

On a demo account:

Drag your EA onto a chart.
Check the smiley face at the top-right of the chart (indicates the EA is active).
Watch how it behaves over time.

Make sure your EA:

Opens trades when expected.
Manages stops correctly.
Handles different market sessions (Asian, London, New York).

Reading the Experts and Journal Tabs in Real Time

While the EA runs:

The Experts tab shows messages from your EA.
The Journal tab shows platform, server, and connection messages.

Keep an eye on:

Repeated errors (e.g., invalid stops, no connection).
Trade rejections from the broker.
Unexpected restarts or reinitializations.

Handling Different Brokers, Spreads, and Execution Speeds

Different brokers have different:

Minimum lot sizes.
Stop level distances.
Spreads and execution speeds.

So always:

Use checks for MarketInfo(Symbol(), MODE_STOPLEVEL) and other broker settings.
Test on multiple demo servers if possible.
Avoid hardcoding assumptions that might fail on another broker.

Security, Stability, and Risk Control While Debugging

Protecting Live Accounts During EA Tests

Don’t debug on a live account with big money. Instead:

Use demo accounts.
If you must use live, trade tiny lot sizes.
Set maximum drawdown alerts and close EA if thresholds are hit.

Using Lot Size Limits and Safety Checks

Always validate inputs:

if(Lots < 0.01) Lots = 0.01;
if(Lots > 1.0) Lots = 1.0; // Safety cap

You can also implement:

Max number of open trades.
Daily loss limits.
Equity-based shutdown rules.

Handling Network Errors and Requotes Gracefully

When OrderSend fails with certain errors (like requotes or off quotes), you may retry or log and skip:

int err = GetLastError();
if(err == ERR_OFF_QUOTES || err == ERR_REQUOTE)
{
   Print("Temporary error, will retry later. Error #", err);
   // maybe implement a retry delay
}

This makes your EA more stable in real-world market conditions.

FAQ – how to debug mql4 code in mt4 expert advisors

1. Why doesn’t my EA take any trades at all?

Common reasons:

AutoTrading is disabled.
The EA isn’t attached to the right chart/timeframe.
Entry conditions are never true (logic error).
Lot size or stops violate broker rules.
OrderSend fails but you aren’t checking or logging the error.

Add Print() statements around your entry logic and around OrderSend to see what’s actually happening.

2. How do I see the output of Print() in MT4?

Open the Terminal window (Ctrl+T) and go to the Experts tab. All Print() messages from your EA show up there with timestamps. You can also inspect log files in the terminal’s data folder under logs.

3. Can I step through my EA line by line like in other programming IDEs?

Yes. Use the MetaEditor debugger:

Open the EA in MetaEditor.
Set a breakpoint.
Press F5 to start debugging.
Use step buttons to move through the code.

This helps you inspect variables and follow the execution path precisely.

4. How can I find out why OrderSend fails?

Always capture the return value:

int ticket = OrderSend(...);
if(ticket < 0)
{
   int err = GetLastError();
   Print("OrderSend failed, error #", err);
}

Then look up the error code in the official MQL4 documentation on MetaQuotes’ site for a detailed explanation and suggested fixes.

5. Should I debug using real or demo accounts?

Always start with demo. Once your EA is stable and tested through backtests and forward tests, you can move to live accounts with small lot sizes. Debugging directly on live with large risk is dangerous and unnecessary.

6. What’s the best way to keep track of complex EA behavior over many days?

Use a combination of:

Print() for quick checks.
File logging (FileOpen, FileWrite) for long-term, structured data.
Strategy Tester logs for historical analysis.

You can export logs as CSV and open them in Excel or similar tools for deeper analysis.

Conclusion: Building Reliable and Profitable MT4 Expert Advisors

Learning how to debug mql4 code in mt4 expert advisors is one of the most valuable skills you can develop as an EA developer. Instead of guessing why trades fail, you now have a toolkit:

Print() and logs for quick insights.
Strategy Tester for controlled historical testing.
MetaEditor’s debugger for step-by-step inspection.
Clean coding practices for easier maintenance.
File logs, global variables, and performance checks for advanced scenarios.

By combining these methods and always testing on demo first, you can catch bugs early, protect your capital, and steadily improve the reliability and profitability of your trading robots.

Advanced Variable products with swatches

Recent Posts