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

MQL4 · Codes d’erreur

Erreur 129 en MQL4 (ERR_INVALID_PRICE) : le prix d’exécution refusé par le serveur

L’erreur 129 signifie que le serveur de trading refuse le prix transmis avec l’ordre. Bid ou Ask inversé, prix périmé, valeur non normalisée : voici comment l’éviter dans vos EA MQL4.

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

L’erreur 129, constante ERR_INVALID_PRICE, libellé officiel *Invalid price*, est un code de retour du serveur de trading : votre requête OrderSend ou OrderClose a bien été transmise, mais le prix qu’elle contient n’est pas acceptable. La documentation de OrderSend en donne les deux causes principales : pour un ordre au marché, seul le dernier Bid (vente) ou le dernier Ask (achat) peut servir de prix d’ouverture ; et un prix calculé ou non normalisé est refusé avec l’erreur 129, le prix devant en outre figurer dans le flux de cotations.

En pratique, l’erreur 129 révèle donc presque toujours un défaut du code : mauvais côté de la cotation, prix lu trop tôt, ou prix fabriqué par un calcul. Cette page se concentre sur le prix d’exécution des ordres au marché, à l’ouverture comme à la clôture. Les niveaux de stop loss et de take profit, eux, relèvent de l’erreur 130.

Les causes de l’erreur 129

Bid et Ask inversés

C’est la cause numéro un. On achète au prix Ask et on vend au prix Bid. Pour fermer une position, c’est l’inverse : un achat se clôture au Bid (on revend), une vente au Ask (on rachète). Un OrderClose qui ferme un achat au prix Ask déclenche une erreur 129, de même qu’un OrderSend(OP_SELL) envoyé avec Ask.

Un prix périmé

Les variables prédéfinies Bid et Ask sont une copie locale des cotations, figée au début de l’exécution de OnTick(). Si votre EA effectue de longs calculs, appelle Sleep() ou enchaîne plusieurs tentatives, ces valeurs peuvent ne plus correspondre au marché. La documentation de RefreshRates() le rappelle : de nouveaux ticks peuvent arriver pendant l’exécution d’un expert, rendant ses données obsolètes. Un prix trop ancien peut aussi provoquer une erreur 138 (requote) ; la frontière entre les deux dépend de l’écart et du serveur.

Un prix non normalisé ou calculé

Passer Ask + 0.00001 ou le résultat d’une moyenne comme prix d’un ordre au marché revient à demander un prix qui n’existe pas dans le flux. Même un prix « juste » mais comportant trop de décimales, issu d’une opération en virgule flottante, peut être rejeté. Normalisez avec NormalizeDouble(prix, Digits).

Le prix d’un autre symbole

Un EA multi-paires qui envoie un ordre sur GBPUSD depuis un graphique EURUSD en utilisant Ask transmet le prix de l’EURUSD. La documentation est explicite : pour un autre symbole, il faut récupérer ses cotations avec MarketInfo() et les identifiants MODE_BID ou MODE_ASK.

Close[0] à la place du prix courant

Close[0] contient le dernier Bid connu de la bougie en cours. L’utiliser comme prix d’achat revient à acheter au Bid : erreur assurée, et même pour une vente, c’est une valeur issue de la série, pas forcément synchronisée avec le flux au moment de l’envoi.

Une fonction qui fournit le bon prix

Le code ci-dessous centralise le choix du prix. Il rafraîchit les données, lit les cotations du symbole demandé (qui n’est pas forcément celui du graphique) et normalise le résultat avec le nombre de décimales de ce symbole.

//+------------------------------------------------------------------+
//| Prix d'exécution correct pour ouvrir ou fermer au marché          |
//+------------------------------------------------------------------+
#property strict

//--- type : OP_BUY ou OP_SELL ; closing=true pour une clôture
double MarketPrice(const string sym, const int type, const bool closing)
  {
   RefreshRates();                                   // actualise Bid/Ask locaux
   int    digits = (int)MarketInfo(sym, MODE_DIGITS);
   double bid    = MarketInfo(sym, MODE_BID);
   double ask    = MarketInfo(sym, MODE_ASK);

   bool useAsk;
   if(!closing) useAsk = (type == OP_BUY);           // achat au Ask, vente au Bid
   else         useAsk = (type == OP_SELL);          // on rachète une vente au Ask

   return NormalizeDouble(useAsk ? ask : bid, digits);
  }

//--- ouverture d'un achat avec un essai supplémentaire si 129
int OpenBuy(const string sym, const double lots, const int slippage)
  {
   for(int attempt = 0; attempt < 2; attempt++)
     {
      double price = MarketPrice(sym, OP_BUY, false);
      ResetLastError();
      int ticket = OrderSend(sym, OP_BUY, lots, price, slippage,
                             0, 0, "achat", 0, 0, clrNONE);
      if(ticket >= 0)
         return ticket;

      int err = GetLastError();
      PrintFormat("OrderSend %s à %s : erreur %d", sym,
                  DoubleToString(price, (int)MarketInfo(sym, MODE_DIGITS)), err);
      if(err != 129)                                  // autre erreur : on arrête
         break;
     }
   return -1;
  }

//--- clôture d'un ordre au marché déjà sélectionné par OrderSelect()
bool CloseSelected(const int slippage)
  {
   double price = MarketPrice(OrderSymbol(), OrderType(), true);
   return OrderClose(OrderTicket(), OrderLots(), price, slippage, clrNONE);
  }

Un seul nouvel essai suffit : si le prix rafraîchi et normalisé est encore refusé, le problème n’est plus le prix, et il faut examiner la connexion, le symbole ou les réglages du compte.

Le paramètre slippage ne vous protège pas de la 129

On pense souvent qu’un slippage généreux permet d’envoyer un prix approximatif. C’est inexact. Le paramètre de glissement définit l’écart toléré entre le prix demandé et le prix d’exécution lorsque le prix demandé est valide et encore présent dans le flux. Il ne transforme pas un Bid en Ask, ni une valeur calculée en cotation réelle. Augmenter le slippage pour faire disparaître une erreur 129 revient à masquer le symptôme sans traiter la cause, et expose l’EA à des exécutions plus éloignées que prévu lorsque le prix est réellement correct. Corrigez d’abord le choix du prix, puis fixez un glissement cohérent avec la volatilité du symbole.

Diagnostiquer une erreur 129 dans le journal

Lorsque l’erreur apparaît, le message du journal doit vous permettre de répondre à trois questions : quel type d’opération (ouverture ou clôture, achat ou vente), quel prix a été envoyé, et quels étaient Bid et Ask à ce moment. Si le prix envoyé est égal au Bid pour un achat, la cause est trouvée. S’il est proche du marché mais avec un nombre de décimales anormal, c’est un problème de normalisation. S’il correspond à un niveau ancien, c’est un manque de rafraîchissement. La page GetLastError en MQL4 propose une fonction de journalisation qui enregistre ces informations.

Cas pratiques et pièges

Comptes à 5 décimales

Sur un compte coté à 5 décimales (ou 3 pour les paires en yen), Digits vaut 5 et Point 0,00001. Un code écrit pour 4 décimales qui arrondit les prix à NormalizeDouble(prix, 4) produit des valeurs hors du flux : normalisez toujours avec Digits ou MODE_DIGITS, jamais avec une constante.

Ordres en attente

L’erreur 129 concerne d’abord les ordres au marché. Pour un ordre en attente, vous choisissez librement le prix, mais il doit respecter une distance minimale par rapport au marché : un prix trop proche se traduit par une erreur 130, détaillée sur sa page. Pensez néanmoins à normaliser le prix d’un ordre limite ou stop, sans quoi c’est cette fois une erreur 4107 qui peut apparaître côté terminal.

Fermeture en boucle

Dans une boucle de fermeture de tous les ordres, chaque OrderClose prend du temps. Rafraîchissez les prix à chaque itération, avant de calculer le prix de clôture, et non une seule fois avant la boucle. La rubrique Ordres et positions en MQL4 détaille la structure de ces boucles.

Le testeur ne montre pas tout

Dans le testeur de stratégie, les prix sont synthétiques et l’erreur 129 n’apparaît que si votre code est franchement faux (Bid et Ask inversés). Les erreurs liées à un prix périmé n’apparaissent qu’en temps réel. Testez la logique d’exécution sur un compte de démonstration avant toute mise en production.

Une erreur 129 non gérée peut empêcher la fermeture d’une position au moment voulu. Assurez-vous que vos routines de clôture utilisent le bon côté de la cotation et journalisent chaque échec. Le trading sur marge comporte un risque de perte en capital.

Questions fréquentes

Pourquoi ai-je une erreur 129 en fermant un achat ?

Parce qu’un achat se ferme au prix Bid. Si vous transmettez Ask à OrderClose pour un ordre OP_BUY, le serveur refuse le prix. Utilisez Bid pour clôturer un achat et Ask pour clôturer une vente.

NormalizeDouble suffit-il à éviter l’erreur 129 ?

Non. La normalisation évite les prix aux décimales anormales, mais un prix normalisé reste refusé s’il est du mauvais côté de la cotation ou trop ancien. Il faut aussi rafraîchir les données avec RefreshRates() et lire le bon côté.

Quelle différence entre l’erreur 129 et l’erreur 135 ?

La 129 indique un prix inacceptable en lui-même. La 135 (ERR_PRICE_CHANGED) indique que le prix a changé entre la lecture et l’exécution. La première appelle une correction du code ; la seconde se traite par un nouvel essai avec un prix rafraîchi.

Comment obtenir le prix d’un autre symbole que celui du graphique ?

Avec MarketInfo(symbole, MODE_ASK) ou MarketInfo(symbole, MODE_BID), puis en normalisant avec MarketInfo(symbole, MODE_DIGITS). Les variables Bid, Ask et Digits ne concernent que le symbole du graphique.

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.