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

MQL4 · Codes d’erreur

Erreur 4107 en MQL4 (ERR_INVALID_PRICE_PARAM) : le prix rejeté par le terminal

L’erreur 4107 est détectée par le terminal avant tout envoi : le prix passé à une fonction de trading est mal formé. Normalisation, taille de tick et différence avec l’erreur 129 expliquées.

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

L’erreur 4107, constante ERR_INVALID_PRICE_PARAM, signale un paramètre de prix invalide transmis à une fonction de trading. C’est une erreur d’exécution de la famille 4000 : elle est détectée par le terminal MetaTrader 4 lui-même, avant que la requête ne parte vers le serveur. C’est ce qui la distingue de l’erreur 129 (ERR_INVALID_PRICE), dont le libellé est presque identique mais qui est renvoyée par le serveur de trading après examen de la requête.

Cette distinction n’est pas qu’une curiosité : elle indique où regarder. Avec une 4107, le problème se situe dans la valeur numérique elle-même, telle que votre code l’a construite : précision excessive, valeur nulle ou négative, prix incohérent avec le symbole. Avec une 129, la valeur est bien formée mais le serveur ne l’accepte pas (mauvais côté de la cotation, prix périmé). L’angle de cette page est la construction d’un prix valide : normalisation, alignement sur la taille de tick et contrôles de cohérence.

Les causes de l’erreur 4107

Prix non normalisé

C’est la cause principale. Un prix calculé, par exemple Ask - 25 * Point ou un niveau issu d’une moyenne, contient très souvent des décimales parasites dues à la représentation binaire des nombres à virgule : 1.08345000000000001 au lieu de 1.08345. Le terminal attend un prix exprimé avec le nombre de décimales du symbole. La fonction NormalizeDouble(valeur, Digits) arrondit la valeur à la précision voulue.

Prix non aligné sur la taille de tick

Pour la plupart des paires de devises, la taille de tick (MODE_TICKSIZE) est égale au point. Mais pour certains indices, métaux ou contrats, le prix ne peut varier que par pas plus larges : 0,25, 0,5, 1 point… Un prix normalisé à Digits décimales peut alors rester invalide parce qu’il ne tombe pas sur un multiple du tick. Il faut l’arrondir au tick, puis normaliser.

Valeur nulle, négative ou absurde

Un prix de 0 pour un ordre en attente, un niveau négatif issu d’une soustraction mal contrôlée, ou un prix d’un autre ordre de grandeur (celui d’un autre symbole) sont rejetés. Ces cas trahissent généralement une variable non initialisée ou un calcul effectué avec les propriétés du mauvais symbole.

Prix lu sur le mauvais symbole

Un EA multi-paires qui utilise Digits et Point (propriétés du graphique) pour normaliser le prix d’un autre symbole produit des valeurs mal arrondies. Lisez systématiquement MODE_DIGITS, MODE_POINT et MODE_TICKSIZE du symbole visé avec MarketInfo().

Une fonction de normalisation complète

La fonction ci-dessous produit un prix valide pour n’importe quel symbole : elle aligne la valeur sur la taille de tick, puis la normalise au nombre de décimales. Elle refuse les valeurs nulles ou négatives, ce qui permet de détecter les erreurs de calcul avant l’appel de trading.

//+------------------------------------------------------------------+
//| Prix aligné sur le tick et normalisé pour un symbole donné       |
//+------------------------------------------------------------------+
#property strict

//--- renvoie 0 si le prix est inutilisable
double NormalizePrice(const string sym, const double price)
  {
   if(price <= 0)
      return 0;
   double tick   = MarketInfo(sym, MODE_TICKSIZE);
   int    digits = (int)MarketInfo(sym, MODE_DIGITS);
   if(tick <= 0)
      tick = MarketInfo(sym, MODE_POINT);       // repli si la propriété manque
   double aligned = MathRound(price / tick) * tick;
   return NormalizeDouble(aligned, digits);
  }

//--- exemple : Buy Stop placé à une distance en points au-dessus du Ask
int PlaceBuyStop(const string sym, const int distancePts, const double lots,
                 const int slPts, const int magic)
  {
   RefreshRates();
   double point = MarketInfo(sym, MODE_POINT);
   double ask   = MarketInfo(sym, MODE_ASK);

   double price = NormalizePrice(sym, ask + distancePts * point);
   double sl    = (slPts > 0) ? NormalizePrice(sym, price - slPts * point) : 0;
   if(price == 0)
     {
      Print("Prix d'ordre inutilisable : envoi annulé");
      return -1;
     }

   ResetLastError();
   int ticket = OrderSend(sym, OP_BUYSTOP, lots, price, 0, sl, 0,
                          "buy stop", magic, 0, clrNONE);
   if(ticket < 0)
     {
      int err = GetLastError();
      PrintFormat("%s Buy Stop à %s : erreur %d", sym,
                  DoubleToString(price, 8), err);   // 8 décimales pour voir les parasites
     }
   return ticket;
  }

Remarquez l’affichage du prix avec huit décimales dans le message d’erreur. Afficher un prix avec Digits décimales masque justement le défaut que l’on cherche : 1.08345000000000001 s’affiche 1.08345. En cas de doute, journalisez toujours la valeur brute avec une précision supérieure.

Pourquoi les décimales parasites apparaissent-elles ?

Le type double stocke les nombres en binaire. Or la plupart des fractions décimales, comme 0,1 ou 0,00001, n’ont pas de représentation binaire exacte : elles sont stockées sous forme d’une valeur très proche. Chaque addition, soustraction ou multiplication peut accumuler ces minuscules écarts. Après quelques opérations, un prix qui devrait valoir 1,08345 vaut en réalité 1,0834500000000001 ou 1,0834499999999999.

Ces écarts sont invisibles dans la plupart des affichages, mais suffisent pour qu’une valeur ne corresponde plus exactement à un prix du symbole. NormalizeDouble ramène la valeur au plus proche nombre représentable avec le nombre de décimales demandé, ce qui la rend acceptable par le terminal. Ce n’est pas un défaut propre à MQL4 : tous les langages qui utilisent des nombres à virgule flottante présentent ce comportement. La seule parade est de normaliser au dernier moment, juste avant de transmettre le prix à une fonction de trading, et de ne jamais réutiliser un prix normalisé dans de nouveaux calculs sans le normaliser à nouveau.

4107 ou 129 : savoir où chercher

Critère4107129
FamilleErreur d’exécution du terminalCode de retour du serveur
MomentAvant l’envoi de la requêteAprès examen par le serveur
Cause typiqueValeur mal formée (précision, tick, signe)Prix inacceptable (côté, fraîcheur)
CorrectionNormaliser et aligner sur le tickLire le bon côté, rafraîchir les prix

Les deux erreurs peuvent se succéder : une fois la 4107 corrigée par la normalisation, un prix encore du mauvais côté de la cotation produira une 129. Traitez-les dans cet ordre, de la forme vers le fond.

Cas d’usage en trading

Ordres en attente et niveaux calculés

Les ordres en attente sont les plus exposés à l’erreur 4107, parce que leur prix est toujours calculé : distance fixe au marché, plus haut de la veille, niveau d’un indicateur. Chaque prix calculé doit passer par une fonction comme NormalizePrice. La page Ordres en attente détaille les règles de placement propres à chaque type d’ordre.

Stop loss et take profit

Les niveaux de stop sont aussi des prix et doivent être normalisés de la même façon. Un stop non normalisé peut provoquer une 4107 ou, selon le cas, une erreur 130, puisque la documentation de OrderSend mentionne explicitement les niveaux non normalisés parmi les causes de cette dernière.

Comparer des prix

La normalisation sert aussi aux comparaisons. Tester l’égalité de deux double (if(sl == OrderStopLoss())) échoue souvent à cause des décimales parasites. Comparez plutôt la différence à une fraction de point, ou comparez des valeurs normalisées. Les propriétés Point et Digits sont présentées dans Variables prédéfinies.

Une erreur à corriger une fois pour toutes

L’erreur 4107 ne justifie jamais un nouvel essai : le même prix produira le même refus. Centralisez la construction des prix dans une fonction unique et utilisez-la partout. Pour les autres codes, consultez Codes d’erreur MQL4.

Un ordre en attente refusé pour un prix mal formé n’est simplement pas placé : votre stratégie peut alors manquer une entrée ou, plus grave, une protection. Vérifiez la valeur de retour de chaque appel de trading. Le trading comporte un risque de perte en capital.

Questions fréquentes

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

La 4107 est détectée par le terminal avant l’envoi : la valeur du prix est mal formée. La 129 est renvoyée par le serveur : le prix est bien formé mais inacceptable, par exemple du mauvais côté de la cotation ou périmé.

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

Sur la plupart des paires de devises, oui, car la taille de tick est égale au point. Sur les symboles dont le tick est plus large, il faut d’abord arrondir le prix au multiple de MODE_TICKSIZE, puis normaliser.

Pourquoi mon prix semble correct dans le journal alors qu’il est refusé ?

Parce qu’il est affiché avec un nombre limité de décimales, qui masque les parasites de la virgule flottante. Affichez-le avec DoubleToString(prix, 8) pour voir sa valeur réelle.

L’erreur 4107 peut-elle concerner OrderClose ?

Oui, toute fonction de trading qui reçoit un prix peut la produire. Pour une clôture, utilisez le Bid ou le Ask du symbole de l’ordre, normalisé avec ses propres décimales.

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.