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

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.

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

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 :

ActionUsageChamps indispensables à vérifier
TRADE_ACTION_DEALOrdre au marchésymbol, volume, type (BUY ou SELL), price selon le mode d’exécution, type_filling
TRADE_ACTION_PENDINGOrdre en attentesymbol, volume, type (LIMIT, STOP, STOP_LIMIT), price, type_time
TRADE_ACTION_SLTPModifier SL/TP d’une positionsymbol, position (ticket), sl, tp
TRADE_ACTION_MODIFYModifier un ordre en attenteorder (ticket), price, sl, tp, type_time
TRADE_ACTION_REMOVESupprimer un ordre en attenteorder (ticket)
TRADE_ACTION_CLOSE_BYClôturer par une position opposéeposition, 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_DEAL avec un type d’ordre en attente (ORDER_TYPE_BUY_LIMIT, par exemple), ou l’inverse ;
  • une modification TRADE_ACTION_SLTP sans ticket de position sur un compte de couverture (hedging), où plusieurs positions peuvent coexister sur le même symbole ;
  • un ticket order ou position resté à 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 symbol vide 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

  1. Isolez l’action concernée en relisant le champ action dans le journal : un 10013 sur une ouverture et un 10013 sur une modification n’ont pas les mêmes causes.
  2. Imprimez la requête complète juste avant l’envoi, avec chaque champ nommé.
  3. Comparez avec le tableau des champs indispensables pour cette action.
  4. Passez la requête à OrderCheck() et lisez le retcode et le commentaire du résultat de contrôle.
  5. 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.

Une requête incohérente envoyée en réel peut aussi produire un résultat inattendu au lieu d’un refus, par exemple la suppression d’un take profit. Testez toute fonction d’envoi écrite à la main sur compte démo et vérifiez l’état réel des positions après chaque opération.

À 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.

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.