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

MQL5 · Codes d’erreur

Erreur 10006 Request rejected en MQL5 : enquêter sur un rejet

Le retcode 10006 signale un refus global du serveur. Méthode d’enquête, lecture de retcode_external et coupe-circuit MQL5 contre les rejets répétés.

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

Le code 10006 (TRADE_RETCODE_REJECT, libellé officiel « Request rejected ») indique que le serveur de trading a refusé votre requête sans la classer dans une catégorie plus précise. Contrairement à 10014 (volume) ou 10016 (stops), il ne désigne pas un champ fautif : c’est un refus global, souvent décidé par la configuration du courtier ou par un système situé en amont. La démarche consiste donc à collecter toutes les informations disponibles (commentaire, code externe, contexte) avant de décider s’il faut corriger l’EA, réessayer plus tard ou interroger le courtier.

Cette page propose une méthode d’enquête et un mécanisme de protection contre les rejets répétés. Elle fait partie de la rubrique Codes d’erreur et de retour MQL5.

Ce que dit (et ne dit pas) la documentation

La documentation officielle se limite au libellé « Request rejected ». Elle ne liste aucune cause précise, et c’est logique : le rejet est une décision du serveur, dont les règles varient d’un courtier à l’autre. Méfiez-vous donc des explications toutes faites trouvées sur les forums ; elles décrivent la configuration d’un courtier particulier, pas un comportement universel de MetaTrader 5.

En revanche, deux champs de MqlTradeResult peuvent apporter un complément :

  • comment : texte libre renvoyé par le serveur, qui précise parfois la raison du refus.
  • retcode_external : code d’erreur d’un système de trading externe. La documentation précise que sa signification dépend du courtier et du système concerné.

Les situations où l’on rencontre 10006

Sans prétendre à l’exhaustivité, voici les contextes dans lesquels ce code est typiquement observé, et la piste à vérifier pour chacun :

Contexte observéPiste de vérification
Rejet uniquement à certaines heures (rollover, faible liquidité)Comparer l’heure serveur des rejets avec les sessions du symbole
Rejet sur un symbole précis, pas sur les autresRelire les propriétés du symbole : mode de trading, types d’ordres autorisés
Rejet après une série d’ordres rapprochésRéduire la fréquence des envois
Rejet avec un retcode_external non nulTransmettre le code au courtier, il vient d’un système en amont
Rejet systématique dès le premier ordreVérifier les droits du compte et les paramètres de la requête avec OrderCheck()

Le dernier cas est le plus instructif : si OrderCheck() signale déjà un problème, le rejet n’a rien de mystérieux. Si OrderCheck() renvoie un contrôle correct et que l’envoi est tout de même rejeté, la cause se situe bien du côté du serveur.

Diagnostiquer dans le journal

La première étape est de produire une trace exploitable. Une ligne de journal utile pour un 10006 contient l’heure serveur, le symbole, le type d’ordre, le volume, le prix demandé, le Bid et l’Ask au moment de la réponse, le commentaire et le code externe. Avec cette ligne, vous pouvez repérer une régularité (toujours le vendredi soir, toujours sur l’or, toujours au-delà d’un certain volume) et, si besoin, fournir au support du courtier un élément précis plutôt qu’un « mon robot ne marche pas ».

Consultez aussi l’onglet Journal du terminal : le serveur y consigne l’opération telle qu’il l’a reçue, ce qui permet de vérifier que la requête envoyée correspond bien à celle que vous pensiez construire.

Un coupe-circuit contre les rejets répétés

Réessayer en boucle un ordre rejeté n’apporte rien et peut aggraver la situation. Une approche plus saine consiste à compter les rejets consécutifs et à suspendre les entrées au-delà d’un seuil, pendant une durée donnée.

#include <Trade\Trade.mqh>
CTrade trade;

input int InpMaxRejects   = 3;     // rejets consécutifs tolérés
input int InpPauseMinutes = 30;    // durée de suspension

int      g_rejects    = 0;         // compteur de rejets consécutifs
datetime g_pauseUntil = 0;         // fin de la suspension

//+------------------------------------------------------------------+
//| Journalise un rejet de façon détaillée                           |
//+------------------------------------------------------------------+
void LogReject(const string what)
  {
   MqlTradeResult r;
   trade.Result(r);                                  // copie complète du résultat
   PrintFormat("%s REJET %s | retcode=%u ext=%d comment='%s' bid=%.5f ask=%.5f",
               TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS), what,
               r.retcode, r.retcode_external, r.comment, r.bid, r.ask);
  }

//+------------------------------------------------------------------+
//| Tente une entrée en respectant le coupe-circuit                  |
//+------------------------------------------------------------------+
bool TryEntry(const ENUM_ORDER_TYPE type, const double lots)
  {
   if(TimeCurrent() < g_pauseUntil)
      return false;                                  // suspension en cours

   bool ok = (type == ORDER_TYPE_BUY) ? trade.Buy(lots) : trade.Sell(lots);
   uint rc = trade.ResultRetcode();

   if(ok && (rc == TRADE_RETCODE_DONE || rc == TRADE_RETCODE_PLACED))
     {
      g_rejects = 0;                                 // succès : on remet à zéro
      return true;
     }

   if(rc == TRADE_RETCODE_REJECT)
     {
      LogReject(EnumToString(type));
      if(++g_rejects >= InpMaxRejects)
        {
         g_pauseUntil = TimeCurrent() + InpPauseMinutes * 60;
         PrintFormat("%d rejets consécutifs : entrées suspendues jusqu'à %s",
                     g_rejects, TimeToString(g_pauseUntil));
         g_rejects = 0;
        }
     }
   return false;
  }

La méthode Result() de CTrade copie la structure MqlTradeResult complète, ce qui donne accès à retcode_external. Avec Buy(lots) et Sell(lots), la classe utilise le symbole courant et le prix du marché. Le coupe-circuit n’empêche pas la gestion des positions déjà ouvertes : seule l’ouverture de nouvelles positions est suspendue.

Prévenir ce qui peut l’être

Une partie des rejets disparaît lorsque l’EA respecte scrupuleusement les propriétés du symbole et contrôle la requête avant envoi. Deux habitudes sont particulièrement efficaces :

  1. Contrôler avec OrderCheck() avant chaque envoi en réel. Un contrôle négatif évite d’exposer au serveur une requête défectueuse. Voyez OrderCheck : vérifier un ordre avant envoi.
  2. Éviter les périodes à risque, notamment le passage de journée (rollover) où la liquidité se raréfie et les spreads s’élargissent. Un filtre horaire, décrit dans Filtres horaires, de spread et de volatilité, réduit souvent les refus.

Si, malgré cela, le code persiste sur un symbole où les ordres manuels passent normalement, comparez les paramètres : un ordre manuel et un ordre envoyé par l’EA n’utilisent pas forcément le même mode de remplissage ni la même tolérance de prix. Un écart sur le remplissage produira d’ailleurs plutôt un 10030 Mode de remplissage non supporté.

Ne pas confondre avec les codes voisins

Plusieurs retcodes ressemblent à un rejet mais portent une information plus précise, qu’il serait dommage de traiter comme un 10006 générique :

  • 10041 (TRADE_RETCODE_REJECT_CANCEL) : l’activation d’un ordre en attente a été rejetée et l’ordre annulé. Le refus intervient au déclenchement, pas à l’envoi ; il ne s’observe donc pas dans la réponse immédiate à OrderSend() mais dans l’historique et les événements de transaction.
  • 10007 (TRADE_RETCODE_CANCEL) : la requête a été annulée par le trader, pas par le serveur.
  • 10012 (TRADE_RETCODE_TIMEOUT) : la requête a expiré faute de traitement dans le délai.

Traitez chacun dans une branche distincte de votre code : leurs réactions appropriées diffèrent, et les regrouper sous un seul message rend le journal ambigu.

Pièges à éviter

  • Interpréter 10006 comme une interdiction définitive. Un rejet ponctuel est souvent conjoncturel ; une interdiction se traduit plutôt par 10017, 10026 ou 10027.
  • Supprimer le message pour « nettoyer » le journal. Les rejets sont rares et précieux pour le diagnostic : gardez-les visibles.
  • Recopier la solution d’un autre trader. Le même code peut avoir des causes opposées chez deux courtiers différents.
Un ordre rejeté au mauvais moment peut laisser une stratégie partiellement exposée, par exemple une couverture qui ne s’ouvre pas. Le trading sur marge comporte un risque de perte élevé : prévoyez dans votre EA le comportement à adopter quand une jambe d’une opération échoue.

Que tester sur compte démo

Avant de passer en réel, provoquez volontairement quelques situations limites sur un compte démo du même courtier : ordre juste avant la clôture du vendredi, ordre pendant le rollover, série d’envois rapprochés. Notez les codes obtenus. Vous saurez alors si votre courtier répond par un 10006 générique ou par un code plus précis, et votre gestion d’erreur reposera sur des observations plutôt que sur des suppositions.

Questions fréquentes

Le code 10006 vient-il de mon EA ou du courtier ?

Il est émis par le serveur de trading, donc côté courtier. Mais la cause peut se trouver dans la requête envoyée par l’EA : vérifiez-la avec OrderCheck() avant de conclure à un problème du serveur.

Que faire si retcode_external est rempli ?

Notez-le avec l’heure et le symbole, puis transmettez-le au support du courtier. La documentation précise que sa signification dépend du système externe concerné ; aucune table publique MQL5 ne permet de l’interpréter.

Faut-il réessayer immédiatement après un 10006 ?

Un essai supplémentaire après une courte pause peut se justifier, mais pas une boucle. Au-delà de quelques rejets consécutifs, suspendez les entrées et analysez le journal.

Pourquoi mes ordres manuels passent alors que l’EA est rejeté ?

Comparez les paramètres réellement envoyés : volume, type de remplissage, tolérance de prix, stops. Les ordres manuels utilisent les réglages du terminal, l’EA ceux que vous avez codés.

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.