MQL5 · Ordres et positions
OrderSend et MqlTradeRequest : envoyer une requête de trading en MQL5
OrderSend envoie au serveur une structure MqlTradeRequest et renvoie un MqlTradeResult. Champs obligatoires par action, lecture du retcode et exemple complet commenté.
OrderSend est la fonction native de MQL5 qui envoie une requête de trading au serveur. Sa signature est bool OrderSend(MqlTradeRequest& request, MqlTradeResult& result) : vous remplissez une structure MqlTradeRequest avec l’action, le symbole, le volume, le type d’ordre et les prix, vous appelez la fonction, puis vous lisez la structure MqlTradeResult, en commençant par son champ retcode. Le retour true signifie seulement que la vérification de base des structures a réussi.
La classe CTrade appelle cette fonction pour vous. Connaître OrderSend reste indispensable pour comprendre ce que fait la classe, diagnostiquer un refus et écrire des requêtes que la classe ne propose pas directement. Cette page fait partie de la rubrique Ordres et positions en MQL5.
Ce que dit la documentation sur le retour
La documentation officielle insiste sur trois points :
- en cas de vérification de base réussie des structures, la fonction renvoie
true, ce qui n’est pas un signe d’exécution réussie de l’opération ; - pour toute requête, il faut d’abord vérifier le code de retour du serveur
retcodeet le code du système externeretcode_external; - pour un ordre au marché, un résultat positif signifie seulement que l’ordre a été placé dans le système de trading pour exécution ; les événements d’exécution peuvent arriver après la réponse.
La documentation recommande aussi de vérifier la requête avant de l’envoyer avec OrderCheck.
La structure MqlTradeRequest
| Champ | Type | Rôle |
|---|---|---|
action | ENUM_TRADE_REQUEST_ACTIONS | type d’opération |
magic | ulong | identifiant de l’EA |
order | ulong | ticket d’ordre (modification, suppression) |
symbol | string | symbole |
volume | double | volume en lots |
price | double | prix d’exécution ou d’activation |
stoplimit | double | prix de l’ordre limite d’un stop-limit |
sl | double | stop loss |
tp | double | take profit |
deviation | ulong | déviation maximale en points |
type | ENUM_ORDER_TYPE | type d’ordre |
type_filling | ENUM_ORDER_TYPE_FILLING | mode de remplissage |
type_time | ENUM_ORDER_TYPE_TIME | type d’expiration |
expiration | datetime | date d’expiration |
comment | string | commentaire |
position | ulong | ticket de position (modification, fermeture) |
position_by | ulong | ticket de la position opposée |
Les six actions et leurs champs obligatoires
L’énumération ENUM_TRADE_REQUEST_ACTIONS contient six valeurs. La documentation de MqlTradeRequest indique les champs nécessaires pour chacune :
| Action | Usage | Champs requis |
|---|---|---|
TRADE_ACTION_DEAL (exécution Market ou Exchange) | ordre au marché | action, symbol, volume, type, type_filling |
TRADE_ACTION_DEAL (exécution Request ou Instant) | ordre au marché | action, symbol, volume, price, sl, tp, deviation, type, type_filling |
TRADE_ACTION_PENDING | ordre en attente | action, symbol, volume, price, stoplimit, sl, tp, type, type_filling, type_time, expiration |
TRADE_ACTION_SLTP | stops d’une position | action, symbol, sl, tp, position |
TRADE_ACTION_MODIFY | modifier un ordre en attente | action, order, price, sl, tp, type_time, expiration |
TRADE_ACTION_REMOVE | supprimer un ordre en attente | action, order |
TRADE_ACTION_CLOSE_BY | fermer par position opposée | non listés dans ce tableau ; l’exemple officiel renseigne position et position_by |
Le champ magic et le champ comment sont facultatifs mais vivement conseillés. Le mode d’exécution du symbole se lit avec SymbolInfoInteger(symbol, SYMBOL_TRADE_EXEMODE) ; il vaut SYMBOL_TRADE_EXECUTION_REQUEST, SYMBOL_TRADE_EXECUTION_INSTANT, SYMBOL_TRADE_EXECUTION_MARKET ou SYMBOL_TRADE_EXECUTION_EXCHANGE. Pour écrire un code qui fonctionne partout, renseignez le prix et la déviation même en exécution Market : ils sont simplement non requis dans ce mode.
Pour fermer ou modifier une position sur un compte hedging, le champ position doit contenir son ticket, comme le rappelle la documentation. Il peut aussi être indiqué en netting.
La structure MqlTradeResult
| Champ | Type | Contenu |
|---|---|---|
retcode | uint | code de retour du serveur |
deal | ulong | ticket du deal, si un deal a été effectué (action DEAL) |
order | ulong | ticket de l’ordre, s’il a été placé |
volume | double | volume confirmé par le broker |
price | double | prix confirmé par le broker |
bid, ask | double | prix courants (cotation de requote) |
comment | string | commentaire du broker, par défaut la description du code |
request_id | uint | identifiant de requête attribué par le terminal |
retcode_external | int | code d’erreur du système de trading externe |
Exemple complet : un achat au marché avec OrderSend
Le script ci-dessous envoie un achat au volume minimal avec stop loss et take profit, en vérifiant le mode de remplissage autorisé par le symbole. À exécuter sur un compte de démonstration.
//+------------------------------------------------------------------+
//| Script : achat au marché avec OrderSend (compte de démo) |
//+------------------------------------------------------------------+
input int InpSLPoints = 300; // stop loss en points
input int InpTPPoints = 600; // take profit en points
//--- choisit un mode de remplissage autorisé pour un ordre au marché
ENUM_ORDER_TYPE_FILLING MarketFilling(const string symbol)
{
long flags = SymbolInfoInteger(symbol, SYMBOL_FILLING_MODE);
if((flags & SYMBOL_FILLING_FOK) == SYMBOL_FILLING_FOK) return(ORDER_FILLING_FOK);
if((flags & SYMBOL_FILLING_IOC) == SYMBOL_FILLING_IOC) return(ORDER_FILLING_IOC);
return(ORDER_FILLING_RETURN); // interdit en exécution Market
}
void OnStart()
{
MqlTradeRequest request;
MqlTradeResult result;
ZeroMemory(request); // tous les champs à zéro
ZeroMemory(result);
MqlTick tick;
if(!SymbolInfoTick(_Symbol, tick)) { Print("Pas de cotation"); return; }
request.action = TRADE_ACTION_DEAL;
request.symbol = _Symbol;
request.volume = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
request.type = ORDER_TYPE_BUY;
request.price = tick.ask; // achat au Ask
request.sl = NormalizeDouble(tick.bid - InpSLPoints * _Point, _Digits);
request.tp = NormalizeDouble(tick.bid + InpTPPoints * _Point, _Digits);
request.deviation = 10; // en points
request.type_filling = MarketFilling(_Symbol);
request.magic = 240504;
request.comment = "OrderSend demo";
ResetLastError();
if(!OrderSend(request, result))
{
//--- échec de la vérification de base : erreur côté terminal
PrintFormat("OrderSend a échoué, erreur %d, retcode %u", GetLastError(), result.retcode);
return;
}
//--- la requête est partie : analyser la réponse du serveur
switch(result.retcode)
{
case TRADE_RETCODE_DONE:
case TRADE_RETCODE_DONE_PARTIAL:
PrintFormat("Exécuté : deal %I64u, ordre %I64u, %.2f lot à %.5f",
result.deal, result.order, result.volume, result.price);
break;
case TRADE_RETCODE_PLACED:
Print("Ordre placé, exécution à confirmer par OnTradeTransaction");
break;
default:
PrintFormat("Refus : %u %s (externe %d)",
result.retcode, result.comment, result.retcode_external);
}
}
ZeroMemory est important : une structure locale non initialisée peut contenir des valeurs résiduelles, par exemple un ticket de position ou une expiration, qui rendraient la requête invalide (code 10013).
Les autres actions en pratique
Le même schéma (remplir, envoyer, lire retcode) vaut pour toutes les actions. Quelques repères pour les plus courantes :
- Modifier les stops d’une position :
TRADE_ACTION_SLTPavecsymbol,sl,tpet le ticket dansposition. Envoyer les mêmes valeurs que celles déjà en place produitTRADE_RETCODE_NO_CHANGES(10025) ; comparez avant d’envoyer. Voir Placer et modifier stop loss et take profit. - Fermer une position : une requête
TRADE_ACTION_DEALde sens opposé, de même volume, avec le ticket dansposition. Sans ticket, sur un compte hedging, le serveur ouvrirait une nouvelle position opposée au lieu de fermer la première. - Placer un ordre en attente :
TRADE_ACTION_PENDINGavec un type limite ou stop, le prix d’activation danspriceet le type d’expiration. Le ticket utile est alorsresult.order. - Supprimer un ordre en attente :
TRADE_ACTION_REMOVEavec seulementactionetorder.
Dans tous les cas, appelez ZeroMemory sur la requête avant de la remplir et réutilisez une fonction de journalisation commune pour les refus.
Distinguer erreur du terminal et refus du serveur
Deux niveaux d’erreur coexistent :
OrderSendrenvoiefalse: la requête n’a pas passé les contrôles du terminal.GetLastError()renvoie un code d’exécution, typiquement dans la plage 4751 à 4758 : par exemple 4752 (ERR_TRADE_DISABLED, trading par Expert Advisor interdit) ou 4756 (ERR_TRADE_SEND_FAILED, échec d’envoi de la requête), traité dans la page 4756 : échec d’envoi de la requête.OrderSendrenvoietruemaisretcoden’indique pas un succès : le serveur a analysé la requête et l’a refusée, partiellement exécutée ou annulée. Les codes vont de 10004 (TRADE_RETCODE_REQUOTE) à 10046 (TRADE_RETCODE_HEDGE_PROHIBITED).
Votre code doit traiter les deux niveaux et journaliser les informations utiles : symbole, volume, prix demandé, retcode, comment.
Pièges fréquents
Prix non normalisé. Un prix calculé avec des décimales en trop peut être refusé (10015, prix invalide). Normalisez avec NormalizeDouble(prix, _Digits) et, pour les symboles dont le pas de cotation n’est pas égal au point, arrondissez au multiple de SYMBOL_TRADE_TICK_SIZE. Voir NormalizeDouble et précision des prix.
Mauvais mode de remplissage. Le mode Return est interdit en exécution Market : la requête est refusée avec 10030. Lisez SYMBOL_FILLING_MODE comme dans l’exemple.
Stops trop proches. Le serveur refuse les stops plus proches que SYMBOL_TRADE_STOPS_LEVEL points (10016).
Boucle de renvoi. Renvoyer la même requête à chaque tick après un refus sature le serveur et peut déclencher 10024 (TRADE_RETCODE_TOO_MANY_REQUESTS). Limitez les tentatives et ne réessayez que pour les codes temporaires (requote, prix modifié, pas de cotation).
FAQ
Quelle différence entre OrderSend et OrderSendAsync ?
OrderSendAsync envoie la requête sans attendre la réponse du serveur. Selon la documentation, elle renvoie true si la requête a été envoyée, avec le code 10008 dans le résultat, et le résultat réel s’obtient via OnTradeTransaction. OrderSend attend la réponse du serveur.
Dois-je remplir price pour un ordre au marché ?
En exécution Market ou Exchange, le prix ne fait pas partie des champs requis ; en exécution Request ou Instant, il l’est, avec la déviation. Renseigner le prix courant rend le code compatible avec tous les modes.
Que contient result.deal après un ordre en attente ?
Rien d’utile : selon la documentation, deal concerne les opérations TRADE_ACTION_DEAL et order les opérations TRADE_ACTION_PENDING. Pour un ordre en attente, lisez result.order.
Pourquoi utiliser retcode_external ?
Certains brokers relaient les ordres vers un système externe (bourse, fournisseur de liquidité). Le champ contient alors le code d’erreur de ce système ; sa signification dépend du broker.
- Ordres, positions et transactions : le modèle de MT5
- Comptes netting ou hedging
- La classe CTrade
- OrderCheck : vérifier un ordre avant envoi
- Ouvrir une position au marché
- Ordres limites et stop
- Placer et modifier stop loss et take profit
- Coder un trailing stop
- Passer une position à break-even
- Fermer une position (totale ou partielle)
- Parcourir et filtrer les positions
- Le magic number
- Lire l’historique des ordres et transactions
- OnTradeTransaction : réagir aux événements de trading
- Modes de remplissage (FOK, IOC, Return)
- Gérer spread et slippage dans un EA
- Calculer et normaliser la taille de lot
