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

MQL4 · Ordres

OrderSend en MQL4 : ouvrir un ordre au marché ou en attente

Signature d’OrderSend, prix Bid et Ask, slippage, stop loss, take profit, magic number : comment ouvrir un ordre fiable en MQL4 et réagir aux erreurs 129, 130, 138 ou 148.

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

OrderSend() est la fonction MQL4 qui ouvre un ordre au marché (OP_BUY, OP_SELL) ou place un ordre en attente (OP_BUYLIMIT, OP_SELLLIMIT, OP_BUYSTOP, OP_SELLSTOP). Elle renvoie le numéro de ticket attribué par le serveur, ou -1 en cas d’échec ; le code de l’erreur se lit alors avec GetLastError(). Pour un ordre au marché, le prix envoyé doit être le dernier Ask (achat) ou le dernier Bid (vente), normalisé au nombre de décimales du symbole ; le stop loss et le take profit doivent respecter la distance minimale imposée par le serveur.

Cette page détaille chaque paramètre d’après la documentation officielle, puis propose une fonction d’ouverture complète et commentée. Elle fait partie de la rubrique Gérer les ordres en MQL4.

La signature

int OrderSend(
   string   symbol,              // symbole
   int      cmd,                 // type d'opération (OP_BUY, OP_SELL...)
   double   volume,              // volume en lots
   double   price,               // prix d'ouverture
   int      slippage,            // glissement maximal accepté, en points
   double   stoploss,            // niveau du stop loss (0 = aucun)
   double   takeprofit,          // niveau du take profit (0 = aucun)
   string   comment=NULL,        // commentaire
   int      magic=0,             // numéro magique
   datetime expiration=0,        // expiration (ordres en attente uniquement)
   color    arrow_color=clrNONE  // couleur de la flèche sur le graphique
   );

Les paramètres un par un

ParamètreCe qu’il faut savoir
symbolLe nom exact du symbole chez votre courtier. Utilisez Symbol() pour le graphique courant ; les suffixes comme « .m » font partie du nom.
cmdL’une des six constantes OP_....
volumeEn lots, compris entre le minimum et le maximum du courtier et multiple du pas de volume (valeurs lisibles avec MarketInfo()).
pricePour un ordre au marché : Ask à l’achat, Bid à la vente. Pour un ordre en attente : le niveau de déclenchement.
slippageL’écart maximal, en points, entre le prix demandé et le prix d’exécution.
stoploss, takeprofitDes niveaux de prix, pas des distances. 0 signifie « pas de niveau ».
commentTexte libre ; la documentation précise que le serveur peut en modifier la fin.
magicIdentifiant de l’EA, indispensable pour retrouver ses ordres.
expirationDate d’expiration d’un ordre en attente. Certains serveurs la refusent (erreur 147).
arrow_colorCouleur de la flèche dessinée ; clrNONE ou CLR_NONE pour ne rien dessiner.

Les règles de prix fixées par la documentation

La documentation d’OrderSend() énonce plusieurs règles qui expliquent la majorité des refus :

  • Prix d’un ordre au marché. Seul le dernier Bid (vente) ou Ask (achat) peut servir de prix d’ouverture. Si l’opération porte sur un autre symbole que celui du graphique, il faut lire ses prix avec MarketInfo().
  • Prix calculé ou non normalisé. Un prix qui n’existe pas dans le flux de cotations ou qui n’est pas normalisé au nombre de décimales produit l’erreur 129 (prix invalide).
  • Prix dépassé. Si le prix demandé est totalement périmé, l’erreur 138 (requote) est renvoyée, quel que soit le glissement. S’il est périmé mais encore présent dans le flux, l’ordre est exécuté au prix courant, à condition que celui-ci se situe dans la fourchette prix ± glissement.
  • Stops trop proches. Le stop loss et le take profit ne peuvent pas être trop près du marché. La distance minimale, en points, s’obtient avec MarketInfo(symbole, MODE_STOPLEVEL). Un niveau erroné ou non normalisé produit l’erreur 130. Une valeur de stop level égale à zéro signifie soit l’absence de restriction, soit un contrôle dynamique côté serveur : dans ce second cas, l’erreur 130 reste possible.
  • Ordre en attente trop proche. Le prix d’un ordre en attente ne peut pas non plus être trop près du marché ; un prix incorrect produit également l’erreur 130.
  • Limite du nombre d’ordres. Certains serveurs limitent le nombre total d’ordres ouverts et en attente ; au-delà, l’erreur 148 est renvoyée.

Les règles de distance sont détaillées, type d’ordre par type d’ordre, dans la page StopLevel et FreezeLevel.

Une fonction d’ouverture complète

Le code suivant ouvre un achat ou une vente au marché avec un stop et un objectif exprimés en points. Il vérifie le volume, le stop level et l’environnement, normalise les prix et journalise l’échec.

#property strict

input double InpLots       = 0.10;    // Volume (lots)
input int    InpStopPoints = 300;     // Stop loss (points)
input int    InpTpPoints   = 600;     // Take profit (points)
input int    InpSlippage   = 10;      // Glissement max (points)
input int    InpMagic      = 240201;  // Numéro magique

//+------------------------------------------------------------------+
//| Arrondit un volume au pas du courtier et le borne                 |
//+------------------------------------------------------------------+
double NormaliserLot(double lots)
  {
   double minLot  = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
   double pas     = MarketInfo(Symbol(), MODE_LOTSTEP);
   lots = MathFloor(lots / pas) * pas;           // arrondi vers le bas au pas
   lots = MathMax(minLot, MathMin(maxLot, lots));
   return(NormalizeDouble(lots, 2));
  }

//+------------------------------------------------------------------+
//| Ouvre un ordre au marché. type = OP_BUY ou OP_SELL                |
//| Renvoie le ticket ou -1                                           |
//+------------------------------------------------------------------+
int OuvrirOrdre(int type)
  {
   if(!IsTradeAllowed() || IsTradeContextBusy())
      return(-1);

   RefreshRates();                                // prix les plus récents
   int    stopLevel = (int)MarketInfo(Symbol(), MODE_STOPLEVEL);
   int    distSL    = MathMax(InpStopPoints, stopLevel + 1);
   int    distTP    = MathMax(InpTpPoints,   stopLevel + 1);

   double prix, sl, tp;
   color  couleur;
   if(type == OP_BUY)
     {
      prix = Ask;                                 // on achète au Ask
      sl   = prix - distSL * Point;
      tp   = prix + distTP * Point;
      couleur = clrBlue;
     }
   else
     {
      prix = Bid;                                 // on vend au Bid
      sl   = prix + distSL * Point;
      tp   = prix - distTP * Point;
      couleur = clrRed;
     }

   prix = NormalizeDouble(prix, Digits);
   sl   = NormalizeDouble(sl,   Digits);
   tp   = NormalizeDouble(tp,   Digits);

   ResetLastError();
   int ticket = OrderSend(Symbol(), type, NormaliserLot(InpLots), prix,
                          InpSlippage, sl, tp, "OptiBot", InpMagic, 0, couleur);
   if(ticket < 0)
     {
      int err = GetLastError();
      PrintFormat("OrderSend %s échoué : erreur %d (prix %s, SL %s, TP %s)",
                  (type == OP_BUY ? "achat" : "vente"), err,
                  DoubleToString(prix, Digits), DoubleToString(sl, Digits),
                  DoubleToString(tp, Digits));
     }
   else
      PrintFormat("Ordre %d ouvert", ticket);
   return(ticket);
  }

void OnTick()
  {
   // exemple minimal : ouvrir un achat s'il n'y a aucun ordre
   if(OrdersTotal() == 0)
      OuvrirOrdre(OP_BUY);
  }

Remarquez que le stop d’un achat est calculé depuis Ask mais que le serveur le contrôle par rapport au Bid : avec un spread large, un stop calculé au minimum depuis Ask peut être refusé. Le + 1 ajouté au stop level et une marge plus confortable dans vos paramètres évitent ce cas limite. Ce point est développé dans la page consacrée aux distances minimales.

Le test OrdersTotal() == 0 de l’exemple est volontairement simpliste : il compte tous les ordres du compte, y compris ceux d’autres EA. Un vrai EA compte uniquement ses propres ordres, filtrés par symbole et numéro magique, comme le montre la page OrderSelect et boucles.

Après l’envoi : lire le résultat

Un ticket positif signifie que le serveur a accepté l’ordre. Pour connaître le prix réel d’exécution (qui peut différer du prix demandé dans la limite du glissement), sélectionnez l’ordre par son ticket et lisez OrderOpenPrice() :

if(ticket > 0 && OrderSelect(ticket, SELECT_BY_TICKET))
   PrintFormat("Exécuté à %s", DoubleToString(OrderOpenPrice(), Digits));

En cas d’échec, le code d’erreur oriente la réaction : 129, 135, 136 ou 138 justifient une nouvelle tentative après RefreshRates() ; 130 impose de revoir les distances ; 131 de corriger le volume ; 134 signale une marge insuffisante ; 146 un contexte de trading occupé. Chaque code a sa page dans la rubrique erreurs, par exemple Erreur 130 : stops invalides.

Vérifier la marge avant d’envoyer

Avant un envoi, il est prudent de vérifier que le compte peut supporter le nouvel ordre. La fonction AccountFreeMarginCheck(symbole, cmd, volume) renvoie la marge libre qui resterait après l’ouverture de l’ordre envisagé. Si la valeur est négative ou nulle, l’envoi échouerait avec l’erreur 134 (fonds insuffisants) : autant ne pas solliciter le serveur. Ce contrôle est particulièrement utile pour les EA qui calculent leur volume dynamiquement, car une erreur de calcul peut produire un volume bien supérieur à ce que le compte autorise. Combinez-le avec le calcul du volume selon le risque décrit dans Taille de lot selon le risque, plutôt que de compter sur le refus du serveur pour vous protéger.

Pièges fréquents

  • Passer une distance au lieu d’un prix. stoploss = 300 n’est pas un stop à 300 points, c’est un stop au prix 300. Calculez toujours un niveau de prix.
  • Inverser Bid et Ask. Acheter au Bid ou vendre au Ask provoque un refus de prix.
  • Oublier la normalisation. Ask + 0.0015 peut produire un nombre avec des décimales parasites.
  • Retenter sans limite. Une boucle qui renvoie l’ordre tant qu’il échoue peut produire plusieurs positions si la réponse du serveur s’est perdue. Limitez le nombre d’essais et recomptez vos ordres avant chaque tentative.
  • Volume non conforme. Un volume de 0.015 sur un compte au pas de 0.01 est refusé : arrondissez au pas du courtier.

Et en MQL5 ?

En MQL5, OrderSend() existe toujours mais prend une structure MqlTradeRequest et remplit une structure MqlTradeResult : on renseigne l’action, le symbole, le volume, le type, le prix, le stop, l’objectif, le glissement et le mode de remplissage, puis on lit le retcode. La classe CTrade simplifie ces appels avec des méthodes comme Buy() et Sell(). La logique de position diffère aussi selon que le compte est en mode netting ou hedging : voyez Des ordres MQL4 aux positions MQL5.

FAQ

Que renvoie OrderSend en cas d’échec ?

La valeur -1. Le détail de l’erreur s’obtient immédiatement après avec GetLastError(), qui en MQL4 remet le code à zéro après lecture : stockez-le dans une variable.

Le slippage est-il exprimé en pips ou en points ?

En points. Sur une cotation à 5 décimales, un glissement de 10 correspond à 1 pip.

Peut-on ouvrir un ordre sur un autre symbole que celui du graphique ?

Oui, en passant son nom dans symbol et en utilisant ses prix lus par MarketInfo(symbole, MODE_ASK) ou MODE_BID, ainsi que ses propres MODE_POINT et MODE_DIGITS pour les calculs.

Pourquoi mon ordre est-il refusé avec stop loss mais accepté sans ?

Soit le stop est trop proche du marché (erreur 130), soit le serveur fonctionne en exécution au marché et refuse les stops à l’ouverture. Voyez la page sur les comptes ECN.

Un appel à OrderSend sur un compte réel engage immédiatement votre capital. Testez toute fonction d’ouverture sur compte de démonstration et fixez un risque par trade limité : le trading à effet de levier peut entraîner des pertes rapides.
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.