Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

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.

Mis à jour le 23 octobre 2026Lecture : 7 minPar Alix, OptiBot Trading

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 :

PositionContrôle du take profitContrôle du stop loss
AchatTP − Bid ≥ StopsLevelBid − SL ≥ StopsLevel
VenteAsk − TP ≥ StopsLevelSL − 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.

Un stop loss limite la perte prévue mais ne la garantit pas : en cas de gap ou de forte volatilité, l’exécution peut se faire à un prix moins favorable que le niveau fixé. Le trading avec effet de levier comporte un risque élevé de perte en capital.

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.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.