Home » How to Write an Expert Advisor (EA) for MT4

Guides

How to Write an Expert Advisor (EA) for MT4

Investing Robots

April 17, 2026

A Comprehensive Guide on How to Write an Expert Advisor (EA) for MT4

MetaTrader 4 (MT4) is one of the most popular trading platforms used by retail traders worldwide. It allows users to write custom scripts and automated trading strategies known as Expert Advisors (EAs). Writing an EA for MT4 enables traders to automate their strategies, eliminating the need for manual intervention and allowing for more efficient and precise execution of trades. This guide will provide a step-by-step process for writing an Expert Advisor for MT4, including all the necessary information, concepts, and coding techniques.

Table of Contents

1. Introduction to Expert Advisors (EAs)
   • What is an Expert Advisor?
   • Why Use an EA in Trading?
   • Structure of an EA
2. Setting Up Your Environment for EA Development
   • Installing MetaTrader 4
   • Installing MetaEditor
   • Overview of the MT4 Interface
   • Setting Up a Demo Account for Testing
3. Understanding the MQL4 Programming Language
   • Basics of MQL4 Syntax
   • Data Types and Variables
   • Functions in MQL4
   • Operators in MQL4
   • Control Flow: If Statements, Loops, etc.
4. Structure of an Expert Advisor
   • Main Functions in an EA
   • The OnInit() Function
   • The OnTick() Function
   • The OnDeinit() Function
5. Writing Your First Expert Advisor
   • Basic EA Structure Example
   • Placing Orders Programmatically
   • Managing Orders: Opening, Closing, and Modifying Orders
6. Risk Management in EAs
   • Calculating Position Size
   • Stop Loss and Take Profit
   • Trailing Stops and Break-even Strategies
   • Risk-to-Reward Ratio and Money Management
7. Handling Trading Logic
   • Building Simple Trading Strategies
   • Indicators and Their Use in EAs
   • Moving Averages, RSI, MACD, and Other Indicators
   • Combining Multiple Indicators for Complex Strategies
8. Backtesting Your Expert Advisor
   • The Importance of Backtesting
   • Setting Up Backtesting in MT4
   • Interpreting Backtest Results
   • Improving Your EA Based on Backtest Data
9. Debugging and Optimizing Your EA
   • Common Errors and How to Fix Them
   • Debugging in MetaEditor
   • Using Print Statements for Troubleshooting
   • Optimizing Performance and Execution Speed
10. Advanced Features of Expert Advisors
    • Trading with News Events
    • Multi-Timeframe Analysis
    • Incorporating External Data and APIs
    • Complex Risk Management Techniques
    • Integrating Machine Learning Models
11. Testing and Refining Your Expert Advisor
    • Using Forward Testing to Verify Real-World Performance
    • Walk-Forward Optimization
    • Risk and Performance Metrics
12. Conclusion
    • Final Thoughts on Writing Expert Advisors
    • Continuous Improvement and Updates
    • Further Resources and Learning Materials

1. Introduction to Expert Advisors (EAs)

What is an Expert Advisor?

An Expert Advisor (EA) is a program written in the MQL4 (MetaQuotes Language 4) programming language that automatically executes trading operations based on predefined conditions. These conditions can be based on market analysis, technical indicators, time, or even news events. EAs enable traders to automate their strategies, ensuring trades are executed without emotional bias or delay.

Why Use an EA in Trading?

The main advantages of using an Expert Advisor are automation, efficiency, and consistency. Once an EA is programmed and optimized, it can execute trades based on pre-determined rules, even when the trader is not at the computer. This removes the need for constant monitoring of the markets and reduces the likelihood of missing opportunities. EAs also enable backtesting, which allows traders to evaluate a strategy’s historical performance before going live.

Structure of an EA

An EA consists of a series of functions and commands that dictate how it operates. The core functions in an EA are the OnInit(), OnTick(), and OnDeinit() functions, but more complex EAs can include additional functions for handling different tasks such as managing orders or calculating indicators.

2. Setting Up Your Environment for EA Development

Installing MetaTrader 4

MetaTrader 4 is the platform where you will run and test your EAs. You can download it from your broker’s website or from MetaQuotes’ official site. After installation, make sure to create a demo account for testing your EAs in a risk-free environment.

Installing MetaEditor

MetaEditor is the integrated development environment (IDE) used to write, compile, and debug MQL4 code. It comes bundled with the MetaTrader 4 installation. Open MetaEditor from the MT4 platform and begin writing your code in the editor.

Overview of the MT4 Interface

MT4 features a clean and intuitive interface with windows for charts, indicators, and trading data. Familiarizing yourself with the navigation of these windows is important when working with EAs, as you will need to monitor the performance of your EA in real-time.

Setting Up a Demo Account for Testing

Before running your EA live, always test it on a demo account. This allows you to simulate real market conditions without the risk of losing actual capital. To set up a demo account, go to “File” in the MT4 platform, select “Open an Account,” and follow the prompts.

3. Understanding the MQL4 Programming Language

Basics of MQL4 Syntax

MQL4 is similar to the C programming language, making it relatively easy to learn for those familiar with programming. It includes various data types like int, double, string, and bool, and supports functions, loops, and control structures.

Data Types and Variables

In MQL4, you will often work with several data types. The most common ones include:

• int: Integer values (e.g., 10, -5).
• double: Floating-point numbers (e.g., 3.14, 100.75).
• string: Text data (e.g., “Hello World”).
• bool: Boolean values (true or false).

Variables are declared by specifying the data type followed by the variable name. Example:

int myVariable;
double accountBalance;
string tradingSignal;

Functions in MQL4

Functions are the building blocks of an EA. MQL4 allows you to define custom functions that can be called to execute certain tasks. Functions can return values or be used for side effects.

Example:

double CalculateLotSize(double balance, double risk) {
   return balance * risk / 100;
}

Operators in MQL4

Operators in MQL4 include basic arithmetic operators (+, -, *, /), comparison operators (==, !=, >, <), and logical operators (&&, ||, !).

Control Flow: If Statements, Loops, etc.

MQL4 supports standard control flow structures like if statements and loops (for, while). These are essential for setting up decision-making in your EA, such as when to buy or sell based on certain conditions.

Example of an if statement:

if (MarketInfo(Symbol(), MODE_SPREAD) > 5) {
   Print("The spread is too high.");
}

4. Structure of an Expert Advisor

Main Functions in an EA

1. OnInit(): This function is called when the EA is first loaded onto a chart. It is used to initialize variables, set parameters, and establish other settings.
2. OnTick(): This function runs every time the market price changes. It is where the bulk of your trading logic will go, as this is where the EA decides when to enter or exit a trade based on the market conditions.
3. OnDeinit(): This function is called when the EA is removed from the chart or when MetaTrader is closed. It can be used for cleanup tasks, like closing open files or releasing memory.

Example Code for Basic EA Structure:

int OnInit() {
   // Initialization code
   return(INIT_SUCCEEDED);
}
void OnTick() {
   // Trading logic goes here
}
void OnDeinit(const int reason) {
   // Cleanup code
}

5. Writing Your First Expert Advisor

Basic EA Structure Example

A simple EA could be created that buys when the price crosses above a moving average and sells when it crosses below. Here’s how you might structure that:

int maPeriod = 14;
double maPrevious, maCurrent;
int OnInit() {
   // Initialization
   return(INIT_SUCCEEDED);
}
void OnTick() {
   maPrevious = iMA(Symbol(), 0, maPeriod, 0, MODE_SMA, PRICE_CLOSE, 1);
   maCurrent = iMA(Symbol(), 0, maPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
   
   if (Close[0] > maCurrent && Close[1] <= maPrevious) {
      // Buy condition
      if (OrderSend(Symbol(), OP_BUY, 0.1, Ask, 2, 0, 0, "Buy Signal", 0, 0, clrGreen) < 0) {
         Print("Error opening buy order: ", GetLastError());
      }
   } 
   else if (Close[0] < maCurrent && Close[1] >= maPrevious) {
      // Sell condition
      if (OrderSend(Symbol(), OP_SELL, 0.1, Bid, 2, 0, 0, "Sell Signal", 0, 0, clrRed) < 0) {
         Print("Error opening sell order: ", GetLastError());
      }
   }
}

This basic EA will buy when the current close price crosses above the moving average and sell when it crosses below.

Placing Orders Programmatically

In an EA, placing orders is a key task. The function OrderSend() is used to open new positions. It requires several parameters, including the symbol, order type (buy or sell), lot size, and slippage. Here’s a breakdown of how to use it:

int ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 2, 0, 0, "Buy Signal", 0, 0, clrGreen);

This opens a buy order for 0.1 lots at the current Ask price.

6. Risk Management in EAs

Risk management is an essential part of creating a successful EA. Some of the most important aspects include calculating position size, setting stop losses and take profits, and using trailing stops.

Calculating Position Size

Position size is determined by the trader’s risk tolerance, account size, and stop loss. Here’s an example function to calculate position size based on risk percentage:

double CalculateLotSize(double riskPercentage, double stopLoss) {
   double riskAmount = AccountBalance() * (riskPercentage / 100);
   double lotSize = riskAmount / (stopLoss * MarketInfo(Symbol(), MODE_POINT));
   return NormalizeDouble(lotSize, 2);  // Normalize to 2 decimal places
}

This function helps ensure that each trade risks only a small percentage of the trader’s total account balance.

Stop Loss and Take Profit

You can define the stop loss (SL) and take profit (TP) levels using the OrderSend() function. These levels are crucial for limiting losses and locking in profits.

Example:

OrderSend(Symbol(), OP_BUY, 0.1, Ask, 2, Ask - 50 * Point, Ask + 100 * Point, "Buy Order", 0, 0, clrBlue);

This example sets a stop loss 50 pips below the entry price and a take profit 100 pips above the entry price.

Trailing Stops and Break-even Strategies

A trailing stop moves the stop loss level as the market price moves in your favor. It can help lock in profits while allowing the trade to remain open for further gains.

Example:

if (OrderSelect(ticket, SELECT_BY_TICKET)) {
   double currentStopLoss = OrderStopLoss();
   double currentPrice = Bid;  // For a sell order
   if (currentPrice < OrderOpenPrice() - 50 * Point) {
      OrderModify(ticket, OrderOpenPrice(), currentPrice - 50 * Point, OrderTakeProfit(), 0, clrRed);
   }
}

7. Handling Trading Logic

Building Simple Trading Strategies

A simple trading strategy might be based on a single moving average crossover. However, more sophisticated strategies often combine multiple indicators, such as RSI, MACD, and stochastic oscillators, to filter signals and reduce false positives.

8. Backtesting Your Expert Advisor

Backtesting is a crucial part of EA development. It helps you see how the EA would have performed historically with past data. You can use MT4’s Strategy Tester to run backtests on your EA.

Setting Up Backtesting in MT4

1. Go to View > Strategy Tester in MT4.
2. Select your EA from the drop-down menu.
3. Choose the currency pair, time frame, and date range for the backtest.
4. Click Start to run the backtest.

Interpreting Backtest Results

Backtesting will provide various metrics like net profit, drawdown, and win rate. Analyzing these results helps identify whether the strategy is profitable or if it needs adjustments.

9. Debugging and Optimizing Your EA

When developing an EA, debugging and optimization are key to ensuring smooth operation. You can use Print() statements to log information and diagnose problems.

Optimizing Performance

You can optimize your EA by testing different parameters, such as moving average periods or stop loss distances. MT4 provides an optimization feature that allows you to test multiple combinations of parameters and identify the most profitable ones.

10. Advanced Features of Expert Advisors

As you get more experienced, you can incorporate advanced features like trading based on news events, multi-timeframe analysis, or even machine learning models for predictive trading.

11. Testing and Refining Your Expert Advisor

Forward Testing

Forward testing involves running the EA in a demo account with real-time data to ensure it works in live market conditions.

Walk-Forward Optimization

This technique helps refine your EA’s parameters by testing it on different periods of historical data and adapting it to changing market conditions.

12. Conclusion

Writing an Expert Advisor for MT4 is an exciting and rewarding process that allows traders to automate their strategies and improve their trading performance. By understanding MQL4, structuring your EA properly, implementing risk management, and backtesting thoroughly, you can create a robust automated trading system. Continuous testing, optimization, and refinement will help ensure that your EA performs well in different market conditions.