MQL4 · Ordres
Comptes ECN en MQL4 : ouvrir sans stops puis les poser avec OrderModify
Exécution au marché, SYMBOL_TRADE_EXEMODE et ouverture en deux temps : comment un EA MQL4 place ses stops sur un compte ECN sans laisser de position sans protection.
Sur certains comptes MetaTrader 4 en exécution au marché, souvent présentés comme comptes ECN ou STP, le serveur refuse un ordre au marché envoyé avec un stop loss ou un take profit non nul. La méthode robuste, qui fonctionne sur tous les types de comptes, consiste à ouvrir la position avec stoploss = 0 et takeprofit = 0, puis à poser immédiatement les niveaux avec OrderModify() en les recalculant à partir du prix réellement obtenu. Le mode d’exécution d’un symbole se lit avec SymbolInfoInteger(symbole, SYMBOL_TRADE_EXEMODE), qui renvoie notamment SYMBOL_TRADE_EXECUTION_INSTANT ou SYMBOL_TRADE_EXECUTION_MARKET.
Cette page explique la différence entre les modes d’exécution, montre comment détecter le mode du symbole et propose une fonction d’ouverture en deux temps qui limite la période sans protection. Elle fait partie de la rubrique Gérer les ordres en MQL4.
Exécution instantanée et exécution au marché
La documentation du MQL4 définit, pour la propriété SYMBOL_TRADE_EXEMODE, les modes suivants :
| Constante | Mode | Ce que cela implique pour l’EA |
|---|---|---|
SYMBOL_TRADE_EXECUTION_REQUEST | Exécution sur demande | Le prix est demandé puis confirmé |
SYMBOL_TRADE_EXECUTION_INSTANT | Exécution instantanée | L’ordre est exécuté au prix demandé, dans la limite du glissement, ou refusé (requote) |
SYMBOL_TRADE_EXECUTION_MARKET | Exécution au marché | L’ordre est exécuté au prix disponible, le prix envoyé et le glissement ayant un rôle limité |
SYMBOL_TRADE_EXECUTION_EXCHANGE | Exécution bourse | Non utilisé en MQL4 selon la documentation |
En exécution instantanée, le paramètre slippage d’OrderSend() fixe l’écart toléré, et un prix dépassé produit une requote. En exécution au marché, l’ordre est transmis pour être exécuté au meilleur prix disponible : le prix réellement obtenu peut différer du prix envoyé, et c’est le contexte dans lequel certains serveurs refusent des stops à l’ouverture.
Ce comportement dépend du courtier et de sa configuration, pas du langage : deux comptes en exécution au marché chez deux courtiers différents peuvent réagir différemment. D’où l’intérêt d’une méthode qui fonctionne partout.
Détecter le mode d’exécution
#property strict
//+------------------------------------------------------------------+
//| Vrai si le symbole est en exécution au marché |
//+------------------------------------------------------------------+
bool ExecutionAuMarche(string sym)
{
long mode = SymbolInfoInteger(sym, SYMBOL_TRADE_EXEMODE);
return(mode == SYMBOL_TRADE_EXECUTION_MARKET);
}
int OnInit()
{
PrintFormat("%s : exécution %s", Symbol(),
EnumToString((ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(Symbol(), SYMBOL_TRADE_EXEMODE)));
return(INIT_SUCCEEDED);
}
Affichez cette information au démarrage de l’EA : elle permet de comprendre a posteriori un comportement différent entre deux comptes. Vous pouvez aussi l’utiliser pour choisir automatiquement la méthode d’ouverture, mais la méthode en deux temps décrite ci-dessous peut être utilisée systématiquement, quel que soit le mode.
Ouvrir en deux temps
#property strict
input double InpLots = 0.10; // Volume
input int InpStopPoints = 300; // Stop loss (points)
input int InpTpPoints = 600; // Take profit (points)
input int InpSlippage = 10; // Glissement (points, exécution instantanée)
input int InpMagic = 240212; // Numéro magique
//+------------------------------------------------------------------+
//| Ouvre sans stops, puis pose SL et TP depuis le prix obtenu |
//+------------------------------------------------------------------+
int OuvrirPuisProteger(int type)
{
RefreshRates();
double prix = (type == OP_BUY) ? Ask : Bid;
// 1. ouverture SANS stop ni objectif
ResetLastError();
int ticket = OrderSend(Symbol(), type, InpLots, NormalizeDouble(prix, Digits),
InpSlippage, 0, 0, "ecn", InpMagic, 0, clrNONE);
if(ticket < 0)
{
PrintFormat("Ouverture refusée : erreur %d", GetLastError());
return(-1);
}
// 2. relire le prix d'exécution réel
if(!OrderSelect(ticket, SELECT_BY_TICKET))
return(ticket);
double entree = OrderOpenPrice();
double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
double dSL = MathMax(InpStopPoints * Point, stopLevel + Point);
double dTP = MathMax(InpTpPoints * Point, stopLevel + Point);
double sl = (type == OP_BUY) ? entree - dSL : entree + dSL;
double tp = (type == OP_BUY) ? entree + dTP : entree - dTP;
sl = NormalizeDouble(sl, Digits);
tp = NormalizeDouble(tp, Digits);
// 3. poser les niveaux, avec quelques tentatives
for(int essai = 1; essai <= 5; essai++)
{
ResetLastError();
if(OrderModify(ticket, entree, sl, tp, 0, clrNONE))
return(ticket);
PrintFormat("Pose des stops, essai %d : erreur %d", essai, GetLastError());
Sleep(300);
RefreshRates();
}
// 4. échec persistant : ne pas laisser une position sans protection
Print("Impossible de poser le stop : fermeture de sécurité");
RefreshRates();
double prixSortie = (type == OP_BUY) ? Bid : Ask;
if(!OrderClose(ticket, InpLots, NormalizeDouble(prixSortie, Digits), InpSlippage, clrRed))
PrintFormat("Fermeture de sécurité refusée : erreur %d", GetLastError());
return(-1);
}
Cette fonction contient trois décisions importantes. D’abord, les niveaux sont calculés depuis le prix d’exécution réel lu avec OrderOpenPrice(), et non depuis le prix envoyé : en exécution au marché, l’écart peut être de plusieurs points, et un stop calculé sur le prix demandé ne correspondrait plus au risque prévu. Ensuite, la pose des stops est retentée plusieurs fois, car une modification peut échouer pour une raison passagère (contexte occupé, prix en mouvement). Enfin, si le stop ne peut décidément pas être posé, la fonction ferme la position plutôt que de la laisser sans protection. C’est un choix de gestion du risque que vous pouvez adapter, mais qui doit être explicite.
Si le stop est trop proche du prix au moment de la pose, le serveur renvoie l’erreur 130 ; la distance minimale est expliquée dans StopLevel et FreezeLevel.
La fenêtre sans protection
Entre l’ouverture et la pose du stop, la position n’est pas protégée. En conditions normales, cette fenêtre dure le temps d’un aller-retour avec le serveur. Elle peut s’allonger en cas de forte activité ou de coupure de connexion. Trois mesures la réduisent :
- Appeler
OrderModify()immédiatement après l’ouverture, dans la même exécution deOnTick(), sans calcul intermédiaire. - Vérifier à chaque tick que toutes les positions de l’EA ont bien un stop. Une fonction de contrôle qui pose un stop sur toute position où
OrderStopLoss() == 0rattrape les cas où la pose a échoué, y compris après un redémarrage du terminal. - Surveiller le journal. Des échecs répétés de pose de stop sont un signal d’alerte à traiter avant de poursuivre en réel.
Et les ordres en attente ?
La contrainte concerne les ordres au marché. Un ordre en attente est placé avec ses niveaux, puis exécuté plus tard par le serveur ; ses stops sont mesurés depuis son prix d’entrée. Si votre courtier en exécution au marché pose problème à l’ouverture, une entrée par ordre en attente peut être une alternative, avec ses propres règles décrites dans Ordres en attente. Après le déclenchement, vérifiez néanmoins que les niveaux sont bien présents sur la position.
Une fonction de rattrapage à chaque tick
La fonction d’ouverture en deux temps couvre le cas normal. Pour les situations anormales (redémarrage du terminal juste après une ouverture, coupure réseau pendant la pose des stops), ajoutez une fonction appelée au début de chaque OnTick() qui parcourt les positions de l’EA et pose un stop sur toute position où OrderStopLoss() vaut 0. Elle utilise les mêmes calculs que la fonction d’ouverture, à partir de OrderOpenPrice(), en vérifiant d’abord que le stop calculé n’est pas déjà dépassé par le prix courant ; si c’est le cas, la position a déjà perdu plus que prévu et la fermer immédiatement est généralement le choix le plus cohérent avec le risque initial.
Pièges fréquents
- Calculer le stop depuis le prix envoyé : le prix d’exécution peut être différent, et le risque réel avec lui.
- Abandonner après un échec de pose : une position sans stop sur un compte réel est un risque non borné.
- Compter sur le glissement en exécution au marché : il n’y garantit pas un prix maximal comme en exécution instantanée.
- Coder le comportement d’un seul courtier : la méthode en deux temps fonctionne partout ; un code qui suppose que les stops sont acceptés à l’ouverture échouera chez un autre courtier.
Et en MQL5 ?
En MQL5, le mode d’exécution se lit de la même façon avec SYMBOL_TRADE_EXEMODE, et le mode de remplissage de l’ordre (ORDER_FILLING_FOK, ORDER_FILLING_IOC, ORDER_FILLING_RETURN) doit être compatible avec le symbole. Les stops peuvent en général être fournis dans la requête d’ouverture, mais vérifier qu’ils ont bien été posés reste une bonne pratique. Voir Des ordres MQL4 aux positions MQL5.
FAQ
Pourquoi mon ordre avec stop loss est-il refusé sur mon compte ECN ?
Certains serveurs en exécution au marché n’acceptent pas de stop loss ni de take profit dans l’ordre d’ouverture. Ouvrez avec des niveaux à 0, puis posez-les avec OrderModify() juste après.
Comment savoir si mon compte est en exécution au marché ?
Lisez SymbolInfoInteger(Symbol(), SYMBOL_TRADE_EXEMODE) et comparez la valeur à SYMBOL_TRADE_EXECUTION_MARKET. La fenêtre de passage d’ordre du terminal l’indique aussi.
Peut-on utiliser la méthode en deux temps sur un compte classique ?
Oui. Elle fonctionne quel que soit le mode d’exécution, ce qui en fait la solution la plus portable pour un EA distribué à plusieurs utilisateurs.
Que faire si le stop ne peut pas être posé ?
Retentez quelques fois en rafraîchissant les prix. Si l’échec persiste, fermez la position ou alertez l’utilisateur : ne la laissez pas ouverte sans protection.
