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

MQL5 · Ordres et positions

Ordres limites et stop en MQL5 : placer, modifier et supprimer un ordre en attente

Buy Limit, Sell Limit, Buy Stop, Sell Stop et stop-limit : comment placer un ordre en attente en MQL5, choisir son expiration, le modifier, le supprimer et éviter les refus du serveur.

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

Un ordre en attente est une instruction d’achat ou de vente qui ne s’exécute que lorsque le prix atteint un niveau fixé. En MQL5, il se place avec l’action TRADE_ACTION_PENDING ou les méthodes BuyLimit, SellLimit, BuyStop et SellStop de la classe CTrade. Un ordre limite attend un prix plus favorable que le marché (acheter plus bas, vendre plus haut) ; un ordre stop attend une cassure (acheter plus haut, vendre plus bas). Le serveur répond TRADE_RETCODE_PLACED (10008) et le ticket à conserver est celui de l’ordre.

Cette page présente les types d’ordres en attente, leur expiration, leur modification et leur suppression. Elle appartient à la rubrique Ordres et positions en MQL5.

Les types d’ordres en attente

L’énumération ENUM_ORDER_TYPE contient six types d’ordres en attente :

TypePlacement par rapport au marchéUsage typique
ORDER_TYPE_BUY_LIMITsous le Askacheter un repli
ORDER_TYPE_SELL_LIMITau-dessus du Bidvendre un rebond
ORDER_TYPE_BUY_STOPau-dessus du Askacheter une cassure haussière
ORDER_TYPE_SELL_STOPsous le Bidvendre une cassure baissière
ORDER_TYPE_BUY_STOP_LIMITprix stop au-dessus du marchéà l’activation, place un Buy Limit au prix StopLimit
ORDER_TYPE_SELL_STOP_LIMITprix stop sous le marchéà l’activation, place un Sell Limit au prix StopLimit

Pour un ordre stop-limit, la requête contient deux prix : price, le niveau d’activation, et stoplimit, le prix de l’ordre limite qui sera alors placé. Avec CTrade::OrderOpen, ces deux valeurs correspondent aux paramètres price et limit_price.

Tous les symboles n’acceptent pas tous les types. La propriété SYMBOL_ORDER_MODE est un ensemble d’indicateurs : SYMBOL_ORDER_MARKET (1), SYMBOL_ORDER_LIMIT (2), SYMBOL_ORDER_STOP (4), SYMBOL_ORDER_STOP_LIMIT (8), SYMBOL_ORDER_SL (16), SYMBOL_ORDER_TP (32) et SYMBOL_ORDER_CLOSEBY (64). Testez le bit correspondant avant d’envoyer un type d’ordre ; un type interdit est refusé avec TRADE_RETCODE_INVALID_ORDER (10035).

Ordre en attente ou ordre au marché : que choisir ?

Le choix dépend de la logique de la stratégie, pas d’une préférence technique.

  • Stratégie de cassure. Le signal est le franchissement d’un niveau. Un ordre stop placé à l’avance s’exécute dès le franchissement, sans attendre le tick suivant ni la clôture de la bougie. L’alternative au marché consiste à surveiller le prix et à envoyer un achat après la cassure, ce qui ajoute un délai et dépend de la connexion du terminal.
  • Stratégie de retour à la moyenne. On cherche à acheter un repli ou à vendre un excès. Un ordre limite garantit un prix au moins égal au niveau visé, au prix d’un risque de non-exécution si le marché n’y revient pas.
  • Entrée à la clôture d’une bougie. Si le signal n’est connu qu’à la clôture, un ordre au marché à l’ouverture de la bougie suivante est le plus simple.

Un autre critère est la présence d’un ordre côté serveur. Un ordre en attente est exécuté par le serveur même si votre terminal est déconnecté, alors qu’une entrée « surveillée » par l’EA ne se produit que si le terminal fonctionne. C’est un avantage pour la robustesse, mais aussi un risque : un ordre oublié peut s’exécuter longtemps après que la situation qui l’a motivé a disparu, d’où l’intérêt d’une expiration.

Expiration : ENUM_ORDER_TYPE_TIME

Un ordre en attente reste actif jusqu’à son exécution, sa suppression ou son expiration. Le champ type_time en fixe la durée de vie :

  • ORDER_TIME_GTC : valable jusqu’à annulation ;
  • ORDER_TIME_DAY : valable jusqu’à la fin de la journée de trading en cours ;
  • ORDER_TIME_SPECIFIED : valable jusqu’à la date indiquée dans expiration ;
  • ORDER_TIME_SPECIFIED_DAY : valable jusqu’à 23:59:59 du jour indiqué ; si cette heure tombe hors session, l’ordre expire au moment de trading le plus proche.

Le broker n’autorise pas forcément tous ces modes. La propriété SYMBOL_EXPIRATION_MODE combine les indicateurs SYMBOL_EXPIRATION_GTC (1), SYMBOL_EXPIRATION_DAY (2), SYMBOL_EXPIRATION_SPECIFIED (4) et SYMBOL_EXPIRATION_SPECIFIED_DAY (8). Une expiration non admise ou incohérente produit TRADE_RETCODE_INVALID_EXPIRATION (10022).

Mode de remplissage des ordres en attente

La documentation de ENUM_ORDER_TYPE_FILLING donne une consigne précise : pour les ordres en attente, utilisez ORDER_FILLING_RETURN quel que soit le mode d’exécution du symbole, car le broker appliquera le type de remplissage supporté au moment où les conditions seront remplies. Les autres modes sont expliqués dans Modes de remplissage (FOK, IOC, Return).

Exemple : un ordre stop de cassure valable pour la journée

L’Expert Advisor suivant place, à chaque nouvelle bougie, un Buy Stop quelques points au-dessus du plus haut de la bougie précédente, s’il n’a ni position ni ordre en attente. Il supprime l’ordre si la condition n’est plus valable. C’est une illustration technique, pas une stratégie.

//+------------------------------------------------------------------+
//| Buy Stop au-dessus du plus haut précédent, expiration journée    |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>

input ulong  InpMagic        = 240507;
input double InpLots         = 0.10;
input int    InpOffsetPoints = 50;    // marge au-dessus du plus haut
input int    InpSLPoints     = 300;

CTrade   trade;
datetime g_lastBar = 0;

int OnInit()
  {
   trade.SetExpertMagicNumber(InpMagic);
   trade.SetTypeFilling(ORDER_FILLING_RETURN);   // consigne pour les ordres en attente
   return(INIT_SUCCEEDED);
  }

//--- ticket de l'ordre en attente de l'EA sur ce symbole (0 si aucun)
ulong MyPendingOrder()
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      ulong ticket = OrderGetTicket(i);           // sélectionne l'ordre
      if(ticket == 0) continue;
      if(OrderGetString(ORDER_SYMBOL) == _Symbol &&
         (ulong)OrderGetInteger(ORDER_MAGIC) == InpMagic)
         return(ticket);
     }
   return(0);
  }

void OnTick()
  {
   datetime bar = iTime(_Symbol, _Period, 0);
   if(bar == g_lastBar) return;                    // une fois par bougie
   g_lastBar = bar;

   //--- supprimer l'ancien ordre pour le replacer au nouveau niveau
   ulong old = MyPendingOrder();
   if(old > 0 && !trade.OrderDelete(old))
      Print("Suppression impossible, erreur ", GetLastError());

   if(PositionSelect(_Symbol)) return;             // déjà en position (netting)

   double high  = iHigh(_Symbol, _Period, 1);
   double ask   = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double price = NormalizeDouble(high + InpOffsetPoints * _Point, _Digits);
   double sl    = NormalizeDouble(price - InpSLPoints * _Point, _Digits);

   //--- un Buy Stop doit être au-dessus du Ask, avec la distance minimale
   long stops = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   if(price - ask < stops * _Point || price <= ask) return;

   //--- expiration en fin de journée si le symbole l'autorise
   long exp_flags = SymbolInfoInteger(_Symbol, SYMBOL_EXPIRATION_MODE);
   ENUM_ORDER_TYPE_TIME ttime =
      ((exp_flags & SYMBOL_EXPIRATION_DAY) != 0) ? ORDER_TIME_DAY : ORDER_TIME_GTC;

   if(!trade.BuyStop(InpLots, price, _Symbol, sl, 0.0, ttime, 0, "breakout"))
     {
      Print("Requête non envoyée, erreur ", GetLastError());
      return;
     }
   if(trade.ResultRetcode() == TRADE_RETCODE_PLACED || trade.ResultRetcode() == TRADE_RETCODE_DONE)
      PrintFormat("Buy Stop %I64u placé à %.5f", trade.ResultOrder(), price);
   else
      PrintFormat("Refus : %u %s", trade.ResultRetcode(), trade.ResultRetcodeDescription());
  }

Le test PositionSelect(_Symbol) suppose un compte netting ; sur un compte hedging, filtrez les positions par magic number comme expliqué dans Parcourir et filtrer les positions. La détection de bougie par iTime est volontairement minimale ; la page Détecter une nouvelle bougie présente une version plus robuste.

Modifier ou supprimer un ordre en attente

Modification. CTrade::OrderModify(ticket, price, sl, tp, type_time, expiration, stoplimit) correspond à l’action TRADE_ACTION_MODIFY. La documentation indique de repasser la valeur actuelle de chaque paramètre que vous ne voulez pas changer : lisez donc l’ordre avec OrderSelect(ticket) et OrderGetDouble(ORDER_PRICE_OPEN), ORDER_SL, ORDER_TP, puis ne remplacez que le champ voulu. Une requête qui ne change rien est refusée avec TRADE_RETCODE_NO_CHANGES (10025).

Suppression. CTrade::OrderDelete(ticket) correspond à TRADE_ACTION_REMOVE, qui ne requiert que l’action et le ticket d’ordre.

Gel de modification. Quand le prix est très proche du niveau d’activation, le broker peut interdire toute modification. La distance est donnée par SYMBOL_TRADE_FREEZE_LEVEL, en points ; une requête dans cette zone est refusée avec TRADE_RETCODE_FROZEN (10029).

Ce qui se passe à l’activation

Lorsque le prix atteint le niveau, le serveur exécute l’ordre : il quitte la liste des ordres actifs, passe dans l’historique avec l’état ORDER_STATE_FILLED, un deal est créé et une position s’ouvre (ou s’ajoute à la position existante en netting). Votre EA peut le détecter dans OnTradeTransaction ou en constatant au tick suivant que l’ordre a disparu et qu’une position est apparue. Les stops définis sur l’ordre sont reportés sur la position.

Pièges fréquents

Inverser limite et stop. Un Buy Limit au-dessus du marché ou un Buy Stop en dessous est invalide (10015). Gardez en tête : limite = meilleur prix, stop = cassure.

Oublier la limite d’ordres. La propriété de compte ACCOUNT_LIMIT_ORDERS indique le nombre maximal d’ordres en attente actifs ; au-delà, le serveur renvoie TRADE_RETCODE_LIMIT_ORDERS (10033). Un EA qui replace ses ordres sans supprimer les anciens atteint vite cette limite.

Accumuler des ordres orphelins. Si l’EA est retiré du graphique, ses ordres restent sur le serveur. Prévoyez une suppression dans OnDeinit si votre logique l’exige.

Glissement à l’exécution. Un ordre stop devient un ordre au marché à l’activation : en cas de gap ou de forte volatilité, le prix d’exécution peut être nettement moins bon que le niveau prévu. Un ordre limite, lui, ne s’exécute pas à un prix moins favorable que son prix, mais peut ne jamais être exécuté.

Un ordre en attente peut s’exécuter alors que vous n’êtes pas devant l’écran, y compris lors d’une annonce économique. Le trading avec effet de levier comporte un risque élevé de perte en capital ; vérifiez la logique de placement et de suppression sur un compte de démonstration.

FAQ

Quel code de retour attendre après BuyLimit ?

TRADE_RETCODE_PLACED (10008, « Order placed »). Le ticket de l’ordre est renvoyé par ResultOrder() ; ResultDeal() ne contient rien d’utile tant que l’ordre n’est pas exécuté.

Comment faire expirer un ordre à une heure précise ?

Utilisez ORDER_TIME_SPECIFIED avec la date et l’heure dans expiration, à condition que SYMBOL_EXPIRATION_MODE autorise SYMBOL_EXPIRATION_SPECIFIED.

Pourquoi OrdersTotal ne compte-t-il pas mes positions ?

Parce qu’il ne compte que les ordres en attente actifs. Une fois exécuté, l’ordre passe dans l’historique et la position se compte avec PositionsTotal.

Un ordre stop-limit est-il disponible partout ?

Non, il faut que SYMBOL_ORDER_MODE contienne SYMBOL_ORDER_STOP_LIMIT. Vérifiez ce bit avant de proposer ce type d’ordre dans un EA.

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.