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

MQL5 · Ordres et positions

OrderCheck en MQL5 : vérifier un ordre et la marge avant de l’envoyer

OrderCheck contrôle une requête sans l’envoyer et projette marge, marge libre et niveau de marge. Comment l’utiliser comme garde-fou avant OrderSend, et ses limites.

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

OrderCheck vérifie une requête de trading sans l’envoyer au serveur : elle contrôle que les paramètres sont correctement remplis et que les fonds suffisent, puis renseigne une structure MqlTradeCheckResult avec la marge requise, la marge libre restante, le niveau de marge et le solde projetés après l’opération. Sa signature est bool OrderCheck(MqlTradeRequest& request, MqlTradeCheckResult& result). Elle renvoie false si les fonds sont insuffisants ou si les paramètres sont incorrects.

La documentation de OrderSend recommande explicitement de vérifier une requête avant de l’envoyer. OrderCheck est l’outil prévu pour cela. Cette page fait partie de la rubrique Ordres et positions en MQL5.

Ce que OrderCheck vérifie… et ce qu’elle ne garantit pas

D’après la documentation :

  • la fonction renvoie false en cas de fonds insuffisants ou de paramètres mal remplis ; le code d’erreur s’obtient alors avec GetLastError() ;
  • elle renvoie true lorsque la vérification de base des structures réussit, ce qui n’indique pas que l’opération demandée sera exécutée avec succès ;
  • le détail du résultat se lit dans la structure MqlTradeCheckResult.

Autrement dit, OrderCheck filtre les erreurs prévisibles côté terminal (marge, volume, paramètres manquants), mais ne peut pas anticiper les décisions du serveur au moment de l’exécution : requote, marché fermé, prix qui a bougé, limite de positions atteinte, refus du fournisseur de liquidité. Elle ne remplace jamais la lecture du retcode après OrderSend.

La structure MqlTradeCheckResult

ChampTypeContenu
retcodeuintcode de réponse (même énumération que les codes de retour du serveur)
balancedoublesolde après l’exécution de l’opération
equitydoublefonds propres après l’exécution
profitdoubleprofit flottant après l’exécution
margindoublemarge requise pour l’opération
margin_freedoublemarge libre restant après l’exécution
margin_leveldoubleniveau de marge après l’exécution
commentstringcommentaire sur le code de réponse, description de l’erreur

Les champs margin_free et margin_level sont les plus utiles pour un Expert Advisor : ils permettent de refuser une entrée qui laisserait le compte trop proche d’un appel de marge, même si elle est techniquement possible.

Exemple : refuser une entrée qui consomme trop de marge

La fonction ci-dessous prépare un achat au marché, le vérifie avec OrderCheck, puis applique une règle maison : le niveau de marge projeté doit rester supérieur à un seuil exprimé en pourcentage. Le script affiche le diagnostic sans rien envoyer.

//+------------------------------------------------------------------+
//| Script : vérifier un achat avec OrderCheck sans l'envoyer        |
//+------------------------------------------------------------------+
input double InpLots          = 1.0;    // volume à tester
input double InpMinMarginLvl  = 500.0;  // niveau de marge minimal accepté (%)

//--- prépare une requête d'achat au marché
void BuildBuyRequest(MqlTradeRequest &req, double volume)
  {
   ZeroMemory(req);
   req.action       = TRADE_ACTION_DEAL;
   req.symbol       = _Symbol;
   req.volume       = volume;
   req.type         = ORDER_TYPE_BUY;
   req.price        = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   req.deviation    = 10;
   req.type_filling = ORDER_FILLING_FOK;   // à adapter au symbole
  }

//--- true si la requête passe OrderCheck et la règle de marge
bool CheckEntry(MqlTradeRequest &req)
  {
   MqlTradeCheckResult check;
   ZeroMemory(check);

   ResetLastError();
   if(!OrderCheck(req, check))
     {
      PrintFormat("OrderCheck refuse : erreur %d, retcode %u (%s)",
                  GetLastError(), check.retcode, check.comment);
      return(false);
     }

   PrintFormat("Marge requise %.2f | marge libre après %.2f | niveau %.1f %%",
               check.margin, check.margin_free, check.margin_level);

   if(check.margin_level > 0 && check.margin_level < InpMinMarginLvl)
     {
      Print("Entrée refusée : niveau de marge projeté trop faible");
      return(false);
     }
   return(true);
  }

void OnStart()
  {
   MqlTradeRequest req;
   BuildBuyRequest(req, InpLots);
   if(CheckEntry(req))
      Print("La requête peut être envoyée (le serveur aura le dernier mot)");
  }

Dans un Expert Advisor, la même fonction CheckEntry s’appelle juste avant OrderSend. Si vous utilisez CTrade, les méthodes CheckResultRetcode(), CheckResultMargin(), CheckResultMarginFree(), CheckResultMarginLevel() et CheckResultComment() donnent accès aux résultats de la dernière vérification ; la documentation précise que CheckResultRetcode() renvoie le champ retcode rempli lors du contrôle de validité de la requête.

OrderCheck ou OrderCalcMargin ?

MQL5 propose une autre fonction de calcul préalable : bool OrderCalcMargin(ENUM_ORDER_TYPE action, string symbol, double volume, double price, double& margin). Les deux ne répondent pas à la même question :

CritèreOrderCheckOrderCalcMargin
Entréerequête complète MqlTradeRequesttype, symbole, volume, prix
Prise en compte des positions et ordres existantsoui (projection sur le compte)non, selon la documentation
Résultatmarge, marge libre, niveau de marge, solde, fonds propresmarge requise seule, en devise du compte
Contrôle des paramètresouinon

OrderCalcMargin sert à dimensionner : combien de marge coûterait un lot, avant même de construire la requête. OrderCheck sert à valider une requête prête à partir, dans le contexte réel du compte. Sur un compte hedging, où la marge des positions couvertes peut être réduite, la projection d’OrderCheck est plus fidèle.

Où placer OrderCheck dans le flux d’un EA

Dans un Expert Advisor structuré, la vérification s’insère à un endroit précis de la séquence d’entrée :

  1. le signal est détecté (par exemple à l’ouverture d’une nouvelle bougie) ;
  2. les filtres sont appliqués : horaires, spread, volatilité ;
  3. le volume est calculé selon le risque et normalisé ;
  4. les prix (entrée, stop loss, take profit) sont lus sur la dernière cotation et normalisés ;
  5. la requête est construite, puis vérifiée par OrderCheck et vos règles de marge ;
  6. la requête est envoyée avec OrderSend et le retcode est analysé.

Placer la vérification en dernière étape, juste avant l’envoi, garantit qu’elle porte sur la requête exacte qui partira, avec les prix les plus récents. Si elle échoue, journalisez la raison et ne réessayez pas au tick suivant avec la même requête : corrigez d’abord la cause (volume, stops, marge).

Cas d’usage en trading

Contrôle de sécurité avant chaque entrée. Un EA qui pyramide ou qui gère plusieurs symboles peut, par accumulation, consommer la marge du compte. Un seuil de niveau de marge minimal, testé avec OrderCheck, est un coupe-circuit simple. Il complète la gestion du risque par trade décrite dans la page Calculer et normaliser la taille de lot.

Diagnostic d’une requête refusée. Quand une requête échoue sans raison apparente, passez-la à OrderCheck et affichez retcode et comment : un volume hors bornes, un stop mal placé ou un mode de remplissage interdit y apparaissent sans encombrer le serveur.

Validation d’un EA avant publication. Les vérifications de marge font partie des contrôles qu’un EA doit passer pour être robuste avec un petit dépôt. Un EA qui ouvre des positions sans vérifier la marge produira des rejets TRADE_RETCODE_NO_MONEY (10019) en série.

Pièges fréquents

Trading automatique désactivé. L’exemple de la documentation montre l’erreur 4752 avec le commentaire « AutoTrading disabled by client » lorsque le trading algorithmique est désactivé dans le terminal. OrderCheck échoue alors même pour une requête parfaite. Vérifiez le bouton Algo Trading du terminal et l’autorisation dans les propriétés de l’EA.

Prix périmé. La projection est calculée au prix indiqué dans la requête. Si vous construisez la requête longtemps avant l’envoi, relisez le prix juste avant OrderCheck puis juste avant OrderSend.

Interpréter true comme une garantie. Même avec OrderCheck réussi, le serveur peut refuser l’ordre. Gardez la gestion des codes de retour décrite dans Codes de retour du serveur de trading.

Appeler OrderCheck à chaque tick sans raison. La fonction n’envoie rien au serveur, mais l’appeler en boucle pour une requête qui ne sera pas envoyée n’apporte rien. Appelez-la au moment de la décision d’entrée.

Une vérification de marge n’est pas une gestion du risque complète : une position correctement margée peut perdre beaucoup si le stop est éloigné ou absent. Le trading avec effet de levier comporte un risque élevé de perte en capital.

FAQ

OrderCheck envoie-t-elle quelque chose au serveur ?

Non. Elle vérifie la requête et calcule les valeurs projetées sans transmettre d’ordre. Seules OrderSend et OrderSendAsync envoient une requête au serveur de trading.

Pourquoi OrderCheck renvoie-t-elle false avec l’erreur 4752 ?

Le code 4752 (ERR_TRADE_DISABLED) signifie que le trading par Expert Advisor est interdit. Activez le trading algorithmique dans le terminal et dans les paramètres du programme.

Faut-il appeler OrderCheck si j’utilise CTrade ?

Ce n’est pas obligatoire, mais une vérification explicite de la marge avant les entrées reste une bonne pratique. Les méthodes CheckResult… de CTrade exposent les résultats de la dernière vérification.

Le champ margin_level est-il en pourcentage ?

Le niveau de marge de MetaTrader correspond au rapport entre fonds propres et marge utilisée, affiché en pourcentage dans le terminal. Comparez-le à un seuil cohérent avec les niveaux d’appel de marge et de stop out de votre compte.

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.