MQL5 · Codes d’erreur
Erreur 10015 Invalid price en MQL5 : aligner et placer ses prix
Le retcode 10015 signale un prix refusé : mal aligné sur le tick, ordre en attente du mauvais côté du marché ou cotation périmée. Diagnostic et code MQL5.
Le code 10015 (TRADE_RETCODE_INVALID_PRICE, libellé officiel « Invalid price in the request ») indique que le prix figurant dans votre requête n’est pas acceptable pour le serveur. Les causes se répartissent en trois familles : un prix qui n’est pas aligné sur la granularité du symbole (taille de tick), un ordre en attente placé du mauvais côté du marché ou trop près de lui, et un prix d’ordre au marché qui ne correspond pas à la cotation courante. Dans tous les cas, la correction se fait dans le code : on construit le prix à partir du dernier tick, on l’aligne sur la taille de tick et on vérifie sa position par rapport au marché avant l’envoi.
Cette page détaille ces trois familles et fournit les fonctions de contrôle correspondantes. Elle appartient à la rubrique Codes d’erreur et de retour MQL5.
Première cause : un prix mal aligné
Chaque symbole a une variation minimale de prix, SYMBOL_TRADE_TICK_SIZE. Sur la plupart des paires forex, elle est égale au point (_Point), par exemple 0,00001. Mais sur de nombreux indices, métaux ou contrats à terme, elle est plus grande : un indice coté avec deux décimales peut n’accepter que des multiples de 0,25 ou de 0,5, selon le courtier.
L’erreur classique consiste à arrondir le prix avec NormalizeDouble(prix, _Digits) en pensant que cela suffit. Cet arrondi aligne le prix sur le nombre de décimales, pas sur la taille de tick. Un prix de 18 452,30 est correctement arrondi à deux décimales, mais invalide si seuls les multiples de 0,25 sont acceptés. La page NormalizeDouble et précision des prix explique la différence en détail ; voici la fonction qui règle le problème :
//+------------------------------------------------------------------+
//| Aligne un prix sur la taille de tick du symbole |
//+------------------------------------------------------------------+
double NormalizePrice(const string symbol, const double price)
{
double tick = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
if(tick <= 0.0)
return NormalizeDouble(price, digits); // repli prudent
return NormalizeDouble(MathRound(price / tick) * tick, digits);
}
Deuxième cause : un ordre en attente mal placé
Chaque type d’ordre en attente a un côté obligatoire par rapport au marché. Un ordre limite parie sur un retour du prix, un ordre stop sur une poursuite du mouvement :
| Type d’ordre | Doit être placé | Prix de référence |
|---|---|---|
ORDER_TYPE_BUY_LIMIT | Sous le marché | Ask |
ORDER_TYPE_BUY_STOP | Au-dessus du marché | Ask |
ORDER_TYPE_SELL_LIMIT | Au-dessus du marché | Bid |
ORDER_TYPE_SELL_STOP | Sous le marché | Bid |
Un achat limite placé au-dessus de l’Ask n’a pas de sens : il serait exécuté immédiatement. Le serveur le refuse. Ce cas apparaît souvent quand un EA calcule un niveau d’entrée sur une bougie passée et que le marché a entre-temps franchi ce niveau. Une cassure attendue à 1,0850 devient un ordre stop invalide si le prix est déjà à 1,0855.
À cela s’ajoute la distance minimale SYMBOL_TRADE_STOPS_LEVEL : un ordre en attente doit être placé à au moins ce nombre de points du prix courant. Un ordre trop proche est lui aussi refusé. Lorsque la valeur vaut 0, le courtier n’impose pas de distance fixe, mais une marge d’un ou deux spreads reste prudente.
Troisième cause : un prix d’ordre au marché périmé
Pour un ordre au marché, le champ price doit correspondre à l’Ask pour un achat et au Bid pour une vente. En exécution instantanée, un écart trop grand produit plutôt un requote (voir 10004 Requote), mais un prix aberrant, nul ou pris du mauvais côté peut donner un 10015. Les erreurs typiques : utiliser le Bid pour acheter, réutiliser un prix calculé plusieurs secondes plus tôt, ou envoyer Close[0] d’une série au lieu du dernier tick.
Une fonction de contrôle des ordres en attente
La fonction suivante combine alignement, côté du marché et distance minimale. Elle renvoie false avec un message clair au lieu de laisser le serveur répondre 10015.
//+------------------------------------------------------------------+
//| Vérifie et aligne le prix d'un ordre en attente |
//+------------------------------------------------------------------+
bool CheckPendingPrice(const string symbol, const ENUM_ORDER_TYPE type, double &price)
{
MqlTick t;
if(!SymbolInfoTick(symbol, t))
return false;
price = NormalizePrice(symbol, price);
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
long stopsLvl = SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL);
double minDist = stopsLvl * point;
bool ok = false;
switch(type)
{
case ORDER_TYPE_BUY_LIMIT: ok = (price <= t.ask - minDist); break;
case ORDER_TYPE_BUY_STOP: ok = (price >= t.ask + minDist); break;
case ORDER_TYPE_SELL_LIMIT: ok = (price >= t.bid + minDist); break;
case ORDER_TYPE_SELL_STOP: ok = (price <= t.bid - minDist); break;
default:
Print("CheckPendingPrice : type non géré");
return false;
}
if(!ok)
PrintFormat("%s %s @ %.5f refusé localement : Bid %.5f Ask %.5f, distance mini %d pts",
symbol, EnumToString(type), price, t.bid, t.ask, (int)stopsLvl);
return ok;
}
Dans un EA de cassure, que faire si le contrôle échoue parce que le prix a déjà franchi le niveau ? Il existe deux réponses défendables : renoncer au trade, ou entrer au marché si l’écart reste faible. Mais ce choix appartient à la stratégie et doit être testé, pas improvisé dans la gestion d’erreur. Les différents types d’ordres sont présentés dans Ordres limites et stop.
Et lors d’une modification d’ordre ?
Déplacer un ordre en attente avec TRADE_ACTION_MODIFY (ou OrderModify() de la classe CTrade) soumet le nouveau prix aux mêmes règles : alignement sur le tick, bon côté du marché, distance minimale. Un EA qui « suit » le prix avec un ordre stop, par exemple pour une entrée sur cassure glissante, doit donc appeler la même fonction de contrôle avant chaque modification.
Une contrainte supplémentaire s’applique : la zone de gel SYMBOL_TRADE_FREEZE_LEVEL. Lorsque le prix d’activation d’un ordre se trouve à moins de cette distance du marché, l’ordre ne peut plus être modifié ni supprimé. Le serveur répond alors généralement par 10029 (TRADE_RETCODE_FROZEN, ordre ou position gelé) plutôt que par 10015. Lisez cette propriété au même endroit que le StopsLevel, afin de ne pas tenter de modification vouée à l’échec.
Diagnostiquer un 10015 dans le journal
La ligne de journal utile contient : le type d’ordre, le prix envoyé avec toutes ses décimales, le Bid et l’Ask au moment de l’envoi, la taille de tick et le StopsLevel. Avec ces éléments, trois questions suffisent :
- Le prix est-il un multiple exact de la taille de tick ? Sinon, problème d’alignement.
- Le prix est-il du bon côté du marché pour ce type d’ordre ? Sinon, niveau calculé périmé ou type d’ordre inversé.
- La distance au marché respecte-t-elle le StopsLevel ? Sinon, ordre trop proche.
Un réflexe complémentaire : faire passer la requête dans OrderCheck(), qui place le retcode dans sa structure de résultat sans rien envoyer au serveur.
Pièges fréquents
- Utiliser
_Pointcomme pas de prix universel. Il correspond à la plus petite décimale affichée, pas forcément au tick négociable. - Mélanger Bid et Ask. Un ordre d’achat se réfère à l’Ask, un ordre de vente au Bid ; les stops et limites suivent la même logique.
- Inverser LIMIT et STOP. Un « achat sur cassure » est un BUY_STOP, pas un BUY_LIMIT. L’inversion produit un prix du mauvais côté.
- Réessayer en boucle. Un prix structurellement invalide le restera ; seul un prix périmé justifie de reconstruire la requête avec un tick frais.
- Oublier les week-ends et les gaps. À la réouverture, le marché peut s’ouvrir au-delà de vos niveaux ; un ordre recalculé sur la clôture du vendredi devient invalide.
Questions fréquentes
NormalizeDouble(price, _Digits) ne suffit-il pas ?
Pas toujours. Il arrondit au nombre de décimales, alors que le serveur exige un multiple de SYMBOL_TRADE_TICK_SIZE. Sur les symboles où la taille de tick est supérieure au point, il faut d’abord arrondir au tick.
Quelle différence entre 10015 et 10016 ?
10015 concerne le prix de l’ordre lui-même (prix d’entrée ou d’activation). 10016 concerne les niveaux de stop loss et de take profit. Un ordre en attente peut cumuler les deux problèmes ; corrigez d’abord le prix, puis les stops.
Pourquoi mon ordre BUY_STOP est-il refusé alors que le prix est au-dessus du marché ?
Vérifiez qu’il est au-dessus de l’Ask et non du Bid, qu’il respecte la distance SYMBOL_TRADE_STOPS_LEVEL et qu’il est aligné sur la taille de tick. Un écart d’un seul point suffit à provoquer le refus.
Un 10015 peut-il venir d’un marché très rapide ?
Oui, indirectement : le niveau calculé peut se retrouver du mauvais côté du prix quelques millisecondes plus tard. La parade consiste à relire le tick juste avant l’envoi et à revérifier la position du prix.
- Erreurs de compilation MQL5
- Invalid pointer access
- GetLastError et gestion des erreurs
- Codes de retour du serveur de trading
- 10004 Requote
- 10006 Requête rejetée
- 10013 Requête invalide
- 10014 Volume invalide
- 10016 Stops invalides
- 10017 Trading désactivé
- 10018 Marché fermé
- 10019 Fonds insuffisants
- 10021 Pas de cotations
- 10024 Trop de requêtes
- 10027 Trading automatique désactivé
- 10030 Mode de remplissage non supporté
- 4756 Échec d’envoi de la requête
- Array out of range
- Division par zéro
