How to Write an Expert Advisor (EA) for MT5

May 23, 2026

Detailed Guide on Writing an Expert Advisor (EA) for MetaTrader 5 (MT5)

Writing an Expert Advisor (EA) for MetaTrader 5 (MT5) involves creating automated trading strategies using the MQL5 programming language. This guide provides a detailed, step-by-step process for writing an EA for MT5, starting with the basic concepts and moving toward more advanced functionalities. By the end, you should be able to create and modify EAs tailored to your trading needs.

Introduction to Expert Advisors (EAs)
Getting Started with MetaTrader 5
Understanding MQL5 Language
Setting Up MetaEditor
Creating a Basic EA Template
Core Functions of an EA
Trading Logic and Strategy
Implementing Order Execution
Risk Management in EAs
Backtesting and Optimization
Error Handling and Debugging
Advanced EA Features
Final Tips and Best Practices
Conclusion

1. Introduction to Expert Advisors (EAs)

An Expert Advisor (EA) is a program that runs within the MetaTrader 5 (MT5) trading platform to automate trading activities. EAs are designed to execute trades based on predefined conditions such as technical indicators, price patterns, or other market data. Writing an EA allows you to automate your strategy, potentially increasing efficiency and eliminating emotional biases in decision-making.

An EA consists of three main components:

Indicators: Used to identify market conditions.
Logic/Conditions: Defines when the EA will enter or exit a trade.
Order Execution: Manages the actual trading process (e.g., sending buy/sell orders to the broker).

In MT5, EAs are written in MQL5, a C-like programming language that provides a range of functions to interact with the trading environment.

2. Getting Started with MetaTrader 5

Before you can start writing EAs, you need to install MetaTrader 5. Here are the steps:

Download and Install MT5: Visit the MetaTrader 5 website or your broker’s platform page and download the installation file. Follow the on-screen instructions to install it on your computer.
Open MT5: Once installed, launch MetaTrader 5.
Access the MetaEditor: Press F4 to open the MetaEditor, the integrated development environment (IDE) used for writing and compiling MQL5 code.

MetaTrader 5 also supports other trading tools, such as custom indicators, scripts, and libraries, which you can integrate into your EA.

3. Understanding MQL5 Language

MQL5 (MetaQuotes Language 5) is the programming language used to write EAs for MetaTrader 5. It’s an object-oriented language that is similar to C++ but with specific functions designed for financial market data and trading operations.

Key features of MQL5 include:

Strong Object-Oriented Programming (OOP) Support: MQL5 allows for the creation of classes and objects, promoting clean, modular, and reusable code.
Event-Driven Programming: EAs in MT5 are event-driven, meaning they execute code based on market events such as price movements or time-based intervals.
Built-in Trading Functions: MQL5 comes with built-in functions for order management, data retrieval, technical analysis, and more.

MQL5 provides essential functions for EAs, such as OrderSend(), OrderClose(), and iMA() for moving averages. The language also supports custom indicators and scripts to enhance trading strategies.

4. Setting Up MetaEditor

MetaEditor is the coding environment used for writing and compiling MQL5 code. Follow these steps to set it up:

Open MetaEditor: Press F4 in MT5 or click on “MetaEditor” from the toolbar.
Create a New EA: In MetaEditor, go to File > New and select “Expert Advisor” from the wizard. The wizard will guide you in creating a basic EA template.
File Structure: A new EA template will be generated with basic functions like OnInit(), OnDeinit(), and OnTick() already defined. These functions are essential for running your EA.

5. Creating a Basic EA Template

The fundamental structure of any EA consists of three main functions:

OnInit(): This function is executed when the EA is initialized. It is used for setting up resources or performing any setup tasks before the EA starts.
OnDeinit(): This function is executed when the EA is removed from the chart or MetaTrader is shut down. It handles any cleanup tasks, such as closing files or releasing resources.
OnTick(): This function is triggered every time there is a price change. It is where most of your trading logic and execution code will be written.

Here’s a simple template for an EA:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   Print("EA Initialized");
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Print("EA Removed");
  }
//+------------------------------------------------------------------+
//| Expert tick function (this is called when new tick data arrives) |
//+------------------------------------------------------------------+
void OnTick()
  {
   // Example of trading logic
   if (MarketInfo(Symbol(), MODE_ASK) > 1.2000)
     {
      Print("Price is above 1.2000");
     }
  }

This template will output a message when the EA is initialized and removed and checks if the current ask price is above 1.2000.

6. Core Functions of an EA

An EA’s primary job is to execute trades based on conditions you define. To do this, you need to use several core functions:

OrderSend(): Places a new order. int ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0, "Buy Order", 0, 0, Blue);
OrderClose(): Closes an open order. bool result = OrderClose(ticket, 0.1, Bid, 3, CLR_NONE);
iMA(): Returns the value of a moving average. double maValue = iMA(Symbol(), PERIOD_M15, 14, 0, MODE_SMA, PRICE_CLOSE, 0);

These functions are the building blocks for executing trades, but you can also integrate custom indicators, create stop-loss and take-profit levels, and manage trading risk.

7. Trading Logic and Strategy

Trading logic in an EA refers to the conditions under which trades are opened and closed. Your trading strategy will dictate how you define these conditions. For instance, you might want to buy when the 14-period moving average crosses above the 50-period moving average.

Here’s an example of a simple moving average crossover strategy:

void OnTick()
  {
   double fastMA = iMA(Symbol(), 0, 14, 0, MODE_SMA, PRICE_CLOSE, 0);
   double slowMA = iMA(Symbol(), 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
   if (fastMA > slowMA)
     {
      // Buy logic
      if (OrderSelect(ticket, SELECT_BY_POS, MODE_TRADES))
        {
         if (OrderType() == OP_SELL)
           {
            OrderClose(ticket, 0.1, Bid, 3, CLR_NONE);
            OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0, "Buy Order", 0, 0, Blue);
           }
        }
     }
  }

This code buys when the fast moving average crosses above the slow moving average and sells when the fast MA crosses below the slow MA.

8. Implementing Order Execution

Order execution is a crucial aspect of any trading EA. When placing trades, it’s essential to consider order types (market, limit, stop) and ensure the correct handling of stops and take-profits. Here’s an example of how to send a market order with stop-loss and take-profit:

int ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, Ask - 50 * Point, Ask + 50 * Point, "Buy Order", 0, 0, CLR_NONE);

This sends a buy order with a stop-loss of 50 pips below the ask price and a take-profit of 50 pips above the ask price.

9. Risk Management in EAs

Risk management is a critical part of any trading strategy. You can implement features like dynamic lot sizing based on account balance, position size limiting, or applying trailing stops.

Example of a dynamic lot size based on account balance:

double lotSize = AccountBalance() / 10000;  // 1 lot per $10,000 balance

10. Backtesting and Optimization

Backtesting is the process of testing an EA against historical data to see how well it would have performed. MT5 provides a powerful Strategy Tester to backtest EAs. To backtest:

Open the Strategy Tester from MT5.
Select your EA and set the testing parameters.
Run the test to see the results.

Optimization allows you to test multiple parameter combinations to find the best-performing settings for your strategy.

11. Error Handling and Debugging

Handling errors and debugging your EA is essential. Common issues include incorrect order parameters, insufficient margin, and logic errors. Use Print() statements to log variables and output information to the “Experts” tab for debugging.

12. Advanced EA Features

Custom Indicators: Create custom indicators within your EA for complex strategies.
Multiple Timeframes: Use data from different timeframes to refine your strategy.
News Filtering: Filter out trades based on major economic news events to avoid volatility spikes.

13. Final Tips and Best Practices

Use Object-Oriented Programming (OOP): Break your EA into classes to make the code more modular and easier to maintain.
Optimize Your Code: Make sure your EA runs efficiently to avoid slowing down MT5.
Test Thoroughly: Always backtest and demo-test your EA before live trading.

14. Conclusion

Writing an EA for MetaTrader 5 is a rewarding process that can automate your trading strategies. By following this guide, you can create a robust EA using MQL5, incorporating various features like order execution, risk management, and custom indicators. As you become more familiar with MQL5, you’ll be able to fine-tune and optimize your EA for maximum profitability. Happy coding, and may your trading journey be successful!