MQL5 · Ordres et positions
Ouvrir une position au marché en MQL5 : achat, vente et gestion des refus
Ouvrir un achat au Ask ou une vente au Bid, calculer les stops depuis le bon prix, vérifier le retcode et réessayer seulement quand c’est utile : la méthode complète en MQL5.
Pour ouvrir une position au marché en MQL5, envoyez un ordre ORDER_TYPE_BUY ou ORDER_TYPE_SELL avec l’action TRADE_ACTION_DEAL, le plus simplement via CTrade::Buy ou CTrade::Sell. Un achat s’exécute au prix Ask, une vente au prix Bid. Calculez les stops depuis le prix auquel la position sera fermée (Bid pour un achat, Ask pour une vente), normalisez prix et volume, puis vérifiez le code de retour : TRADE_RETCODE_DONE (10009) signifie que la requête a été exécutée.
Cette page détaille ce flux, les vérifications préalables et la gestion des refus temporaires. Elle s’appuie sur la classe CTrade et fait partie de la rubrique Ordres et positions en MQL5.
Ask, Bid et le bon prix de référence
Le serveur cote deux prix. Vous achetez au prix demandé (Ask), plus élevé, et vous vendez au prix offert (Bid). L’écart entre les deux est le spread. Une position acheteuse est donc ouverte au Ask et fermée au Bid ; une position vendeuse est ouverte au Bid et fermée au Ask.
Cette asymétrie détermine le calcul des stops :
| Position | Prix d’ouverture | Stop loss | Take profit |
|---|---|---|---|
| Achat | Ask | sous le Bid | au-dessus du Bid |
| Vente | Bid | au-dessus du Ask | sous le Ask |
Le stop d’un achat se déclenche quand le Bid l’atteint, celui d’une vente quand le Ask l’atteint. Si vous calculez le stop d’un achat à partir du Ask, la distance réelle au déclenchement est réduite du spread. Le contrôle des distances minimales imposées par le broker suit la même logique et il est détaillé dans Placer et modifier stop loss et take profit.
Lisez les deux prix au même instant avec SymbolInfoTick, qui remplit une structure MqlTick (champs bid, ask, last, time…). Utiliser une seule cotation pour l’entrée et les stops évite des incohérences quand le prix change entre deux lectures.
Les vérifications avant l’envoi
Avant d’ouvrir une position, un EA robuste vérifie plusieurs conditions qui, sinon, se traduiraient par un refus :
- Le trading est permis. Le terminal et le programme doivent autoriser le trading algorithmique ; sinon le serveur renvoie
TRADE_RETCODE_CLIENT_DISABLES_AT(10027) ou le terminal l’erreur 4752. La propriété de compteACCOUNT_TRADE_EXPERTindique si le trading par Expert Advisor est autorisé sur le compte. - Le symbole est négociable.
SYMBOL_TRADE_MODEindique si le symbole accepte les ouvertures ; un marché fermé produitTRADE_RETCODE_MARKET_CLOSED(10018). - Le volume est valide. Il doit être compris entre
SYMBOL_VOLUME_MINetSYMBOL_VOLUME_MAXet être un multiple deSYMBOL_VOLUME_STEP, sinon 10014. La page sur la taille de lot de cette rubrique montre comment arrondir le volume au pas autorisé. - La marge suffit. Un contrôle préalable avec
OrderCheckouOrderCalcMarginévite 10019. - Le mode de remplissage est autorisé. En exécution Market, le mode Return est interdit ; un mauvais choix produit 10030.
Exemple : une fonction d’ouverture réutilisable
La fonction OpenMarket ci-dessous ouvre un achat ou une vente avec stops exprimés en points, réessaie un nombre limité de fois en cas de refus temporaire, et renvoie le ticket de la position.
//+------------------------------------------------------------------+
//| Ouverture d'une position au marché avec gestion des refus |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
input ulong InpMagic = 240506;
input double InpLots = 0.10;
input int InpSLPoints = 400;
input int InpTPPoints = 800;
CTrade trade;
int OnInit()
{
trade.SetExpertMagicNumber(InpMagic);
trade.SetDeviationInPoints(10);
trade.SetTypeFillingBySymbol(_Symbol);
return(INIT_SUCCEEDED);
}
//--- true pour les refus qui peuvent disparaître au tick suivant
bool IsTemporary(uint rc)
{
return(rc == TRADE_RETCODE_REQUOTE || // 10004
rc == TRADE_RETCODE_PRICE_CHANGED || // 10020
rc == TRADE_RETCODE_PRICE_OFF || // 10021
rc == TRADE_RETCODE_TIMEOUT); // 10012
}
//--- ouvre une position ; renvoie le ticket de position ou 0
ulong OpenMarket(ENUM_ORDER_TYPE type, double lots, int sl_pts, int tp_pts)
{
for(int attempt = 1; attempt <= 3; attempt++)
{
MqlTick tick;
if(!SymbolInfoTick(_Symbol, tick)) return(0);
double price, sl = 0.0, tp = 0.0;
if(type == ORDER_TYPE_BUY)
{
price = tick.ask;
if(sl_pts > 0) sl = NormalizeDouble(tick.bid - sl_pts * _Point, _Digits);
if(tp_pts > 0) tp = NormalizeDouble(tick.bid + tp_pts * _Point, _Digits);
}
else
{
price = tick.bid;
if(sl_pts > 0) sl = NormalizeDouble(tick.ask + sl_pts * _Point, _Digits);
if(tp_pts > 0) tp = NormalizeDouble(tick.ask - tp_pts * _Point, _Digits);
}
if(!trade.PositionOpen(_Symbol, type, lots, price, sl, tp, "OpenMarket"))
{
PrintFormat("Requête non envoyée (erreur %d)", GetLastError());
return(0);
}
uint rc = trade.ResultRetcode();
if(rc == TRADE_RETCODE_DONE || rc == TRADE_RETCODE_DONE_PARTIAL)
{
PrintFormat("Position ouverte : %.2f lot à %.5f (retcode %u)",
trade.ResultVolume(), trade.ResultPrice(), rc);
return(trade.ResultOrder()); // ticket de la nouvelle position
}
PrintFormat("Tentative %d refusée : %u %s", attempt, rc,
trade.ResultRetcodeDescription());
if(!IsTemporary(rc)) return(0); // erreur à corriger : pas de nouvel essai
Sleep(200); // courte pause avant nouvel essai
}
return(0);
}
void OnTick()
{
// Exemple : appel unique à la décision d'entrée, jamais à chaque tick
// ulong ticket = OpenMarket(ORDER_TYPE_BUY, InpLots, InpSLPoints, InpTPPoints);
}
La fonction renvoie ResultOrder() parce que, selon la documentation de PositionSelectByTicket, le ticket d’une position nouvellement ouverte correspond au ticket de l’ordre qui a généré le deal. Sur un compte netting où une position existait déjà, l’ordre s’ajoute à cette position, qui garde son propre ticket : sélectionnez-la alors avec PositionSelect(_Symbol). La distinction est expliquée dans Comptes netting ou hedging.
Déclencher l’entrée au bon moment
La fonction d’ouverture ne doit être appelée qu’une fois par décision. Dans un EA, OnTick est exécutée à chaque nouvelle cotation, parfois plusieurs fois par seconde. La structure la plus sûre sépare trois étapes : détecter un événement ponctuel (le plus souvent l’apparition d’une nouvelle bougie), évaluer le signal sur les bougies clôturées, puis vérifier qu’aucune position de l’EA n’est déjà ouverte dans le sens voulu. Ce n’est qu’après ces trois contrôles que la requête part.
Évaluer le signal sur la bougie clôturée plutôt que sur la bougie en cours a un autre avantage : le résultat du backtest et celui du compte réel restent comparables, puisque la décision ne dépend pas des variations du prix à l’intérieur de la bougie. Cette organisation est celle de la rubrique sur la construction d’un Expert Advisor, qui détaille la détection de nouvelle bougie et le codage du signal.
Après l’ouverture : contrôler la position obtenue
Un retcode de succès ne dispense pas de relire la position. Sélectionnez-la par son ticket et comparez son volume, son prix moyen et ses stops à ce que vous aviez demandé. Trois écarts sont possibles : un volume inférieur en cas de remplissage partiel, un prix d’entrée différent en cas de glissement, et des stops à placer ensuite par une modification si vous avez choisi d’ouvrir sans stops. Journaliser ces écarts dès les premiers jours sur un compte de démonstration vous renseigne sur la qualité d’exécution réelle du compte.
Interpréter le résultat
| Code | Constante | Réaction conseillée |
|---|---|---|
| 10009 | TRADE_RETCODE_DONE | succès, mémoriser le ticket |
| 10010 | TRADE_RETCODE_DONE_PARTIAL | seule une partie du volume est exécutée ; lire ResultVolume() |
| 10004 | TRADE_RETCODE_REQUOTE | relire le prix et réessayer un nombre limité de fois |
| 10020 | TRADE_RETCODE_PRICE_CHANGED | idem |
| 10021 | TRADE_RETCODE_PRICE_OFF | pas de cotation : attendre |
| 10014 / 10015 / 10016 | volume, prix ou stops invalides | corriger le calcul, ne pas réessayer tel quel |
| 10019 | TRADE_RETCODE_NO_MONEY | réduire le volume ou renoncer |
| 10030 | TRADE_RETCODE_INVALID_FILL | changer le mode de remplissage |
Chacun de ces codes dispose d’une page de diagnostic dans la rubrique des codes d’erreur, par exemple 10004 Requote.
Pièges fréquents
Ouvrir à chaque tick. Si la condition d’entrée reste vraie pendant plusieurs ticks, l’EA ouvre une position à chaque tick. Vérifiez qu’aucune position de l’EA n’existe déjà et déclenchez les entrées sur un événement ponctuel, comme l’ouverture d’une nouvelle bougie.
Ignorer le remplissage partiel. Avec un mode IOC, le volume exécuté peut être inférieur au volume demandé. Si votre gestion du risque suppose le volume complet, lisez le volume réel de la position.
Réessayer indéfiniment. Une boucle sans limite face à un refus permanent sature le serveur et peut entraîner TRADE_RETCODE_TOO_MANY_REQUESTS (10024). Limitez les tentatives et filtrez les codes réessayables.
Négliger le spread. Une entrée au marché paie le spread immédiatement. Sur un symbole au spread élargi (ouverture de session, annonce économique), la position démarre avec une perte plus importante. Un filtre de spread est décrit dans Gérer spread et slippage dans un EA.
FAQ
Pourquoi mon stop loss est-il refusé alors qu’il semble correct ?
Il est probablement calculé depuis le mauvais prix ou trop proche du marché. Calculez le stop d’un achat depuis le Bid et celui d’une vente depuis le Ask, et respectez SYMBOL_TRADE_STOPS_LEVEL.
Faut-il préciser le prix pour un ordre au marché ?
En exécution Market, le prix n’est pas requis par le serveur ; en exécution Instant ou Request, il l’est. Passer le prix de la dernière cotation rend votre code compatible avec tous les modes.
Comment récupérer le prix réel d’exécution ?
Juste après l’envoi avec ResultPrice() (champ price de MqlTradeResult), ou plus tard dans le deal (DEAL_PRICE) et le prix moyen de la position (POSITION_PRICE_OPEN).
Faut-il ouvrir sans stops puis les ajouter ?
Ce n’est utile que si le broker ou le symbole l’exige. Placer les stops dans la requête d’ouverture évite qu’une position reste sans protection, même quelques instants, si la modification suivante échouait.
Combien de fois réessayer après un requote ?
Il n’existe pas de règle officielle ; deux ou trois tentatives rapprochées suffisent en général. Au-delà, mieux vaut abandonner l’entrée que la poursuivre à un prix dégradé.
- 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
- 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
