MQL4 · Codes d’erreur
Erreur 135 en MQL4 (ERR_PRICE_CHANGED) : réessayer proprement quand le prix a bougé
L’erreur 135 signale que le prix a changé entre la lecture et l’exécution. Elle est passagère : une boucle de reprise bornée, avec RefreshRates, suffit à la traiter sans risque d’emballement.
L’erreur 135, constante ERR_PRICE_CHANGED, libellé officiel *Price changed*, est un code de retour du serveur qui indique que le prix a changé pendant le traitement de votre requête. Entre le moment où votre EA a lu Bid ou Ask et le moment où le serveur a examiné l’ordre, le marché a bougé, et le serveur n’a pas exécuté au prix demandé.
C’est une erreur passagère par nature. Contrairement aux erreurs 130 ou 134, une nouvelle requête construite avec un prix frais a de bonnes chances d’aboutir. L’enjeu n’est donc pas de corriger un calcul, mais de bâtir une politique de reprise : combien d’essais, à quel rythme, avec quelle tolérance. C’est l’angle de cette page. La recotation proprement dite, avec son paramètre slippage, est traitée sur la page Erreur 138 : requote.
Pourquoi le prix change-t-il ?
Plusieurs facteurs allongent le délai entre la lecture du prix et son examen par le serveur :
- la durée d’exécution de votre code : calculs d’indicateurs, boucles sur l’historique, écriture de fichiers avant l’envoi ;
- la latence réseau entre votre terminal et le serveur, plus forte depuis un ordinateur personnel que depuis un serveur proche du courtier ;
- la volatilité : lors d’une annonce économique, plusieurs ticks peuvent arriver en quelques millisecondes ;
- le mode d’exécution du compte : avec une exécution sur demande ou instantanée, le prix demandé fait partie de la requête et peut être refusé s’il n’est plus valable.
La documentation officielle ne détaille pas la frontière exacte entre l’erreur 135 et l’erreur 138 : elle dépend du serveur et du mode d’exécution. En pratique, les deux se traitent de la même manière.
Une fonction d’envoi avec reprise bornée
La fonction suivante encapsule OrderSend pour un ordre au marché. À chaque essai, elle rafraîchit les prix, recalcule le prix d’exécution et les niveaux, puis envoie. Elle ne réessaie que pour les codes passagers et s’arrête après un nombre d’essais fixé.
//+------------------------------------------------------------------+
//| OrderSend au marché avec reprise sur prix modifié |
//+------------------------------------------------------------------+
#property strict
input int InpMaxAttempts = 3; // nombre maximal d'envois
input int InpPauseMs = 300; // pause entre deux envois (ms)
input int InpSlippage = 5; // glissement toléré (points)
//--- slPts/tpPts : distances en points (0 = pas de niveau)
int SendMarket(const int type, const double lots, const int slPts,
const int tpPts, const int magic)
{
for(int attempt = 1; attempt <= InpMaxAttempts; attempt++)
{
if(IsStopped()) return -1; // l'EA est retiré
RefreshRates(); // prix frais à chaque essai
double price = (type == OP_BUY) ? Ask : Bid;
double ref = (type == OP_BUY) ? Bid : Ask; // référence des stops
double dir = (type == OP_BUY) ? 1.0 : -1.0;
double sl = (slPts > 0) ? NormalizeDouble(ref - dir * slPts * Point, Digits) : 0;
double tp = (tpPts > 0) ? NormalizeDouble(ref + dir * tpPts * Point, Digits) : 0;
ResetLastError();
int ticket = OrderSend(Symbol(), type, lots, NormalizeDouble(price, Digits),
InpSlippage, sl, tp, "reprise 135", magic, 0, clrNONE);
if(ticket >= 0)
return ticket;
int err = GetLastError();
PrintFormat("Essai %d/%d : erreur %d (prix %s)", attempt, InpMaxAttempts,
err, DoubleToString(price, Digits));
if(err != 135 && err != 138 && err != 136) // erreur non passagère
return -1;
Sleep(InpPauseMs);
}
return -1;
}
Trois choix de conception méritent d’être expliqués. D’abord, les stops sont recalculés à chaque essai à partir du nouveau prix : sinon, un stop calculé sur l’ancien prix pourrait devenir trop proche et provoquer une erreur 130. Ensuite, la pause est courte : quelques centaines de millisecondes suffisent pour qu’un nouveau prix soit disponible. Enfin, le nombre d’essais est limité : trois envois au maximum, au-delà desquels l’EA abandonne et attend le tick suivant ou le prochain signal.
Où placer la reprise : dans le tick ou au tick suivant ?
La fonction ci-dessus réessaie immédiatement, dans la même exécution de OnTick(). C’est la solution la plus simple et elle convient à la plupart des EA. Elle a cependant un inconvénient : pendant les pauses, l’EA ne traite aucun nouveau tick, et un autre programme du même terminal peut attendre que le fil de trading se libère.
L’alternative consiste à mémoriser l’intention de trade dans une variable globale du programme, par exemple un type d’ordre et un compteur d’essais, puis à quitter OnTick(). Au tick suivant, l’EA constate qu’une intention est en attente, vérifie que le signal reste valable et renvoie l’ordre. Cette architecture est plus robuste lorsque plusieurs EA tournent sur le même terminal, car elle ne bloque jamais l’exécution. Elle impose en contrepartie de gérer proprement l’expiration de l’intention, afin qu’un ordre ne parte pas plusieurs minutes après le signal.
Quelle que soit l’architecture retenue, journalisez chaque essai avec son numéro, son code et le prix envoyé. Si vous constatez que la plupart des ordres n’aboutissent qu’au deuxième ou troisième essai, c’est un indicateur précieux de la qualité d’exécution de votre environnement.
Le signal est-il toujours valable ?
Une question souvent oubliée : après deux ou trois refus, le prix a bougé, parfois de plusieurs points. Votre signal d’entrée reste-t-il pertinent ? Pour une stratégie de cassure, entrer quelques points plus loin peut dégrader sensiblement le rapport entre gain potentiel et risque. Pour une stratégie à objectifs larges, l’écart est négligeable.
Une bonne pratique consiste à mémoriser le prix du signal et à abandonner si le prix courant s’en est éloigné de plus d’une distance donnée, par exemple une fraction de l’ATR ou du stop. Ce contrôle protège contre les entrées tardives lors des pics de volatilité, précisément les moments où l’erreur 135 est la plus fréquente.
Cas d’usage en trading
Annonces économiques
Lors d’une publication majeure, les erreurs 135 et 138 se multiplient. Plutôt que d’augmenter le nombre d’essais, beaucoup de développeurs préfèrent suspendre les entrées dans une fenêtre autour de l’annonce. C’est un choix de stratégie, mais il réduit à la fois les erreurs et le risque d’exécutions défavorables.
Fermetures
La reprise est encore plus importante pour les fermetures que pour les ouvertures : une position qu’on ne parvient pas à fermer reste exposée. Pour une sortie, vous pouvez accepter un nombre d’essais plus élevé et un glissement plus large que pour une entrée. Les fonctions de fermeture sont détaillées dans la rubrique Ordres et positions en MQL4.
Hébergement
Si l’erreur 135 revient souvent hors des périodes agitées, la latence entre votre terminal et le serveur est probablement en cause. La page Latence et exécution explique comment la mesurer et la réduire.
Ne pas confondre avec la 129
L’erreur 129 (prix invalide) signale un prix inacceptable en lui-même : mauvais côté de la cotation, valeur non normalisée. Elle ne se règle pas par une simple reprise. Si vous observez des 129 au milieu de vos 135, vérifiez le choix du prix, comme expliqué dans Erreur 129 : prix invalide. La vue d’ensemble des codes figure sur la page Codes d’erreur MQL4.
Questions fréquentes
L’erreur 135 est-elle grave ?
Non, elle est passagère : elle indique seulement que le prix a bougé pendant le traitement. Une nouvelle requête avec un prix rafraîchi aboutit généralement. Elle devient problématique si votre EA la traite mal, en boucle infinie ou sans recalculer les stops.
Combien de fois faut-il réessayer ?
Deux ou trois essais suffisent dans la grande majorité des cas. Au-delà, le marché est probablement trop agité ou la connexion instable, et mieux vaut attendre le tick suivant ou abandonner le signal.
Faut-il appeler RefreshRates avant chaque essai ?
Oui. Sans RefreshRates(), les variables Bid et Ask gardent la valeur lue au début de OnTick(), et vous renverriez exactement le même prix périmé.
L’erreur 135 apparaît-elle dans le testeur de stratégie ?
Pratiquement jamais, car le testeur exécute les ordres sur des prix synthétiques sans latence réseau. Votre logique de reprise ne sera réellement éprouvée qu’en temps réel : vérifiez-la sur un compte de démonstration, idéalement pendant une période agitée.
Augmenter le slippage supprime-t-il l’erreur 135 ?
Cela peut réduire certains refus selon le mode d’exécution, mais au prix d’exécutions potentiellement plus éloignées du signal. Fixez un glissement cohérent avec la volatilité du symbole plutôt qu’une valeur très large.
- GetLastError en MQL4
- Erreur 129 : prix invalide
- Erreur 130 : stops invalides
- Erreur 131 : volume invalide
- Erreur 133 : trading interdit
- Erreur 134 : fonds insuffisants
- Erreur 136 : pas de prix
- Erreur 138 : requote
- Erreur 145 : modification refusée (trop proche)
- Erreur 146 : contexte de trading occupé
- Erreur 148 : trop d’ordres
- Erreur 4051 : paramètre invalide
- Erreur 4107 : prix invalide
- Erreur 4108 : ticket invalide
- Erreur 4109 : trading non autorisé
- Erreurs 4110 et 4111 : achats ou ventes non autorisés
- Erreurs de compilation MQL4
