MQL5 · Codes d’erreur
Erreur 4756 Trade request sending failed en MQL5 : trouver la vraie cause
L’erreur 4756 signale qu’OrderSend a échoué sans dire pourquoi. Lire le retcode associé, journaliser les deux codes et distinguer les erreurs voisines 4751 à 4758.
L’erreur 4756 (ERR_TRADE_SEND_FAILED, libellé officiel « Trade request sending failed ») est une erreur d’exécution du terminal, lue avec GetLastError(). Elle indique qu’une requête de trading n’a pas abouti, sans dire pourquoi. C’est le code que l’on observe en pratique lorsque OrderSend() renvoie false. Le message important est ailleurs : la cause réelle se trouve dans le champ retcode de la structure MqlTradeResult, sous la forme d’un code de retour 100xx (volume invalide, stops invalides, marché fermé…). Traiter un 4756, c’est donc toujours lire le retcode qui l’accompagne.
Cette page explique la relation entre ces deux familles de codes, montre comment écrire une journalisation qui ne laisse aucun 4756 inexpliqué et passe en revue les erreurs voisines de la série 475x. Elle fait partie de la rubrique Codes d’erreur et de retour MQL5.
Un symptôme, pas une cause
MQL5 sépare deux niveaux de diagnostic :
- le terminal constate que l’envoi a échoué et positionne
_LastErrorà 4756 ; - le serveur, ou le terminal agissant pour lui lors des contrôles préalables, indique la raison du refus dans
result.retcode, avec éventuellement un texte dansresult.comment.
Un journal qui affiche seulement « OrderSend error 4756 » est donc à peu près inutile : il vous dit que l’ordre n’est pas passé, ce que vous saviez déjà. Le même 4756 peut recouvrir un 10014 (volume invalide), un 10016 (stops invalides), un 10019 (fonds insuffisants) ou un 10027 (trading automatique désactivé), dont les corrections n’ont rien en commun.
La règle de lecture
La documentation d’OrderSend() précise que 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 d’une exécution. Elle recommande de vérifier en premier lieu retcode et retcode_external. On en déduit une règle simple, valable que la fonction renvoie true ou false :
- appeler
ResetLastError()juste avant l’envoi ; - stocker la valeur renvoyée par
OrderSend()etGetLastError()immédiatement après ; - décider du succès d’après
result.retcode(10008, 10009 ou 10010) ; - en cas d’échec, journaliser les deux codes, le commentaire et le code externe.
Une fonction d’envoi qui explique ses échecs
//+------------------------------------------------------------------+
//| Libellé court en français des retcodes les plus fréquents |
//+------------------------------------------------------------------+
string RetcodeText(const uint rc)
{
switch(rc)
{
case TRADE_RETCODE_REQUOTE: return "requote";
case TRADE_RETCODE_REJECT: return "requête rejetée";
case TRADE_RETCODE_INVALID: return "requête invalide";
case TRADE_RETCODE_INVALID_VOLUME: return "volume invalide";
case TRADE_RETCODE_INVALID_PRICE: return "prix invalide";
case TRADE_RETCODE_INVALID_STOPS: return "stops invalides";
case TRADE_RETCODE_TRADE_DISABLED: return "trading désactivé";
case TRADE_RETCODE_MARKET_CLOSED: return "marché fermé";
case TRADE_RETCODE_NO_MONEY: return "fonds insuffisants";
case TRADE_RETCODE_PRICE_OFF: return "pas de cotations";
case TRADE_RETCODE_TOO_MANY_REQUESTS: return "requêtes trop fréquentes";
case TRADE_RETCODE_CLIENT_DISABLES_AT: return "Algo Trading désactivé dans le terminal";
case TRADE_RETCODE_INVALID_FILL: return "mode de remplissage non supporté";
default: return "voir la table des retcodes";
}
}
//+------------------------------------------------------------------+
//| Envoi avec diagnostic complet |
//+------------------------------------------------------------------+
bool SendWithDiagnosis(MqlTradeRequest &req, MqlTradeResult &res)
{
ResetLastError();
bool sent = OrderSend(req, res);
int err = GetLastError();
bool success = (res.retcode == TRADE_RETCODE_DONE ||
res.retcode == TRADE_RETCODE_PLACED ||
res.retcode == TRADE_RETCODE_DONE_PARTIAL);
if(success)
return true;
PrintFormat("ÉCHEC %s %s %.2f lot(s) @ %.5f | OrderSend=%s err=%d | retcode=%u (%s) | comment='%s' ext=%d",
req.symbol, EnumToString(req.type), req.volume, req.price,
sent ? "true" : "false", err,
res.retcode, RetcodeText(res.retcode), res.comment, res.retcode_external);
return false;
}
Avec cette fonction, une ligne de journal ressemble à : ÉCHEC EURUSD ORDER_TYPE_BUY 0.15 lot(s) @ 1.08412 | OrderSend=false err=4756 | retcode=10016 (stops invalides). Le 4756 garde son rôle de signal, le retcode donne la piste à suivre, et la page correspondante de cette rubrique, par exemple 10016 Stops invalides, donne la correction.
Et avec la classe CTrade ?
Les méthodes de CTrade (Buy(), Sell(), PositionModify(), PositionClose()…) renvoient elles aussi un booléen, avec la même ambiguïté. Après un échec, lisez ResultRetcode() et ResultRetcodeDescription(), ou récupérez la structure complète avec Result(). La classe est détaillée dans La classe CTrade.
Un point de vigilance : un booléen true renvoyé par une méthode de CTrade ne garantit pas davantage l’exécution qu’un true d’OrderSend(). Testez le retcode dans les deux cas.
Les erreurs voisines de la série 475x
La documentation regroupe les erreurs d’exécution liées au trading dans une même série. Les connaître évite de les confondre avec un 4756 :
| Code | Constante | Signification officielle | Contexte typique |
|---|---|---|---|
| 4751 | ERR_TRADE_WRONG_PROPERTY | Wrong trade property ID | Identifiant de propriété erroné dans une fonction de lecture d’ordre ou de position |
| 4752 | ERR_TRADE_DISABLED | Trading by Expert Advisors prohibited | Trading algorithmique interdit |
| 4753 | ERR_TRADE_POSITION_NOT_FOUND | Position not found | Sélection d’une position déjà clôturée |
| 4754 | ERR_TRADE_ORDER_NOT_FOUND | Order not found | Ordre en attente déjà exécuté ou supprimé |
| 4755 | ERR_TRADE_DEAL_NOT_FOUND | Deal not found | Transaction absente de l’historique chargé |
| 4756 | ERR_TRADE_SEND_FAILED | Trade request sending failed | Échec d’envoi, cause dans le retcode |
| 4758 | ERR_TRADE_CALC_FAILED | Failed to calculate profit or margin | Échec d’OrderCalcMargin() ou d’OrderCalcProfit() |
Le numéro 4757 n’apparaît pas dans la table officielle. Les erreurs 4753 et 4754 sont fréquentes dans les boucles qui parcourent positions et ordres : la position a pu être clôturée par un stop entre le moment où vous avez compté les positions et celui où vous la sélectionnez. La méthode sûre consiste à parcourir les positions de la dernière vers la première et à vérifier le résultat de chaque sélection.
Reproduire un 4756 pour tester sa journalisation
Avant de faire confiance à votre gestion d’erreur, provoquez volontairement quelques échecs sur un compte démo, depuis un petit script de test :
- envoyez un volume de 0,001 lot sur un symbole dont le minimum est 0,01 : vous devez lire 4756 et 10014 ;
- placez un stop loss au-dessus du Bid pour un achat : 4756 et 10016 ;
- coupez le bouton Algo Trading puis envoyez un ordre : le refus doit être attribué au terminal, avec le retcode 10027 ;
- envoyez un ordre le samedi : 10018.
Pour chaque cas, vérifiez que la ligne de journal permet de comprendre l’incident sans ouvrir le code source. Si ce n’est pas le cas, complétez la fonction de diagnostic. Ce test prend quelques minutes et vous épargnera des heures de recherche le jour où l’EA échouera en réel.
Le cas du mode asynchrone
Avec OrderSendAsync(), ou CTrade configurée par SetAsyncMode(true), la fonction rend la main sans attendre la réponse du serveur. Le résultat immédiat indique seulement si la requête a pu être envoyée ; la réponse définitive arrive ensuite par l’événement OnTradeTransaction(), dans une structure de résultat qui porte elle aussi un retcode. La logique de diagnostic est donc la même, mais répartie à deux endroits. Ce mode est décrit dans OnTradeTransaction : réagir aux événements de trading.
Que faire après un 4756
La décision dépend entièrement du retcode associé :
- Erreur de construction (10013, 10014, 10015, 10016, 10030) : ne pas réessayer, corriger le code.
- Interdiction (10017, 10026, 10027) : suspendre les envois, alerter l’utilisateur.
- Condition passagère (10004, 10020, 10021) : relire le prix, un ou deux essais espacés.
- Fonds (10019) : réduire le volume ou renoncer.
- Surcharge (10024) : ralentir.
Un 4756 sans retcode exploitable (champ à zéro) est rare ; il mérite alors une journalisation détaillée de la requête complète, et une vérification de l’état de la connexion avec TerminalInfoInteger(TERMINAL_CONNECTED).
Prévenir plutôt que constater
Le meilleur 4756 est celui qui ne se produit pas. OrderCheck() soumet la requête aux contrôles sans l’envoyer et renvoie dans MqlTradeCheckResult le retcode qu’aurait probablement reçu l’ordre, avec la marge requise et la marge libre restante. Appelé avant chaque envoi en réel, il transforme un échec d’exécution en simple décision de ne pas envoyer. La méthode est présentée dans OrderCheck : vérifier un ordre avant envoi. Gardez en tête qu’un contrôle positif n’est pas une garantie : le marché peut évoluer entre le contrôle et l’envoi.
Questions fréquentes
Que signifie l’erreur 4756 en MQL5 ?
ERR_TRADE_SEND_FAILED : l’envoi de la requête de trading a échoué. Elle ne donne pas la cause ; celle-ci se lit dans MqlTradeResult.retcode (code 100xx) et parfois dans result.comment.
Pourquoi GetLastError renvoie 4756 alors que le retcode est 10016 ?
Les deux codes décrivent le même incident à deux niveaux : le terminal constate l’échec de l’envoi (4756), le serveur en donne la raison (10016, stops invalides). C’est le retcode qu’il faut corriger.
OrderSend renvoie true : puis-je ignorer GetLastError ?
Vous pouvez ignorer GetLastError(), mais pas le retcode : true signifie seulement que la requête a été acceptée pour traitement. Vérifiez que retcode vaut 10009, 10008 ou 10010.
L’erreur 4757 existe-t-elle ?
Elle ne figure pas dans la table officielle des erreurs d’exécution : la série passe de 4756 à 4758 (ERR_TRADE_CALC_FAILED).
- 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
- 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é
- Array out of range
- Division par zéro
