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.
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
| Code | Constante | Signification |
|---|---|---|
| 10004 | TRADE_RETCODE_REQUOTE | Requote : nouveau prix proposé |
| 10006 | TRADE_RETCODE_REJECT | Requête rejetée |
| 10007 | TRADE_RETCODE_CANCEL | Requête annulée par le trader |
| 10008 | TRADE_RETCODE_PLACED | Ordre placé (succès) |
| 10009 | TRADE_RETCODE_DONE | Requête exécutée (succès) |
| 10010 | TRADE_RETCODE_DONE_PARTIAL | Exécution partielle (succès partiel) |
| 10011 | TRADE_RETCODE_ERROR | Erreur de traitement de la requête |
| 10012 | TRADE_RETCODE_TIMEOUT | Requête annulée par dépassement de délai |
| 10013 | TRADE_RETCODE_INVALID | Requête invalide |
| 10014 | TRADE_RETCODE_INVALID_VOLUME | Volume invalide |
| 10015 | TRADE_RETCODE_INVALID_PRICE | Prix invalide |
| 10016 | TRADE_RETCODE_INVALID_STOPS | Stops invalides |
| 10017 | TRADE_RETCODE_TRADE_DISABLED | Trading désactivé |
| 10018 | TRADE_RETCODE_MARKET_CLOSED | Marché fermé |
| 10019 | TRADE_RETCODE_NO_MONEY | Fonds insuffisants |
| 10020 | TRADE_RETCODE_PRICE_CHANGED | Les prix ont changé |
| 10021 | TRADE_RETCODE_PRICE_OFF | Pas de cotations pour traiter la requête |
| 10022 | TRADE_RETCODE_INVALID_EXPIRATION | Date d’expiration invalide |
| 10023 | TRADE_RETCODE_ORDER_CHANGED | L’état de l’ordre a changé |
| 10024 | TRADE_RETCODE_TOO_MANY_REQUESTS | Requêtes trop fréquentes |
| 10025 | TRADE_RETCODE_NO_CHANGES | Aucun changement dans la requête |
| 10026 | TRADE_RETCODE_SERVER_DISABLES_AT | Trading automatique désactivé par le serveur |
| 10027 | TRADE_RETCODE_CLIENT_DISABLES_AT | Trading automatique désactivé par le terminal |
| 10028 | TRADE_RETCODE_LOCKED | Requête verrouillée pour traitement |
| 10029 | TRADE_RETCODE_FROZEN | Ordre ou position gelé |
| 10030 | TRADE_RETCODE_INVALID_FILL | Type de remplissage invalide |
| 10031 | TRADE_RETCODE_CONNECTION | Pas de connexion au serveur de trading |
| 10032 | TRADE_RETCODE_ONLY_REAL | Opération autorisée uniquement sur compte réel |
| 10033 | TRADE_RETCODE_LIMIT_ORDERS | Limite du nombre d’ordres en attente atteinte |
| 10034 | TRADE_RETCODE_LIMIT_VOLUME | Limite de volume du symbole atteinte |
| 10035 | TRADE_RETCODE_INVALID_ORDER | Type d’ordre invalide ou interdit |
| 10036 | TRADE_RETCODE_POSITION_CLOSED | Position déjà clôturée |
| 10038 | TRADE_RETCODE_INVALID_CLOSE_VOLUME | Volume de clôture supérieur au volume de la position |
| 10039 | TRADE_RETCODE_CLOSE_ORDER_EXIST | Un ordre de clôture existe déjà pour cette position |
| 10040 | TRADE_RETCODE_LIMIT_POSITIONS | Limite du nombre de positions ouvertes atteinte |
| 10041 | TRADE_RETCODE_REJECT_CANCEL | Activation de l’ordre en attente rejetée, ordre annulé |
| 10042 | TRADE_RETCODE_LONG_ONLY | Seules les positions acheteuses sont autorisées |
| 10043 | TRADE_RETCODE_SHORT_ONLY | Seules les positions vendeuses sont autorisées |
| 10044 | TRADE_RETCODE_CLOSE_ONLY | Seule la clôture de positions est autorisée |
| 10045 | TRADE_RETCODE_FIFO_CLOSE | Clôture selon la règle FIFO obligatoire |
| 10046 | TRADE_RETCODE_HEDGE_PROHIBITED | Positions 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.volumepour 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
trueet 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_DONEconsidé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.
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.
- Erreurs de compilation MQL5
- Invalid pointer access
- GetLastError et gestion des erreurs
- 10004 Requote
- 10006 Requête rejetée
- 10013 Requête invalide
- 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
