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

MQL4 · Ordres

Comptes ECN en MQL4 : ouvrir sans stops puis les poser avec OrderModify

Exécution au marché, SYMBOL_TRADE_EXEMODE et ouverture en deux temps : comment un EA MQL4 place ses stops sur un compte ECN sans laisser de position sans protection.

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

Sur certains comptes MetaTrader 4 en exécution au marché, souvent présentés comme comptes ECN ou STP, le serveur refuse un ordre au marché envoyé avec un stop loss ou un take profit non nul. La méthode robuste, qui fonctionne sur tous les types de comptes, consiste à ouvrir la position avec stoploss = 0 et takeprofit = 0, puis à poser immédiatement les niveaux avec OrderModify() en les recalculant à partir du prix réellement obtenu. Le mode d’exécution d’un symbole se lit avec SymbolInfoInteger(symbole, SYMBOL_TRADE_EXEMODE), qui renvoie notamment SYMBOL_TRADE_EXECUTION_INSTANT ou SYMBOL_TRADE_EXECUTION_MARKET.

Cette page explique la différence entre les modes d’exécution, montre comment détecter le mode du symbole et propose une fonction d’ouverture en deux temps qui limite la période sans protection. Elle fait partie de la rubrique Gérer les ordres en MQL4.

Exécution instantanée et exécution au marché

La documentation du MQL4 définit, pour la propriété SYMBOL_TRADE_EXEMODE, les modes suivants :

ConstanteModeCe que cela implique pour l’EA
SYMBOL_TRADE_EXECUTION_REQUESTExécution sur demandeLe prix est demandé puis confirmé
SYMBOL_TRADE_EXECUTION_INSTANTExécution instantanéeL’ordre est exécuté au prix demandé, dans la limite du glissement, ou refusé (requote)
SYMBOL_TRADE_EXECUTION_MARKETExécution au marchéL’ordre est exécuté au prix disponible, le prix envoyé et le glissement ayant un rôle limité
SYMBOL_TRADE_EXECUTION_EXCHANGEExécution bourseNon utilisé en MQL4 selon la documentation

En exécution instantanée, le paramètre slippage d’OrderSend() fixe l’écart toléré, et un prix dépassé produit une requote. En exécution au marché, l’ordre est transmis pour être exécuté au meilleur prix disponible : le prix réellement obtenu peut différer du prix envoyé, et c’est le contexte dans lequel certains serveurs refusent des stops à l’ouverture.

Ce comportement dépend du courtier et de sa configuration, pas du langage : deux comptes en exécution au marché chez deux courtiers différents peuvent réagir différemment. D’où l’intérêt d’une méthode qui fonctionne partout.

Détecter le mode d’exécution

#property strict

//+------------------------------------------------------------------+
//| Vrai si le symbole est en exécution au marché                     |
//+------------------------------------------------------------------+
bool ExecutionAuMarche(string sym)
  {
   long mode = SymbolInfoInteger(sym, SYMBOL_TRADE_EXEMODE);
   return(mode == SYMBOL_TRADE_EXECUTION_MARKET);
  }

int OnInit()
  {
   PrintFormat("%s : exécution %s", Symbol(),
               EnumToString((ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(Symbol(), SYMBOL_TRADE_EXEMODE)));
   return(INIT_SUCCEEDED);
  }

Affichez cette information au démarrage de l’EA : elle permet de comprendre a posteriori un comportement différent entre deux comptes. Vous pouvez aussi l’utiliser pour choisir automatiquement la méthode d’ouverture, mais la méthode en deux temps décrite ci-dessous peut être utilisée systématiquement, quel que soit le mode.

Ouvrir en deux temps

#property strict

input double InpLots       = 0.10;    // Volume
input int    InpStopPoints = 300;     // Stop loss (points)
input int    InpTpPoints   = 600;     // Take profit (points)
input int    InpSlippage   = 10;      // Glissement (points, exécution instantanée)
input int    InpMagic      = 240212;  // Numéro magique

//+------------------------------------------------------------------+
//| Ouvre sans stops, puis pose SL et TP depuis le prix obtenu        |
//+------------------------------------------------------------------+
int OuvrirPuisProteger(int type)
  {
   RefreshRates();
   double prix = (type == OP_BUY) ? Ask : Bid;

   // 1. ouverture SANS stop ni objectif
   ResetLastError();
   int ticket = OrderSend(Symbol(), type, InpLots, NormalizeDouble(prix, Digits),
                          InpSlippage, 0, 0, "ecn", InpMagic, 0, clrNONE);
   if(ticket < 0)
     {
      PrintFormat("Ouverture refusée : erreur %d", GetLastError());
      return(-1);
     }

   // 2. relire le prix d'exécution réel
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
      return(ticket);
   double entree    = OrderOpenPrice();
   double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
   double dSL       = MathMax(InpStopPoints * Point, stopLevel + Point);
   double dTP       = MathMax(InpTpPoints   * Point, stopLevel + Point);

   double sl = (type == OP_BUY) ? entree - dSL : entree + dSL;
   double tp = (type == OP_BUY) ? entree + dTP : entree - dTP;
   sl = NormalizeDouble(sl, Digits);
   tp = NormalizeDouble(tp, Digits);

   // 3. poser les niveaux, avec quelques tentatives
   for(int essai = 1; essai <= 5; essai++)
     {
      ResetLastError();
      if(OrderModify(ticket, entree, sl, tp, 0, clrNONE))
         return(ticket);
      PrintFormat("Pose des stops, essai %d : erreur %d", essai, GetLastError());
      Sleep(300);
      RefreshRates();
     }

   // 4. échec persistant : ne pas laisser une position sans protection
   Print("Impossible de poser le stop : fermeture de sécurité");
   RefreshRates();
   double prixSortie = (type == OP_BUY) ? Bid : Ask;
   if(!OrderClose(ticket, InpLots, NormalizeDouble(prixSortie, Digits), InpSlippage, clrRed))
      PrintFormat("Fermeture de sécurité refusée : erreur %d", GetLastError());
   return(-1);
  }

Cette fonction contient trois décisions importantes. D’abord, les niveaux sont calculés depuis le prix d’exécution réel lu avec OrderOpenPrice(), et non depuis le prix envoyé : en exécution au marché, l’écart peut être de plusieurs points, et un stop calculé sur le prix demandé ne correspondrait plus au risque prévu. Ensuite, la pose des stops est retentée plusieurs fois, car une modification peut échouer pour une raison passagère (contexte occupé, prix en mouvement). Enfin, si le stop ne peut décidément pas être posé, la fonction ferme la position plutôt que de la laisser sans protection. C’est un choix de gestion du risque que vous pouvez adapter, mais qui doit être explicite.

Si le stop est trop proche du prix au moment de la pose, le serveur renvoie l’erreur 130 ; la distance minimale est expliquée dans StopLevel et FreezeLevel.

La fenêtre sans protection

Entre l’ouverture et la pose du stop, la position n’est pas protégée. En conditions normales, cette fenêtre dure le temps d’un aller-retour avec le serveur. Elle peut s’allonger en cas de forte activité ou de coupure de connexion. Trois mesures la réduisent :

  • Appeler OrderModify() immédiatement après l’ouverture, dans la même exécution de OnTick(), sans calcul intermédiaire.
  • Vérifier à chaque tick que toutes les positions de l’EA ont bien un stop. Une fonction de contrôle qui pose un stop sur toute position où OrderStopLoss() == 0 rattrape les cas où la pose a échoué, y compris après un redémarrage du terminal.
  • Surveiller le journal. Des échecs répétés de pose de stop sont un signal d’alerte à traiter avant de poursuivre en réel.

Et les ordres en attente ?

La contrainte concerne les ordres au marché. Un ordre en attente est placé avec ses niveaux, puis exécuté plus tard par le serveur ; ses stops sont mesurés depuis son prix d’entrée. Si votre courtier en exécution au marché pose problème à l’ouverture, une entrée par ordre en attente peut être une alternative, avec ses propres règles décrites dans Ordres en attente. Après le déclenchement, vérifiez néanmoins que les niveaux sont bien présents sur la position.

Une fonction de rattrapage à chaque tick

La fonction d’ouverture en deux temps couvre le cas normal. Pour les situations anormales (redémarrage du terminal juste après une ouverture, coupure réseau pendant la pose des stops), ajoutez une fonction appelée au début de chaque OnTick() qui parcourt les positions de l’EA et pose un stop sur toute position où OrderStopLoss() vaut 0. Elle utilise les mêmes calculs que la fonction d’ouverture, à partir de OrderOpenPrice(), en vérifiant d’abord que le stop calculé n’est pas déjà dépassé par le prix courant ; si c’est le cas, la position a déjà perdu plus que prévu et la fermer immédiatement est généralement le choix le plus cohérent avec le risque initial.

Pièges fréquents

  • Calculer le stop depuis le prix envoyé : le prix d’exécution peut être différent, et le risque réel avec lui.
  • Abandonner après un échec de pose : une position sans stop sur un compte réel est un risque non borné.
  • Compter sur le glissement en exécution au marché : il n’y garantit pas un prix maximal comme en exécution instantanée.
  • Coder le comportement d’un seul courtier : la méthode en deux temps fonctionne partout ; un code qui suppose que les stops sont acceptés à l’ouverture échouera chez un autre courtier.

Et en MQL5 ?

En MQL5, le mode d’exécution se lit de la même façon avec SYMBOL_TRADE_EXEMODE, et le mode de remplissage de l’ordre (ORDER_FILLING_FOK, ORDER_FILLING_IOC, ORDER_FILLING_RETURN) doit être compatible avec le symbole. Les stops peuvent en général être fournis dans la requête d’ouverture, mais vérifier qu’ils ont bien été posés reste une bonne pratique. Voir Des ordres MQL4 aux positions MQL5.

FAQ

Pourquoi mon ordre avec stop loss est-il refusé sur mon compte ECN ?

Certains serveurs en exécution au marché n’acceptent pas de stop loss ni de take profit dans l’ordre d’ouverture. Ouvrez avec des niveaux à 0, puis posez-les avec OrderModify() juste après.

Comment savoir si mon compte est en exécution au marché ?

Lisez SymbolInfoInteger(Symbol(), SYMBOL_TRADE_EXEMODE) et comparez la valeur à SYMBOL_TRADE_EXECUTION_MARKET. La fenêtre de passage d’ordre du terminal l’indique aussi.

Peut-on utiliser la méthode en deux temps sur un compte classique ?

Oui. Elle fonctionne quel que soit le mode d’exécution, ce qui en fait la solution la plus portable pour un EA distribué à plusieurs utilisateurs.

Que faire si le stop ne peut pas être posé ?

Retentez quelques fois en rafraîchissant les prix. Si l’échec persiste, fermez la position ou alertez l’utilisateur : ne la laissez pas ouverte sans protection.

Une position ouverte sans stop, même quelques secondes, est exposée à un mouvement brutal. Testez la méthode sur compte de démonstration chez votre courtier ; le trading à effet de levier comporte un risque élevé de perte en capital.
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.