Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

Trading algorithmique

Apprendre MQL5 : coder son premier Expert Advisor

Le MQL5 est le langage des robots MetaTrader 5. Dans ce tutoriel, vous construisez un Expert Advisor complet : signal, filtre de bougie, ordres et taille de position calculée selon votre risque.

Mis à jour le 23 octobre 2026Lecture : 13 minPar l’équipe OptiBot

Le MQL5 (MetaQuotes Language 5) est un langage proche du C++, conçu pour écrire des indicateurs, des scripts et des robots de trading appelés Expert Advisors (EA). Si vous avez déjà manipulé un langage de programmation, vous pouvez écrire un premier EA fonctionnel en quelques heures.

Ce tutoriel construit un robot volontairement simple : un croisement de moyennes mobiles exponentielles. L’intérêt n’est pas la stratégie, mais la structure, réutilisable pour n’importe quelle idée.

Prérequis et environnement

  • MetaTrader 5 installé, avec un compte démo.
  • MetaEditor, l’éditeur fourni avec MT5 (touche F4 depuis le terminal).
  • Des notions de base en programmation : variables, conditions, fonctions.

Dans MetaEditor, choisissez Nouveau, puis Expert Advisor (modèle). Le fichier .mq5 est créé dans le dossier MQL5/Experts de votre terminal.

La structure d’un Expert Advisor

Un EA repose sur trois fonctions événementielles appelées automatiquement par le terminal :

FonctionQuand est-elle appelée ?Usage
OnInit()Au chargement de l’EA sur un graphiqueCréer les indicateurs, vérifier les paramètres
OnTick()À chaque nouveau tick reçuLogique de trading
OnDeinit()Au retrait de l’EA ou à la fermetureLibérer les ressources

En MQL5, les indicateurs fonctionnent par handles : on crée l’indicateur une fois dans OnInit(), puis on lit ses valeurs avec CopyBuffer() dans OnTick(). C’est la principale différence avec le MQL4, où l’on appelait directement iMA() à chaque tick.

Les paramètres et les variables globales

Les variables déclarées avec le mot-clé input apparaissent dans la fenêtre de paramètres de l’EA et peuvent être optimisées dans le Strategy Tester.

#include <Trade\Trade.mqh>

input int    InpFastPeriod  = 20;      // Période de la moyenne rapide
input int    InpSlowPeriod  = 50;      // Période de la moyenne lente
input double InpRiskPercent = 0.5;     // Risque par trade (% des fonds propres)
input int    InpStopPoints  = 300;     // Stop-loss (en points)
input int    InpTakePoints  = 600;     // Take-profit (en points)
input ulong  InpMagic       = 260101;  // Identifiant unique du robot

CTrade   trade;
int      fastHandle = INVALID_HANDLE;
int      slowHandle = INVALID_HANDLE;
datetime lastBar    = 0;

La classe CTrade, fournie par la bibliothèque standard, simplifie l’envoi des ordres. Le magic number permet au robot de reconnaître ses propres positions parmi celles du compte.

Initialisation et libération des indicateurs

int OnInit()
{
   if(InpFastPeriod >= InpSlowPeriod)
      return(INIT_PARAMETERS_INCORRECT);

   fastHandle = iMA(_Symbol, _Period, InpFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
   slowHandle = iMA(_Symbol, _Period, InpSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);
   if(fastHandle == INVALID_HANDLE || slowHandle == INVALID_HANDLE)
      return(INIT_FAILED);

   trade.SetExpertMagicNumber(InpMagic);
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   IndicatorRelease(fastHandle);
   IndicatorRelease(slowHandle);
}

Retourner INIT_PARAMETERS_INCORRECT quand la moyenne rapide est plus lente que la lente évite de gaspiller des passes lors des optimisations.

Calculer la taille de position selon le risque

C’est la fonction la plus importante du robot. Elle convertit un pourcentage de risque en nombre de lots, à partir de la distance du stop-loss et de la valeur du tick de l’instrument. La logique est détaillée dans notre guide de la gestion du risque.

double LotsForRisk(const int stopPoints)
{
   double riskMoney = AccountInfoDouble(ACCOUNT_EQUITY) * InpRiskPercent / 100.0;
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if(tickValue <= 0.0 || tickSize <= 0.0)
      return(0.0);

   double lossPerLot = (stopPoints * _Point / tickSize) * tickValue;
   double lots       = riskMoney / lossPerLot;

   double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double minL = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxL = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

   lots = MathFloor(lots / step) * step;
   if(lots < minL)
      return(0.0);          // trop petit : on ne trade pas plutôt que de sur-risquer
   return(MathMin(lots, maxL));
}
Notez le choix de ne pas trader quand la taille calculée est inférieure au lot minimum. Arrondir au lot minimum ferait dépasser le risque prévu, une erreur fréquente sur les petits comptes.

Vérifier si le robot a déjà une position

bool HasPosition()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);   // sélectionne aussi la position
      if(ticket > 0
         && PositionGetString(POSITION_SYMBOL) == _Symbol
         && PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
         return(true);
   }
   return(false);
}

La logique de trading dans OnTick()

Le robot ne prend une décision qu’une fois par bougie, sur les valeurs des bougies clôturées. Cela évite les signaux qui apparaissent puis disparaissent au cours de la bougie, et rend le backtest cohérent avec le comportement réel.

void OnTick()
{
   datetime barTime = iTime(_Symbol, _Period, 0);
   if(barTime == lastBar)
      return;                       // une seule décision par bougie
   lastBar = barTime;

   double fast[], slow[];
   ArraySetAsSeries(fast, true);
   ArraySetAsSeries(slow, true);
   // valeurs des bougies 1 (dernière clôturée) et 2
   if(CopyBuffer(fastHandle, 0, 1, 2, fast) < 2) return;
   if(CopyBuffer(slowHandle, 0, 1, 2, slow) < 2) return;

   bool crossUp   = fast[1] <= slow[1] && fast[0] > slow[0];
   bool crossDown = fast[1] >= slow[1] && fast[0] < slow[0];
   if(!crossUp && !crossDown) return;
   if(HasPosition()) return;

   double lots = LotsForRisk(InpStopPoints);
   if(lots <= 0.0) return;

   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(crossUp)
      trade.Buy(lots, _Symbol, ask,
                NormalizeDouble(ask - InpStopPoints * _Point, _Digits),
                NormalizeDouble(ask + InpTakePoints * _Point, _Digits), "EMA cross");
   else
      trade.Sell(lots, _Symbol, bid,
                 NormalizeDouble(bid + InpStopPoints * _Point, _Digits),
                 NormalizeDouble(bid - InpTakePoints * _Point, _Digits), "EMA cross");
}

Compiler et tester

  1. Appuyez sur F7 dans MetaEditor pour compiler. Corrigez les éventuelles erreurs signalées dans l’onglet Erreurs.
  2. Dans MetaTrader 5, ouvrez le Strategy Tester (Ctrl+R), sélectionnez votre EA, le symbole et l’unité de temps.
  3. Lancez un premier test en « OHLC 1 minute » pour vérifier que le robot ouvre et ferme des positions comme prévu.
  4. Passez ensuite à la méthode complète décrite dans notre guide pour backtester une stratégie.

Aller plus loin

Ce squelette couvre l’essentiel, mais un robot destiné au réel doit aussi :

  • vérifier le retour des ordres (trade.ResultRetcode()) et gérer les refus du broker ;
  • filtrer le spread au moment de l’entrée ;
  • intégrer des limites globales : perte journalière maximale, drawdown maximal, horaires autorisés ;
  • journaliser ses décisions pour pouvoir comparer réel et backtest.

Questions fréquentes

Le MQL5 est-il difficile à apprendre ?

Pour quelqu’un qui connaît déjà un langage comme Python, JavaScript ou C, la syntaxe se prend en main rapidement. La vraie difficulté est ailleurs : comprendre le fonctionnement des ordres, des positions et des données de marché sur MetaTrader 5.

Un EA MQL4 fonctionne-t-il sur MT5 ?

Non. Les deux langages sont proches mais incompatibles : la gestion des ordres et des indicateurs diffère. Un EA MQL4 doit être réécrit pour MetaTrader 5.

Faut-il utiliser la bibliothèque standard ou OrderSend() ?

Pour débuter, la classe CTrade de la bibliothèque standard est plus simple et moins source d’erreurs. OrderSend() donne un contrôle plus fin mais demande de remplir soi-même la structure de requête.

Avertissement : ce code est fourni à titre pédagogique. Testez toujours un robot en démo avant tout usage réel. Le trading comporte un risque élevé de perte en capital.