MQL5 · Ordres et positions
Stop loss et take profit en MQL5 : placer, valider et modifier les niveaux
Poser un stop loss et un take profit en MQL5, à l’ouverture ou avec PositionModify, en respectant StopsLevel et FreezeLevel pour éviter les codes 10016, 10025 et 10029.
En MQL5, le stop loss et le take profit d’une position se fixent soit directement dans la requête d’ouverture (champs sl et tp), soit après coup avec l’action TRADE_ACTION_SLTP, que la classe CTrade expose sous la forme PositionModify(ticket, sl, tp). Dans les deux cas, les niveaux doivent être normalisés, placés du bon côté du prix de clôture (Bid pour un achat, Ask pour une vente) et respecter la distance minimale SYMBOL_TRADE_STOPS_LEVEL, sans quoi le serveur répond TRADE_RETCODE_INVALID_STOPS (10016).
Cette page traite de la mécanique : calculer, valider et envoyer les niveaux. Le choix de la distance du stop selon la volatilité ou la structure du marché relève de la gestion du risque, développée dans Placer son stop-loss. Elle fait partie de la rubrique Ordres et positions en MQL5.
Deux façons de poser les stops
À l’ouverture
La requête TRADE_ACTION_DEAL accepte directement sl et tp. Avec CTrade::Buy(volume, symbol, price, sl, tp) ou PositionOpen, il suffit de passer les niveaux calculés. C’est la méthode recommandée : la position n’est jamais exposée sans protection, même un court instant.
Après l’ouverture
L’action TRADE_ACTION_SLTP modifie les niveaux d’une position existante. D’après la documentation de MqlTradeRequest, elle requiert action, symbol, sl, tp et position (le ticket de la position). Avec CTrade, deux surcharges existent : PositionModify(const string symbol, double sl, double tp) et PositionModify(const ulong ticket, double sl, double tp). Sur un compte hedging, la surcharge par symbole modifie la position au ticket le plus bas ; utilisez donc toujours la surcharge par ticket quand plusieurs positions peuvent exister.
Pour conserver un niveau inchangé, repassez sa valeur actuelle : la documentation de PositionModify décrit sl et tp comme le nouveau prix, ou la valeur précédente si aucun changement n’est nécessaire. Une valeur 0 signifie l’absence de niveau ; envoyer 0 supprime donc le stop existant.
Les règles de distance du broker
SYMBOL_TRADE_STOPS_LEVEL
La documentation définit cette propriété comme l’écart minimal, en points, entre le prix de clôture courant et le niveau d’un ordre stop. Un article de référence publié sur le site MQL5 sur les contrôles qu’un EA doit effectuer détaille les comparaisons à appliquer pour une position :
| Position | Contrôle du take profit | Contrôle du stop loss |
|---|---|---|
| Achat | TP − Bid ≥ StopsLevel | Bid − SL ≥ StopsLevel |
| Vente | Ask − TP ≥ StopsLevel | SL − Ask ≥ StopsLevel |
Pour un ordre en attente, les distances se mesurent depuis le prix d’ouverture de l’ordre et non depuis le marché. Une valeur nulle signifie qu’aucune distance minimale n’est imposée par ce paramètre, ce qui ne garantit pas que le serveur accepte un stop collé au prix.
SYMBOL_TRADE_FREEZE_LEVEL
Le niveau de gel est la distance, en points, dans laquelle les opérations de modification sont interdites. Si le prix est trop près du stop loss ou du take profit actuel d’une position, le serveur refuse de modifier ces niveaux et répond TRADE_RETCODE_FROZEN (10029). Pour un achat, la distance se mesure entre le Bid et chacun des niveaux ; pour une vente, entre le Ask et chacun des niveaux.
Exemple : poser ou corriger les stops d’une position
La fonction suivante calcule des stops en points pour une position identifiée par son ticket, vérifie les distances minimales, évite une modification inutile et envoie la requête.
//+------------------------------------------------------------------+
//| Pose SL et TP (en points) sur une position, avec contrôles |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
CTrade trade;
//--- arrondit un prix au pas de cotation du symbole
double RoundToTick(const string symbol, double price)
{
double tick = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
if(tick > 0) price = MathRound(price / tick) * tick;
return(NormalizeDouble(price, digits));
}
//--- true si la modification a été exécutée ou n'était pas nécessaire
bool SetStops(ulong ticket, int sl_pts, int tp_pts)
{
if(!PositionSelectByTicket(ticket)) return(false);
string symbol = PositionGetString(POSITION_SYMBOL);
long type = PositionGetInteger(POSITION_TYPE);
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
double bid = SymbolInfoDouble(symbol, SYMBOL_BID);
double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
double min_d = SymbolInfoInteger(symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
double open = PositionGetDouble(POSITION_PRICE_OPEN);
double sl = 0.0, tp = 0.0;
if(type == POSITION_TYPE_BUY)
{
if(sl_pts > 0) sl = RoundToTick(symbol, open - sl_pts * point);
if(tp_pts > 0) tp = RoundToTick(symbol, open + tp_pts * point);
if(sl > 0 && bid - sl < min_d) { Print("SL trop proche du Bid"); return(false); }
if(tp > 0 && tp - bid < min_d) { Print("TP trop proche du Bid"); return(false); }
}
else
{
if(sl_pts > 0) sl = RoundToTick(symbol, open + sl_pts * point);
if(tp_pts > 0) tp = RoundToTick(symbol, open - tp_pts * point);
if(sl > 0 && sl - ask < min_d) { Print("SL trop proche du Ask"); return(false); }
if(tp > 0 && ask - tp < min_d) { Print("TP trop proche du Ask"); return(false); }
}
//--- rien à changer : éviter le code 10025
if(MathAbs(sl - PositionGetDouble(POSITION_SL)) < point &&
MathAbs(tp - PositionGetDouble(POSITION_TP)) < point)
return(true);
if(!trade.PositionModify(ticket, sl, tp))
{
Print("Requête non envoyée, erreur ", GetLastError());
return(false);
}
uint rc = trade.ResultRetcode();
if(rc != TRADE_RETCODE_DONE)
{
PrintFormat("Modification refusée : %u %s", rc, trade.ResultRetcodeDescription());
return(false);
}
return(true);
}
Les niveaux sont calculés ici depuis le prix d’ouverture de la position, ce qui convient pour poser des stops juste après l’entrée. Si la position est ouverte depuis longtemps et que le prix a beaucoup bougé, le stop calculé peut se retrouver du mauvais côté du marché : le contrôle de distance le détecte et la fonction renonce. L’arrondi au pas de cotation (SYMBOL_TRADE_TICK_SIZE) est plus sûr qu’un simple NormalizeDouble sur les symboles dont le pas n’est pas égal au point, comme certains indices ; voir NormalizeDouble et précision des prix.
Exprimer les stops : points, pips, prix
Les paramètres d’un EA sont souvent exprimés en points, car le point (SYMBOL_POINT) est l’unité native de MetaTrader et celle de SYMBOL_TRADE_STOPS_LEVEL. Sur une paire de devises cotée avec 5 décimales, 1 pip vaut 10 points ; sur une cotation à 3 décimales (paires en yen), même rapport. Si vos utilisateurs raisonnent en pips, convertissez explicitement plutôt que de laisser une ambiguïté dans le nom du paramètre.
Une autre approche consiste à exprimer le stop en multiple de la volatilité, par exemple de l’ATR. Le calcul du niveau devient alors dynamique, mais la mécanique d’envoi reste la même : un prix normalisé, du bon côté, à distance suffisante. La lecture de l’ATR est présentée dans la page iATR : Average True Range.
Pièges fréquents
Stops calculés depuis le mauvais prix. Calculer le stop d’un achat depuis le Ask réduit la distance réelle du montant du spread ; sur un spread large, le stop peut même devenir invalide.
Stops envoyés à chaque tick. Un EA qui recalcule et renvoie les mêmes niveaux à chaque tick provoque des refus TRADE_RETCODE_NO_CHANGES (10025) et peut atteindre TRADE_RETCODE_TOO_MANY_REQUESTS (10024). Comparez toujours avec les niveaux actuels avant d’envoyer.
Supprimer un niveau par erreur. Passer 0.0 pour le take profit alors que vous ne vouliez modifier que le stop loss supprime le take profit. Relisez la valeur actuelle avec PositionGetDouble(POSITION_TP) et repassez-la.
Ignorer le niveau de gel. Près du déclenchement, la modification est bloquée : votre logique doit accepter l’échec sans réessayer en boucle.
Stops désactivés sur le symbole. Si SYMBOL_ORDER_MODE ne contient pas SYMBOL_ORDER_SL ou SYMBOL_ORDER_TP, le symbole n’accepte pas ces niveaux ; il faut alors gérer la sortie par l’EA lui-même.
Aller plus loin
Une fois les stops posés, deux techniques de gestion consistent à les déplacer avec le prix : le trailing stop, qui suit le marché à distance fixe ou variable, et le passage à break-even, qui remonte le stop au prix d’entrée lorsque le gain atteint un seuil. Toutes deux reposent sur la fonction de modification présentée ici.
FAQ
Comment supprimer le stop loss d’une position ?
Envoyez une modification avec sl égal à 0 et le take profit actuel inchangé. Vérifiez que cette suppression est voulue : la position n’a alors plus de protection côté serveur.
Pourquoi le code 10016 apparaît-il alors que ma distance est supérieure au StopsLevel ?
Vérifiez le prix de référence (Bid ou Ask), la normalisation et le niveau de gel. Le spread peut aussi s’élargir entre le calcul et l’envoi ; prévoyez une marge de quelques points au-dessus du minimum.
TRADE_ACTION_SLTP fonctionne-t-il sur un ordre en attente ?
Non. Les stops d’un ordre en attente se modifient avec TRADE_ACTION_MODIFY (CTrade::OrderModify). TRADE_ACTION_SLTP concerne les positions ouvertes.
Faut-il un take profit systématique ?
Non, c’est un choix de stratégie. Certaines stratégies de suivi de tendance sortent par un trailing stop ou un signal inverse, sans take profit fixe. Le stop loss, lui, reste fortement recommandé dans tous les cas pour borner la perte d’une position.
Le stop loss est-il géré par le serveur ou par mon EA ?
Un stop loss posé sur la position est géré par le serveur du broker : il se déclenche même si le terminal est fermé. Un stop « virtuel » calculé par l’EA, au contraire, ne fonctionne que si le terminal tourne.
- Ordres, positions et transactions : le modèle de MT5
- Comptes netting ou hedging
- La classe CTrade
- OrderSend et MqlTradeRequest
- OrderCheck : vérifier un ordre avant envoi
- Ouvrir une position au marché
- Ordres limites et stop
- 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
