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

MQL5 · Codes d’erreur

Codes de retour du serveur de trading MQL5 (retcodes 10004 à 10046)

La table complète des retcodes MQL5, la structure MqlTradeResult et une méthode simple pour distinguer succès, erreurs de requête, interdictions et conditions passagères.

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

Après chaque appel à OrderSend(), le serveur de trading répond par un code numérique placé dans le champ retcode de la structure MqlTradeResult. Ces codes de retour vont de 10004 à 10046 et forment une énumération dédiée, distincte des erreurs d’exécution lues avec GetLastError(). Trois d’entre eux signalent un succès (10008, 10009, 10010) ; tous les autres décrivent une raison de refus ou un état particulier. Lire ce code systématiquement est la seule façon de savoir ce qu’est réellement devenue votre requête.

Cette page présente la structure de la réponse, la table complète des codes et une méthode pour les traiter. Chaque code fréquent dispose ensuite de sa propre page dans la rubrique Codes d’erreur et de retour MQL5.

Ce que contient MqlTradeResult

La documentation définit la structure ainsi :

struct MqlTradeResult
  {
   uint     retcode;          // code de retour du serveur
   ulong    deal;             // ticket de la transaction, si exécutée
   ulong    order;            // ticket de l'ordre, s'il a été placé
   double   volume;           // volume confirmé par le courtier
   double   price;            // prix confirmé par le courtier
   double   bid;              // Bid courant (prix de requote)
   double   ask;              // Ask courant (prix de requote)
   string   comment;          // commentaire du courtier
   uint     request_id;       // identifiant de requête (mode asynchrone)
   int      retcode_external; // code d'erreur d'un système de trading externe
  };

Deux champs sont souvent négligés. comment contient parfois une précision utile ajoutée par le serveur. retcode_external transmet le code d’un système externe (par exemple une plateforme de liquidité en amont du courtier) ; sa signification dépend du courtier, il faut donc l’interpréter avec sa documentation.

Un point crucial de la documentation d’OrderSend() : la valeur true signifie seulement que la requête a passé le contrôle de base et a été acceptée pour traitement. Ce n’est pas la preuve qu’un trade a eu lieu. Vous devez toujours tester retcode.

La table complète des codes de retour

CodeConstanteSignification
10004TRADE_RETCODE_REQUOTERequote : nouveau prix proposé
10006TRADE_RETCODE_REJECTRequête rejetée
10007TRADE_RETCODE_CANCELRequête annulée par le trader
10008TRADE_RETCODE_PLACEDOrdre placé (succès)
10009TRADE_RETCODE_DONERequête exécutée (succès)
10010TRADE_RETCODE_DONE_PARTIALExécution partielle (succès partiel)
10011TRADE_RETCODE_ERRORErreur de traitement de la requête
10012TRADE_RETCODE_TIMEOUTRequête annulée par dépassement de délai
10013TRADE_RETCODE_INVALIDRequête invalide
10014TRADE_RETCODE_INVALID_VOLUMEVolume invalide
10015TRADE_RETCODE_INVALID_PRICEPrix invalide
10016TRADE_RETCODE_INVALID_STOPSStops invalides
10017TRADE_RETCODE_TRADE_DISABLEDTrading désactivé
10018TRADE_RETCODE_MARKET_CLOSEDMarché fermé
10019TRADE_RETCODE_NO_MONEYFonds insuffisants
10020TRADE_RETCODE_PRICE_CHANGEDLes prix ont changé
10021TRADE_RETCODE_PRICE_OFFPas de cotations pour traiter la requête
10022TRADE_RETCODE_INVALID_EXPIRATIONDate d’expiration invalide
10023TRADE_RETCODE_ORDER_CHANGEDL’état de l’ordre a changé
10024TRADE_RETCODE_TOO_MANY_REQUESTSRequêtes trop fréquentes
10025TRADE_RETCODE_NO_CHANGESAucun changement dans la requête
10026TRADE_RETCODE_SERVER_DISABLES_ATTrading automatique désactivé par le serveur
10027TRADE_RETCODE_CLIENT_DISABLES_ATTrading automatique désactivé par le terminal
10028TRADE_RETCODE_LOCKEDRequête verrouillée pour traitement
10029TRADE_RETCODE_FROZENOrdre ou position gelé
10030TRADE_RETCODE_INVALID_FILLType de remplissage invalide
10031TRADE_RETCODE_CONNECTIONPas de connexion au serveur de trading
10032TRADE_RETCODE_ONLY_REALOpération autorisée uniquement sur compte réel
10033TRADE_RETCODE_LIMIT_ORDERSLimite du nombre d’ordres en attente atteinte
10034TRADE_RETCODE_LIMIT_VOLUMELimite de volume du symbole atteinte
10035TRADE_RETCODE_INVALID_ORDERType d’ordre invalide ou interdit
10036TRADE_RETCODE_POSITION_CLOSEDPosition déjà clôturée
10038TRADE_RETCODE_INVALID_CLOSE_VOLUMEVolume de clôture supérieur au volume de la position
10039TRADE_RETCODE_CLOSE_ORDER_EXISTUn ordre de clôture existe déjà pour cette position
10040TRADE_RETCODE_LIMIT_POSITIONSLimite du nombre de positions ouvertes atteinte
10041TRADE_RETCODE_REJECT_CANCELActivation de l’ordre en attente rejetée, ordre annulé
10042TRADE_RETCODE_LONG_ONLYSeules les positions acheteuses sont autorisées
10043TRADE_RETCODE_SHORT_ONLYSeules les positions vendeuses sont autorisées
10044TRADE_RETCODE_CLOSE_ONLYSeule la clôture de positions est autorisée
10045TRADE_RETCODE_FIFO_CLOSEClôture selon la règle FIFO obligatoire
10046TRADE_RETCODE_HEDGE_PROHIBITEDPositions opposées interdites sur ce symbole

Les numéros 10005 et 10037 n’existent pas dans la documentation : ne les cherchez pas.

Classer les codes pour décider

La table est longue, mais votre code n’a besoin que de quatre réactions :

  • Succès : 10008, 10009, et 10010 (en vérifiant result.volume pour savoir ce qui a réellement été exécuté).
  • Erreur de construction de la requête : 10013, 10014, 10015, 10016, 10022, 10030, 10035. Réessayer à l’identique produira le même refus ; c’est le code de l’EA qu’il faut corriger.
  • Interdiction ou limite : 10017, 10026, 10027, 10032, 10033, 10034, 10040, 10042 à 10046. Il faut suspendre les envois et prévenir l’utilisateur.
  • Condition passagère : 10004, 10020, 10021, 10024, 10031, 10012. Un nouvel essai, après rafraîchissement des prix et une courte pause, peut être justifié.

Une fonction d’envoi qui lit tout

L’exemple suivant envoie un achat au marché et interprète la réponse. Il utilise la structure brute pour montrer chaque champ ; le principe est identique avec la classe CTrade, via ResultRetcode() et ResultRetcodeDescription().

//+------------------------------------------------------------------+
//| Vrai si le retcode correspond à un succès                        |
//+------------------------------------------------------------------+
bool IsSuccess(const uint rc)
  {
   return(rc == TRADE_RETCODE_DONE ||
          rc == TRADE_RETCODE_PLACED ||
          rc == TRADE_RETCODE_DONE_PARTIAL);
  }

//+------------------------------------------------------------------+
//| Achat au marché avec lecture complète de la réponse              |
//+------------------------------------------------------------------+
bool BuyMarket(const double lots)
  {
   MqlTradeRequest req = {};
   MqlTradeResult  res = {};
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol, tick))
      return false;

   req.action    = TRADE_ACTION_DEAL;
   req.symbol    = _Symbol;
   req.volume    = lots;
   req.type      = ORDER_TYPE_BUY;
   req.price     = tick.ask;
   req.deviation = 10;                 // écart toléré en points
   req.magic     = 123456;

   ResetLastError();
   bool sent = OrderSend(req, res);
   int  err  = GetLastError();

   // On journalise toujours les deux familles de codes
   PrintFormat("OrderSend=%s err=%d retcode=%u (%s) ext=%d deal=%I64u vol=%.2f",
               sent ? "true" : "false", err, res.retcode, res.comment,
               res.retcode_external, res.deal, res.volume);

   if(!IsSuccess(res.retcode))
      return false;
   if(res.retcode == TRADE_RETCODE_DONE_PARTIAL)
      PrintFormat("Exécution partielle : %.2f lot(s) sur %.2f", res.volume, lots);
   return true;
  }

Remarquez que le test de succès porte sur res.retcode, pas sur la valeur booléenne renvoyée. Dans un journal, une ligne comme OrderSend=false err=4756 retcode=10016 se lit immédiatement : l’envoi a échoué parce que les stops étaient invalides.

Où voir le retcode sans écrire de code

Même sans journalisation personnalisée, le terminal trace chaque opération dans l’onglet Journal de la boîte à outils, avec le résultat de la requête. Comparez cette ligne avec celle de l’onglet Experts, où apparaissent vos propres Print() : la première dit ce que le serveur a répondu, la seconde ce que votre EA a compris. Un écart entre les deux révèle presque toujours un test de succès mal écrit. Dans le testeur de stratégie, ces mêmes informations figurent dans l’onglet Journal du testeur.

Retcodes et OrderCheck

OrderCheck() remplit une structure MqlTradeCheckResult qui possède elle aussi un champ retcode, alimenté par les mêmes constantes. C’est une façon d’obtenir un 10014 ou un 10019 avant d’envoyer quoi que ce soit au serveur, avec en prime la marge requise (margin) et la marge libre restante (margin_free). La page OrderCheck : vérifier un ordre avant envoi détaille cette approche. Gardez à l’esprit qu’un contrôle réussi ne garantit pas l’exécution : le marché peut bouger entre le contrôle et l’envoi.

Traduire les codes en texte

Pour un journal lisible, associez chaque code à un libellé. Avec CTrade, ResultRetcodeDescription() le fait pour vous. Avec la structure brute, une fonction switch qui couvre les codes réellement rencontrés par votre stratégie suffit ; inutile de reproduire les quarante entrées si votre EA n’envoie jamais d’ordres en attente. Prévoyez simplement une branche default qui imprime le numéro brut, afin qu’aucun code inattendu ne passe inaperçu.

Gardez aussi en tête que le champ comment de la réponse est rédigé par le serveur : son contenu peut varier selon le courtier et la langue. Ne construisez jamais une logique de décision sur ce texte ; testez toujours la valeur numérique de retcode et réservez le commentaire au journal.

Pièges courants

  • Tester true et s’arrêter là. C’est la cause n° 1 des EA qui « croient » avoir ouvert une position.
  • Oublier 10008. Un ordre en attente placé avec succès renvoie 10008, pas 10009. Un test limité à TRADE_RETCODE_DONE considérerait à tort tous vos ordres limites comme échoués.
  • Ignorer l’exécution partielle. Avec 10010, le volume exécuté peut être inférieur au volume demandé : votre gestion du risque doit partir de result.volume.
  • En mode asynchrone, OrderSendAsync() ne renvoie pas le résultat final : la réponse définitive arrive par l’événement OnTradeTransaction.
Les codes de retour décrivent l’acceptation technique d’un ordre, pas sa pertinence. Le trading sur marge peut entraîner des pertes supérieures à vos prévisions : validez votre gestion des retcodes sur compte démo avant toute utilisation en réel.

Exécution partielle : un succès à vérifier

Le code 10010 mérite une attention particulière. Il signifie que seule une partie du volume a été exécutée, selon la politique de remplissage choisie. Votre EA doit alors décider : conserver la position réduite, compléter le volume par un nouvel ordre ou tout annuler. Aucune réponse n’est universelle, mais l’absence de décision est la pire option, car les calculs de risque ultérieurs partiraient d’un volume erroné.

Questions fréquentes

Quels retcodes signifient que l’ordre est passé ?

10009 (TRADE_RETCODE_DONE) pour une exécution, 10008 (TRADE_RETCODE_PLACED) pour un ordre placé, et 10010 (TRADE_RETCODE_DONE_PARTIAL) pour une exécution partielle. Tous les autres indiquent un refus ou une situation à traiter.

OrderSend a renvoyé true mais aucune position n’est ouverte, pourquoi ?

Parce que true signifie uniquement que la requête a été acceptée pour traitement. Lisez result.retcode : il peut indiquer 10008 (ordre placé, pas encore exécuté) ou une situation particulière. En mode asynchrone, attendez l’événement de transaction.

Que contient retcode_external ?

Le code d’erreur renvoyé par un système de trading externe au serveur MetaTrader. Sa signification dépend du courtier ; il n’est pas couvert par la table standard.

CTrade simplifie-t-elle la lecture des retcodes ?

Oui : après un Buy() ou un PositionModify(), ResultRetcode() renvoie le code et ResultRetcodeDescription() son libellé. Le principe reste le même : tester le code, pas seulement la valeur booléenne renvoyée par la méthode.

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.