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

MQL4 · Ordres

OrderClose en MQL4 : fermer une position totalement ou partiellement

OrderClose ferme un ordre au marché en MQL4. Prix de clôture Bid ou Ask, boucle descendante pour tout fermer, clôture partielle et nouveau ticket, OrderCloseBy et erreurs fréquentes.

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

OrderClose() ferme, totalement ou partiellement, un ordre au marché ouvert en MQL4. Sa signature est bool OrderClose(int ticket, double lots, double price, int slippage, color arrow_color) : on lui passe le ticket, le volume à fermer, le prix de clôture, le glissement accepté en points et la couleur de la flèche. Le prix de clôture est l’inverse du prix d’ouverture : un achat se ferme au Bid, une vente se ferme au Ask. La fonction renvoie true si la fermeture a réussi, false sinon ; GetLastError() donne alors la raison. OrderClose() ne s’applique qu’aux positions : un ordre en attente se supprime avec OrderDelete().

Cette page montre comment fermer proprement un ordre, tous les ordres d’un EA ou une partie d’une position, et comment réagir aux refus. Elle fait partie de la rubrique Gérer les ordres en MQL4.

Les paramètres

ParamètreValeur à passer
ticketLe ticket de l’ordre, lu avec OrderTicket() après sélection
lotsLe volume à fermer : OrderLots() pour tout fermer, moins pour une clôture partielle
priceBid pour fermer un achat, Ask pour fermer une vente, normalisé
slippageÉcart maximal accepté, en points
arrow_colorCouleur de la flèche de clôture, clrNONE pour aucune

Comme pour OrderSend(), le prix doit être un prix réellement coté, à jour et normalisé. Si l’ordre porte sur un autre symbole que celui du graphique, lisez son prix avec MarketInfo(OrderSymbol(), MODE_BID) ou MODE_ASK, jamais avec les variables Bid et Ask du graphique.

Fermer tous les ordres d’un EA

C’est l’usage le plus courant et celui qui contient le plus de pièges. Le code suivant ferme toutes les positions d’un EA sur son symbole, avec plusieurs tentatives par ordre.

#property strict

input int InpMagic    = 240203;   // Numéro magique de l'EA
input int InpSlippage = 10;       // Glissement max (points)

//+------------------------------------------------------------------+
//| Ferme l'ordre actuellement sélectionné. 3 tentatives au plus.     |
//+------------------------------------------------------------------+
bool FermerOrdreSelectionne()
  {
   int    ticket = OrderTicket();
   double lots   = OrderLots();
   string sym    = OrderSymbol();
   int    type   = OrderType();
   int    digits = (int)MarketInfo(sym, MODE_DIGITS);

   for(int essai = 1; essai <= 3; essai++)
     {
      if(IsTradeContextBusy()) { Sleep(200); continue; }
      RefreshRates();
      // achat fermé au Bid, vente fermée au Ask
      double prix = (type == OP_BUY) ? MarketInfo(sym, MODE_BID)
                                     : MarketInfo(sym, MODE_ASK);
      ResetLastError();
      if(OrderClose(ticket, lots, NormalizeDouble(prix, digits), InpSlippage, clrGold))
         return(true);

      int err = GetLastError();
      PrintFormat("OrderClose %d, essai %d : erreur %d", ticket, essai, err);
      if(err != 129 && err != 135 && err != 136 && err != 138 && err != 146)
         break;                                   // erreur non transitoire
      Sleep(300);
     }
   return(false);
  }

//+------------------------------------------------------------------+
//| Ferme toutes les positions de l'EA sur le symbole courant         |
//+------------------------------------------------------------------+
int FermerTout()
  {
   int echecs = 0;
   // boucle DESCENDANTE : chaque fermeture décale les indices suivants
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol())                 continue;
      if(OrderMagicNumber() != InpMagic)            continue;
      if(OrderType() != OP_BUY && OrderType() != OP_SELL) continue; // pas les ordres en attente

      if(!FermerOrdreSelectionne())
         echecs++;
     }
   return(echecs);
  }

Trois détails font la différence entre un code qui marche en démonstration et un code fiable :

  • La boucle descend de OrdersTotal() - 1 à 0. En montant, la fermeture de l’ordre d’indice 0 ferait glisser l’ordre suivant à l’indice 0, que la boucle sauterait en passant à 1.
  • Les propriétés sont lues avant la boucle de tentatives. Si une autre sélection intervenait entre deux essais, OrderTicket() et OrderLots() désigneraient un autre ordre.
  • Les prix sont relus à chaque essai pour le symbole de l’ordre, après RefreshRates().

La fonction renvoie le nombre d’échecs : si elle n’est pas nulle, il reste des positions ouvertes, et l’EA doit le savoir. La logique de sélection et de filtrage est développée dans OrderSelect et boucles.

Fermeture partielle

Passer dans lots un volume inférieur à OrderLots() ferme seulement une partie de la position. Le volume fermé doit respecter le volume minimal et le pas de volume du courtier, et le volume restant aussi : sur un ordre de 0.15 lot avec un minimum de 0.10, fermer 0.10 laisserait 0.05, ce qui peut être refusé.

Point essentiel : après une clôture partielle, la partie restante de la position ne conserve pas le même ticket. MetaTrader 4 la rouvre sous un nouveau numéro, avec un commentaire qui fait référence à l’ordre d’origine. Un EA qui mémorise le ticket d’origine pour gérer la suite de la position le perd donc. La solution robuste consiste à retrouver la position par son symbole, son numéro magique et son type, plutôt que par un ticket mémorisé. Le numéro magique est conservé, ce qui rend cette recherche fiable (voir Magic number en MQL4).

// fermer la moitié d'une position sélectionnée, arrondie au pas du courtier
double pas     = MarketInfo(OrderSymbol(), MODE_LOTSTEP);
double minLot  = MarketInfo(OrderSymbol(), MODE_MINLOT);
double moitie  = MathFloor((OrderLots() / 2.0) / pas) * pas;
double reste   = OrderLots() - moitie;
if(moitie >= minLot && reste >= minLot)
  {
   double prix = (OrderType() == OP_BUY) ? MarketInfo(OrderSymbol(), MODE_BID)
                                         : MarketInfo(OrderSymbol(), MODE_ASK);
   if(!OrderClose(OrderTicket(), moitie,
                  NormalizeDouble(prix, (int)MarketInfo(OrderSymbol(), MODE_DIGITS)),
                  10, clrOrange))
      PrintFormat("Clôture partielle refusée : erreur %d", GetLastError());
  }

Fermer deux ordres opposés : OrderCloseBy

Lorsque vous détenez un achat et une vente sur le même symbole, OrderCloseBy(ticket, opposite, arrow_color) les ferme l’un par l’autre. Cette opération n’est pas forcément autorisée par tous les serveurs : MarketInfo(symbole, MODE_CLOSEBY_ALLOWED) indique si elle l’est. Elle est surtout utilisée par les stratégies qui couvrent leurs positions ; pour un EA classique, OrderClose() suffit.

Les refus de fermeture

CodeSignificationRéaction
129, 135, 136, 138Prix invalide, modifié, absent ou requoteRafraîchir et retenter
146Contexte de trading occupéAttendre puis retenter
145Ordre dans la zone de gelAttendre que le prix s’éloigne ; voir StopLevel et FreezeLevel
4108Ticket invalide (ordre déjà fermé)Ne pas retenter, recompter les ordres
131Volume invalideCorriger le volume (clôture partielle mal arrondie)

La zone de gel mérite une mention : quand le prix est très proche du stop loss ou du take profit d’un ordre, le serveur peut interdire sa fermeture manuelle, car il s’apprête à l’exécuter lui-même. Ce comportement dépend du paramètre FreezeLevel du symbole.

Fermer sur signal ou laisser faire le serveur

Il existe deux façons de sortir d’une position : laisser le serveur exécuter le stop loss ou le take profit posés sur l’ordre, ou fermer depuis l’EA avec OrderClose() lorsqu’une condition est remplie. La première a un avantage décisif : elle fonctionne même si le terminal est arrêté, puisque les niveaux sont stockés sur le serveur. La seconde permet des sorties plus riches (signal inverse, durée maximale, objectif journalier), mais dépend entièrement de l’EA et de sa connexion.

La pratique la plus sûre combine les deux : toujours poser un stop loss de protection sur le serveur, puis utiliser OrderClose() pour les sorties logiques. Si l’EA tombe en panne, la position reste protégée par son stop ; s’il fonctionne, il sort plus tôt selon sa propre logique.

Pièges fréquents

  • Fermer au mauvais prix : un achat fermé au Ask est refusé.
  • Utiliser Bid pour un ordre d’un autre symbole : l’EA attaché à EURUSD qui ferme un ordre GBPUSD doit lire les prix du GBPUSD.
  • Fermer sans filtrer : sans contrôle du numéro magique, l’EA ferme aussi les ordres manuels ou ceux d’autres robots.
  • Ne pas recompter après la boucle : si une fermeture a échoué, la position reste ouverte avec son risque.
  • Fermer pendant l’annonce d’un chiffre économique : le glissement peut être important et les refus nombreux. Si la stratégie le permet, sortez avant la publication plutôt que pendant.
  • Ignorer le swap et la commission : le résultat d’une fermeture se lit dans l’historique avec OrderProfit(), OrderSwap() et OrderCommission() ; seul leur total reflète le gain ou la perte réels.

Et en MQL5 ?

En MQL5, on ferme une position soit en envoyant un ordre opposé (en mode netting), soit en indiquant explicitement le ticket de la position à fermer (en mode hedging). La méthode CTrade::PositionClose() gère ces cas, et CTrade::PositionClosePartial() la fermeture partielle. Voyez Des ordres MQL4 aux positions MQL5 pour la correspondance détaillée.

FAQ

À quel prix fermer un achat en MQL4 ?

Au Bid. Un achat s’ouvre au Ask et se ferme au Bid ; une vente s’ouvre au Bid et se ferme au Ask.

Pourquoi ma boucle de fermeture laisse-t-elle des ordres ouverts ?

Presque toujours parce qu’elle monte de 0 à OrdersTotal() - 1. Chaque fermeture décale les indices et la boucle saute un ordre. Bouclez en descendant.

Le ticket change-t-il après une clôture partielle ?

Oui, la partie restante reçoit un nouveau ticket. Retrouvez-la par symbole, numéro magique et type plutôt que par l’ancien ticket.

Peut-on fermer un ordre en attente avec OrderClose ?

Non, OrderClose() concerne les ordres au marché. Un ordre en attente se supprime avec OrderDelete().

Une fermeture qui échoue laisse votre capital exposé. Contrôlez toujours le résultat et journalisez les échecs ; testez votre EA sur compte de démonstration avant toute utilisation sur un compte réel.
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.