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

MQL5 · Expert Advisors

EA multi-symboles en MQL5 : trader plusieurs instruments depuis un seul graphique

Gérer plusieurs symboles dans un seul Expert Advisor MQL5 : état par symbole, liste en paramètre, déclenchement par minuterie, données non synchronisées et pièges de _Point.

Mis à jour le 23 octobre 2026Lecture : 8 minPar Alix, OptiBot Trading

Un Expert Advisor multi-symboles est un EA unique, attaché à un seul graphique, qui surveille et trade plusieurs instruments. En MQL5, c’est un fonctionnement prévu par la plateforme : toutes les fonctions de données (iTime, CopyRates, CopyBuffer) et de trading (CTrade) acceptent un nom de symbole. Le travail consiste à dupliquer l’état par symbole (un handle d’indicateur, une date de dernière bougie, un ensemble de paramètres de volume pour chaque instrument) et à déclencher l’analyse au bon moment, car OnTick n’est appelé que pour les ticks du symbole du graphique.

Cette page de la rubrique Construire un Expert Advisor en MQL5 présente une architecture simple et robuste, puis les pièges propres au multi-symboles.

Pourquoi un seul EA pour plusieurs marchés

Lancer le même EA sur dix graphiques fonctionne, mais présente des limites : dix instances à configurer et à mettre à jour, aucune vision d’ensemble de l’exposition, impossibilité de limiter le nombre total de positions ou le risque global sans communication entre instances. Un EA multi-symboles centralise ces décisions. Il peut par exemple refuser une troisième position acheteuse sur des paires corrélées, ou appliquer une seule limite de perte journalière à l’ensemble du portefeuille.

En contrepartie, le code est plus complexe, et une erreur affecte tous les symboles à la fois. Si les stratégies sont indépendantes et qu’aucune règle globale n’est nécessaire, plusieurs instances d’un EA mono-symbole restent une option tout à fait valable.

Architecture recommandée

Une structure par symbole

Regroupez dans une structure tout ce qui est propre à un instrument : son nom, ses handles d’indicateurs, l’heure de la dernière bougie traitée. Un tableau de ces structures remplace les variables globales uniques d’un EA mono-symbole. Le principe des structures en MQL5 est détaillé dans la rubrique des bases.

La liste des symboles en paramètre

Un paramètre texte du type EURUSD,GBPUSD,USDJPY est découpé avec StringSplit dans OnInit. Chaque nom est vérifié et ajouté à l’Observation du marché avec SymbolSelect(nom, true) : un symbole absent de l’Observation du marché ne reçoit pas de cotations à jour. Les suffixes de courtier (EURUSD.m, EURUSDpro…) imposent de saisir les noms exacts ; un symbole inconnu doit faire échouer l’initialisation plutôt que d’être ignoré silencieusement.

Le déclenchement par minuterie

Puisque OnTick ne réagit qu’au symbole du graphique, une nouvelle bougie sur GBPUSD ne serait détectée qu’au prochain tick de EURUSD si l’EA est attaché à un graphique EURUSD. Pour un traitement régulier de tous les symboles, l’EA lance une minuterie avec EventSetTimer et parcourt la liste dans OnTimer. Une période d’une seconde suffit pour des stratégies sur bougies de M5 et plus. Le fonctionnement de la minuterie est détaillé dans Utiliser OnTimer.

Code complet

#property version "1.00"
#include <Trade\Trade.mqh>

input string InpSymbols = "EURUSD,GBPUSD,USDJPY";   // symboles séparés par des virgules
input ENUM_TIMEFRAMES InpTF = PERIOD_H1;            // unité de temps d'analyse
input int    InpFast    = 20;
input int    InpSlow    = 50;
input double InpLots    = 0.10;
sinput ulong InpMagic   = 260107;

//--- état propre à chaque symbole
struct SymbolState
  {
   string   name;
   int      hFast;
   int      hSlow;
   datetime lastBar;
  };

SymbolState g_sym[];
CTrade      trade;

int OnInit()
  {
   string parts[];
   int n = StringSplit(InpSymbols, ',', parts);
   if(n <= 0) return(INIT_PARAMETERS_INCORRECT);
   ArrayResize(g_sym, n);
   for(int i = 0; i < n; i++)
     {
      StringTrimLeft(parts[i]);
      StringTrimRight(parts[i]);
      if(!SymbolSelect(parts[i], true))          // ajoute à l'Observation du marché
        {
         Print("Symbole introuvable : ", parts[i]);
         return(INIT_PARAMETERS_INCORRECT);
        }
      g_sym[i].name    = parts[i];
      g_sym[i].hFast   = iMA(parts[i], InpTF, InpFast, 0, MODE_EMA, PRICE_CLOSE);
      g_sym[i].hSlow   = iMA(parts[i], InpTF, InpSlow, 0, MODE_EMA, PRICE_CLOSE);
      g_sym[i].lastBar = 0;
      if(g_sym[i].hFast == INVALID_HANDLE || g_sym[i].hSlow == INVALID_HANDLE)
         return(INIT_FAILED);
     }
   trade.SetExpertMagicNumber(InpMagic);
   if(!EventSetTimer(1)) return(INIT_FAILED);      // analyse toutes les secondes
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   EventKillTimer();
   for(int i = 0; i < ArraySize(g_sym); i++)
     {
      IndicatorRelease(g_sym[i].hFast);
      IndicatorRelease(g_sym[i].hSlow);
     }
  }

//--- position de l'EA ouverte sur ce symbole ?
bool HasPosition(const string sym)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
      if(PositionGetTicket(i) > 0 &&
         PositionGetString(POSITION_SYMBOL) == sym &&
         PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
         return(true);
   return(false);
  }

//--- traitement d'un symbole, une fois par nouvelle bougie
void ProcessSymbol(SymbolState &s)
  {
   datetime t = iTime(s.name, InpTF, 0);
   if(t == 0 || t == s.lastBar) return;          // pas de nouvelle bougie ou données absentes

   double f[], l[];
   ArraySetAsSeries(f, true);
   ArraySetAsSeries(l, true);
   if(CopyBuffer(s.hFast, 0, 1, 2, f) != 2) return;   // réessayer à la prochaine seconde
   if(CopyBuffer(s.hSlow, 0, 1, 2, l) != 2) return;
   s.lastBar = t;                                   // bougie traitée seulement après lecture réussie

   if(HasPosition(s.name)) return;
   if(f[1] <= l[1] && f[0] > l[0])
      trade.Buy(InpLots, s.name);                   // prix courant de s.name
   else if(f[1] >= l[1] && f[0] < l[0])
      trade.Sell(InpLots, s.name);
  }

void OnTimer()
  {
   for(int i = 0; i < ArraySize(g_sym); i++)
      ProcessSymbol(g_sym[i]);
  }

void OnTick() { }   // la logique est pilotée par la minuterie

Points clés

  • Chaque symbole a sa propre date de dernière bougie : les sessions et les jours de cotation diffèrent d’un instrument à l’autre, une bougie peut s’ouvrir sur un symbole et pas sur un autre.
  • La date n’est mémorisée qu’après une lecture réussie des indicateurs. Si les données d’un symbole secondaire ne sont pas prêtes, l’EA réessaie à la seconde suivante au lieu de perdre le signal.
  • Toutes les propriétés utilisées pour un ordre (prix, point, nombre de décimales, volume minimal) doivent être lues pour le symbole concerné. _Point et _Digits désignent le symbole du graphique : les utiliser pour un autre instrument est l’erreur la plus fréquente des EA multi-symboles.

Pièges spécifiques

  • Données non synchronisées. Au démarrage, l’historique des symboles secondaires peut ne pas être chargé. iTime renvoie alors 0 et CopyBuffer -1 : le code doit simplement attendre. Ne prenez jamais de décision avec un tableau partiellement rempli.
  • Horaires de cotation différents. Une paire de devises cote presque 24 h sur 24, un indice quelques heures par jour. Un ordre envoyé hors séance est rejeté avec le code « marché fermé ». Lisez les sessions du symbole ou filtrez par heure pour chaque instrument.
  • Comptes netting. Sur un compte netting, une seule position par symbole est possible : deux stratégies sur le même instrument se compensent. Voir Comptes netting ou hedging.
  • Charge du terminal. Chaque handle consomme de la mémoire et du calcul. Dix symboles et trois indicateurs restent légers ; plusieurs centaines demandent de mesurer le temps passé dans OnTimer.
  • Strategy Tester. Le testeur de MetaTrader 5 gère les EA multi-symboles et charge l’historique des symboles demandés. En mode ticks réels, chaque symbole dispose de ses propres ticks ; dans les modes générés, la synchronisation entre symboles est approximative, ce qui peut fausser les stratégies qui comparent les prix de plusieurs instruments à l’instant près.

Ajouter des règles globales de portefeuille

L’intérêt principal d’un EA multi-symboles est de pouvoir appliquer des règles à l’ensemble des positions. Trois règles simples couvrent la plupart des besoins :

  • Plafond de positions simultanées : avant chaque entrée, comptez toutes les positions portant le magic number de l’EA, tous symboles confondus, et refusez l’entrée au-delà d’un maximum.
  • Plafond par devise : sur des paires de devises, comptez l’exposition par devise (par exemple, acheter EURUSD et vendre USDJPY revient deux fois à vendre le dollar). Au-delà d’un seuil, les nouvelles positions dans le même sens sont refusées.
  • Risque total : additionnez la perte potentielle au stop de chaque position ouverte et comparez-la à un pourcentage maximal du capital.

Ces contrôles se placent dans une fonction appelée juste avant trade.Buy ou trade.Sell, pour que l’ordre de traitement des symboles n’influence pas la décision plus que nécessaire. Journalisez enfin chaque décision avec le nom du symbole en tête de ligne : quand dix instruments écrivent dans le même journal, c’est le seul moyen de reconstituer ce qui s’est passé sur l’un d’eux.

Cas d’usage

  • Portefeuille de paires avec une seule stratégie de tendance et un plafond de positions simultanées.
  • Stratégies inter-marchés : filtrer les entrées sur un indice selon la tendance d’un autre indice ou d’une devise.
  • Surveillance : un EA qui ne trade pas mais vérifie spread, cotations et positions de tous les symboles du compte, et envoie une alerte en cas d’anomalie.

Questions fréquentes

Sur quel graphique attacher un EA multi-symboles ?

Sur n’importe lequel, puisque la logique est pilotée par la minuterie. Choisissez de préférence un symbole très liquide et coté en continu, et évitez de fermer ce graphique : la fermeture arrête l’EA pour tous les symboles.

Pourquoi mon EA n’ouvre-t-il des positions que sur le symbole du graphique ?

Vérifiez que le nom du symbole est passé à toutes les fonctions (iMA, iTime, Buy, Sell) et que les prix et volumes sont lus avec SymbolInfoDouble(nom, ...) plutôt qu’avec _Point ou Ask.

Combien de symboles un EA peut-il gérer ?

Il n’y a pas de limite pratique pour quelques dizaines de symboles. Au-delà, mesurez le temps d’exécution d’OnTimer et réduisez les calculs inutiles, par exemple en ne lisant les indicateurs qu’à l’ouverture d’une nouvelle bougie.

Faut-il un magic number par symbole ?

Ce n’est pas nécessaire : le filtre combine symbole et magic number. Un magic number distinct par stratégie reste utile si l’EA applique plusieurs stratégies au même symbole.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.