MQL5 · Codes d’erreur
Erreur 10013 Invalid request en MQL5 : relire et valider la requête
Le retcode 10013 signale une requête MqlTradeRequest incohérente. Grille de relecture par action, structure vierge et fonction MQL5 de validation avant envoi.
Le code 10013 (TRADE_RETCODE_INVALID, libellé officiel « Invalid request ») signifie que le serveur juge la requête de trading incohérente dans son ensemble. Il ne pointe ni le volume, ni le prix, ni les stops (qui ont leurs propres codes 10014, 10015 et 10016) : il signale le plus souvent une structure MqlTradeRequest mal remplie, avec un champ manquant ou une combinaison d’action et de type d’ordre qui n’a pas de sens. La correction passe donc par une relecture méthodique de la requête, champ par champ, en fonction de l’action demandée.
Cette page fournit cette grille de relecture et une fonction de validation à appeler avant l’envoi. Elle s’inscrit dans la rubrique Codes d’erreur et de retour MQL5.
Pourquoi ce code est-il si peu précis ?
Le serveur commence par vérifier que la requête est interprétable : une action connue, un symbole, des champs compatibles entre eux. Si cette première étape échoue, il n’a pas de raison de pousser l’analyse jusqu’au volume ou aux stops ; il renvoie donc un code générique. C’est pourquoi 10013 apparaît surtout pendant le développement, lorsque l’on écrit ses premières fonctions d’envoi avec la structure brute, et beaucoup plus rarement avec la classe CTrade, qui remplit les champs à votre place.
La requête dépend de l’action
Le champ action détermine quels autres champs sont attendus. La documentation de MqlTradeRequest décrit six actions principales :
| Action | Usage | Champs indispensables à vérifier |
|---|---|---|
TRADE_ACTION_DEAL | Ordre au marché | symbol, volume, type (BUY ou SELL), price selon le mode d’exécution, type_filling |
TRADE_ACTION_PENDING | Ordre en attente | symbol, volume, type (LIMIT, STOP, STOP_LIMIT), price, type_time |
TRADE_ACTION_SLTP | Modifier SL/TP d’une position | symbol, position (ticket), sl, tp |
TRADE_ACTION_MODIFY | Modifier un ordre en attente | order (ticket), price, sl, tp, type_time |
TRADE_ACTION_REMOVE | Supprimer un ordre en attente | order (ticket) |
TRADE_ACTION_CLOSE_BY | Clôturer par une position opposée | position, position_by |
Les incohérences typiques qui méritent d’être vérifiées en premier lorsqu’apparaît un 10013 :
- une action
TRADE_ACTION_DEALavec un type d’ordre en attente (ORDER_TYPE_BUY_LIMIT, par exemple), ou l’inverse ; - une modification
TRADE_ACTION_SLTPsans ticket de position sur un compte de couverture (hedging), où plusieurs positions peuvent coexister sur le même symbole ; - un ticket
orderoupositionresté à zéro parce que la sélection préalable a échoué ; - une structure réutilisée d’un envoi à l’autre sans remise à zéro, qui transporte des valeurs résiduelles ;
- un champ
symbolvide ou mal orthographié (suffixe du courtier oublié).
Les deux dernières causes sont les plus sournoises, car le code « a l’air juste » à la lecture.
Toujours repartir d’une structure vierge
Déclarer les structures avec un initialiseur vide garantit que tous les champs sont à zéro :
MqlTradeRequest req = {}; // tous les champs à zéro
MqlTradeResult res = {};
// Pour une structure réutilisée (variable globale, membre de classe) :
ZeroMemory(req);
Une variable globale MqlTradeRequest réutilisée pour une modification de stops après un ordre au marché conserve par exemple son volume, son type et son deviation. Selon l’action, ces restes peuvent rendre la requête incohérente.
Une fonction de validation avant envoi
La fonction suivante contrôle les incohérences les plus courantes et affiche un message explicite, bien plus parlant qu’un 10013 renvoyé par le serveur. Elle ne remplace pas OrderCheck(), qui reste le contrôle de référence ; elle intercepte simplement les erreurs de construction propres à votre code.
//+------------------------------------------------------------------+
//| Contrôle de cohérence d'une requête avant OrderCheck/OrderSend |
//+------------------------------------------------------------------+
bool ValidateRequest(const MqlTradeRequest &r)
{
// Symbole présent et connu du terminal
if(r.symbol == "" || !SymbolInfoInteger(r.symbol, SYMBOL_SELECT))
{
PrintFormat("Requête : symbole '%s' absent ou non sélectionné", r.symbol);
return false;
}
bool isMarket = (r.type == ORDER_TYPE_BUY || r.type == ORDER_TYPE_SELL);
switch(r.action)
{
case TRADE_ACTION_DEAL:
if(!isMarket) { Print("DEAL avec un type d'ordre en attente"); return false; }
if(r.volume <= 0.0) { Print("DEAL sans volume"); return false; }
break;
case TRADE_ACTION_PENDING:
if(isMarket) { Print("PENDING avec un type au marché"); return false; }
if(r.price <= 0.0) { Print("PENDING sans prix d'activation"); return false; }
break;
case TRADE_ACTION_SLTP:
if(r.position == 0) { Print("SLTP sans ticket de position"); return false; }
break;
case TRADE_ACTION_MODIFY:
case TRADE_ACTION_REMOVE:
if(r.order == 0) { Print("MODIFY/REMOVE sans ticket d'ordre"); return false; }
break;
case TRADE_ACTION_CLOSE_BY:
if(r.position == 0 || r.position_by == 0)
{ Print("CLOSE_BY sans les deux tickets"); return false; }
break;
default:
PrintFormat("Action inconnue : %d", (int)r.action);
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| Exemple : modifier le stop loss d'une position précise |
//+------------------------------------------------------------------+
bool ModifySL(const ulong ticket, const double newSL)
{
if(!PositionSelectByTicket(ticket))
return false; // la position n'existe plus
MqlTradeRequest req = {};
MqlTradeResult res = {};
req.action = TRADE_ACTION_SLTP;
req.symbol = PositionGetString(POSITION_SYMBOL);
req.position = ticket; // indispensable en hedging
req.sl = newSL;
req.tp = PositionGetDouble(POSITION_TP); // on conserve le TP existant
if(!ValidateRequest(req))
return false;
if(!OrderSend(req, res))
PrintFormat("SLTP refusé : retcode %u (%s)", res.retcode, res.comment);
return(res.retcode == TRADE_RETCODE_DONE);
}
Remarquez que ModifySL() renvoie aussi le take profit existant. Envoyer tp = 0 sur une action TRADE_ACTION_SLTP ne déclenche pas forcément d’erreur, mais supprime le take profit : c’est un autre piège classique des requêtes construites à la main.
Diagnostiquer dans le journal
Quand un 10013 apparaît, imprimez la requête complète juste avant l’envoi : action, type, symbole, volume, prix, sl, tp, tickets order et position, type de remplissage. La comparaison avec le tableau ci-dessus révèle presque toujours le champ manquant en quelques secondes. Sur un compte netting, pensez aussi que la notion de position est différente : une seule position par symbole, ce qui change la façon de cibler une modification. Les deux modèles sont comparés dans Comptes netting ou hedging.
Un cas réel : la position introuvable
Prenons un EA de trailing stop qui parcourt les positions ouvertes et modifie leur stop loss. En développement sur un compte netting, tout fonctionne. Transféré sur un compte hedging, il renvoie des 10013 en série. La cause : la fonction de modification ne renseignait que symbol, ce qui suffit en netting puisqu’il n’existe qu’une position par symbole, mais pas en hedging. Le correctif consiste à récupérer le ticket avec PositionGetTicket(i) dans la boucle et à le placer dans req.position.
Variante fréquente du même problème : la boucle de parcours sélectionne la position, puis une autre fonction en sélectionne une seconde avant l’envoi. Les données lues via PositionGetDouble() ne correspondent alors plus au ticket que l’on croit modifier. Lisez toutes les propriétés nécessaires juste après la sélection, stockez-les dans des variables locales, puis construisez la requête. La page Parcourir et filtrer les positions détaille la bonne façon d’itérer.
Méthode en cinq étapes face à un 10013
- Isolez l’action concernée en relisant le champ
actiondans le journal : un 10013 sur une ouverture et un 10013 sur une modification n’ont pas les mêmes causes. - Imprimez la requête complète juste avant l’envoi, avec chaque champ nommé.
- Comparez avec le tableau des champs indispensables pour cette action.
- Passez la requête à
OrderCheck()et lisez le retcode et le commentaire du résultat de contrôle. - Corrigez la construction, pas les valeurs : un 10013 se règle presque toujours en ajoutant un champ manquant ou en supprimant un reste d’une requête précédente.
Ne mettez pas de nouvel essai automatique sur ce code. Une requête mal formée le restera au tick suivant, et l’insistance risque surtout de produire un 10024 Trop de requêtes.
CTrade comme filet de sécurité
Si vous n’avez pas de besoin particulier, la classe CTrade évite la plupart des 10013 : PositionModify(), PositionClose(), OrderDelete() construisent pour vous une requête cohérente avec l’action. La structure brute reste utile pour comprendre le mécanisme ou pour des besoins très spécifiques, mais elle exige cette discipline de validation.
À retenir
Un 10013 n’est jamais dû au hasard du marché : c’est un défaut de construction. Il se reproduit à l’identique, ce qui le rend facile à corriger une fois la requête imprimée. Prenez l’habitude de valider vos requêtes dans un script de test avant de les intégrer à l’EA : un script qui envoie un ordre minimal sur compte démo, puis le modifie et le supprime, couvre en quelques secondes les trois actions les plus utilisées.
Questions fréquentes
Quelle différence entre 10013 et 10014, 10015 ou 10016 ?
10013 signale une requête incohérente dans son ensemble. Les trois autres codes désignent un champ précis : le volume, le prix ou les niveaux de stop. Un 10013 doit vous faire relire la structure de la requête plutôt que les valeurs numériques.
OrderCheck détecte-t-il un 10013 ?
OrderCheck() renvoie false lorsque les paramètres sont mal remplis et place un code dans MqlTradeCheckResult.retcode. C’est le moyen le plus fiable de découvrir l’erreur avant l’envoi réel.
Pourquoi ma modification de stop fonctionne en netting et pas en hedging ?
En hedging, plusieurs positions peuvent exister sur le même symbole : le serveur a besoin du ticket dans le champ position pour savoir laquelle modifier. Renseignez-le systématiquement, quel que soit le type de compte.
ZeroMemory est-il nécessaire si je déclare la structure en local ?
Non si vous utilisez l’initialiseur = {} à la déclaration. ZeroMemory() est utile pour une structure réutilisée, globale ou membre d’une classe.
- 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
- 10014 Volume invalide
- 10015 Prix 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
