MQL5 · Codes d’erreur
Erreur 10024 Too frequent requests en MQL5 : limiter le débit d’un EA
Le retcode 10024 signale un EA qui envoie trop de requêtes. Trailing stop à chaque tick, boucles de nouvel essai, EA multiples : les causes et un limiteur de débit MQL5.
Le code 10024 (TRADE_RETCODE_TOO_MANY_REQUESTS, libellé officiel « Too frequent requests ») signifie que votre programme envoie des requêtes de trading à un rythme que le serveur juge excessif. Ce n’est pas un problème de paramètres : chaque requête prise isolément peut être parfaitement valide. C’est la fréquence qui est en cause, presque toujours à cause d’un trailing stop modifié à chaque tick, d’une boucle de nouvel essai sans pause ou de plusieurs EA qui travaillent en même temps sur le même compte. La solution est de limiter le débit des requêtes dans le code : ne modifier un niveau que lorsque le changement est significatif, espacer les nouvelles tentatives et centraliser les envois.
Cette page décrit les schémas de code qui produisent ce refus et un limiteur de débit simple à intégrer. Elle fait partie de la rubrique Codes d’erreur et de retour MQL5.
Pourquoi un serveur limite-t-il les requêtes ?
Un serveur de trading traite les ordres de milliers de comptes. Un EA qui envoie plusieurs requêtes par seconde mobilise des ressources sans bénéfice réel, et peut perturber l’exécution des autres. Les courtiers fixent donc des seuils, dont la valeur exacte n’est pas publiée dans la documentation MQL5 et varie d’un serveur à l’autre. Il ne faut pas chercher le chiffre limite pour s’en approcher : il faut écrire un EA qui n’envoie que les requêtes utiles.
Au-delà du refus technique, un débit excessif peut attirer l’attention du courtier. Certains considèrent qu’un flux de modifications incessantes constitue un usage abusif du serveur.
Les schémas qui provoquent le 10024
Le trailing stop modifié à chaque tick
C’est de loin la cause la plus répandue. Un trailing stop naïf recalcule le stop à chaque tick et envoie une modification dès qu’il diffère du précédent, même d’un point. Sur une paire active, cela représente plusieurs requêtes par seconde. La correction consiste à n’envoyer la modification que si le nouveau stop améliore l’ancien d’au moins un pas minimal, par exemple 5 ou 10 points. Les variantes de trailing sont décrites dans Coder un trailing stop.
La boucle de nouvel essai sans pause
Un EA qui, après un refus, renvoie immédiatement la même requête dans une boucle while produit des dizaines d’envois en quelques millisecondes. Si le premier refus était un 10018 (marché fermé) ou un 10019 (fonds insuffisants), aucun de ces envois n’a la moindre chance d’aboutir, et le 10024 vient s’ajouter au problème initial.
Les modifications sans changement
Envoyer une modification avec exactement les mêmes niveaux que les niveaux actuels produit un 10025 (TRADE_RETCODE_NO_CHANGES). Si l’EA ne compare pas les valeurs, il peut répéter cette requête inutile à chaque tick, ce qui finit en 10024.
Plusieurs EA sur le même compte
Dix graphiques ouverts avec le même EA, chacun gérant son trailing, multiplient les requêtes par dix. Le serveur, lui, voit un seul compte. C’est un cas fréquent sur les VPS où l’on déploie un EA sur toute une liste de symboles.
Un limiteur de débit réutilisable
La classe suivante impose un intervalle minimal entre deux requêtes et une pause croissante après chaque 10024. Elle repose sur GetTickCount64(), qui renvoie le nombre de millisecondes écoulées depuis le démarrage du système.
//+------------------------------------------------------------------+
//| Limiteur de débit pour les requêtes de trading |
//+------------------------------------------------------------------+
class CRequestThrottle
{
private:
ulong m_lastSend; // horodatage du dernier envoi (ms)
ulong m_minGap; // intervalle minimal normal (ms)
ulong m_penalty; // pause supplémentaire après un 10024 (ms)
public:
CRequestThrottle(const ulong minGapMs) : m_lastSend(0), m_minGap(minGapMs), m_penalty(0) {}
// Vrai si l'on a le droit d'envoyer maintenant
bool CanSend(void)
{
return(GetTickCount64() - m_lastSend >= m_minGap + m_penalty);
}
// À appeler après chaque envoi avec le retcode obtenu
void OnResult(const uint retcode)
{
m_lastSend = GetTickCount64();
if(retcode == TRADE_RETCODE_TOO_MANY_REQUESTS)
m_penalty = (m_penalty == 0) ? 1000 : MathMin(m_penalty * 2, (ulong)60000);
else
m_penalty = 0; // retour à la normale après un envoi accepté ou refusé pour autre cause
}
};
#include <Trade\Trade.mqh>
CTrade trade;
CRequestThrottle throttle(500); // au plus 2 requêtes par seconde
input int InpTrailPoints = 200; // distance du trailing
input int InpTrailStep = 20; // amélioration minimale avant modification
//+------------------------------------------------------------------+
//| Trailing d'une position acheteuse, économe en requêtes |
//+------------------------------------------------------------------+
void TrailBuy(const ulong ticket)
{
if(!PositionSelectByTicket(ticket)) return;
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double sl = PositionGetDouble(POSITION_SL);
double tp = PositionGetDouble(POSITION_TP);
double newSL = NormalizeDouble(bid - InpTrailPoints * _Point, _Digits);
// N'envoyer que si le stop progresse d'au moins InpTrailStep points
if(sl > 0.0 && newSL - sl < InpTrailStep * _Point) return;
if(!throttle.CanSend()) return; // on réessaiera à un tick ultérieur
trade.PositionModify(ticket, newSL, tp);
throttle.OnResult(trade.ResultRetcode());
}
Le pas minimal InpTrailStep divise à lui seul le nombre de requêtes par un facteur important, sans changer sensiblement le comportement du trailing. Le limiteur ajoute une sécurité générale, et la pénalité exponentielle (une seconde, puis deux, quatre… jusqu’à soixante) laisse au serveur le temps de revenir à la normale.
Diagnostiquer dans le journal
Le 10024 se repère facilement à son contexte : il apparaît rarement seul. Recherchez dans l’onglet Experts une série serrée de requêtes juste avant le refus. Si toutes concernent des modifications de stop, le trailing est en cause. Si ce sont des ouvertures identiques, c’est une boucle de nouvel essai. Si les lignes proviennent de plusieurs symboles, c’est la multiplication des EA.
Un compteur de requêtes par minute, affiché périodiquement, fournit une mesure objective. Pour un EA de swing ou de tendance, quelques requêtes par heure suffisent généralement. Un compteur qui affiche plusieurs dizaines de requêtes par minute signale un problème de conception, même en l’absence de refus.
Auditer un EA avant sa mise en production
Avant de déployer un EA, faites-le tourner une journée complète sur compte démo avec un compteur de requêtes par catégorie : ouvertures, clôtures, modifications de stops, ordres en attente. Exportez ces compteurs dans OnDeinit(). Le résultat dit beaucoup de la qualité de conception : un EA dont les modifications représentent plus de 90 % des requêtes, pour une poignée d’ouvertures, gaspille du débit. Comparez aussi la journée la plus calme et la plus agitée : si le nombre de requêtes explose les jours de forte volatilité, c’est précisément ces jours-là que le 10024 risque de frapper, au moment où vous avez le plus besoin que vos ordres passent. Cet audit fait naturellement partie d’une checklist avant mise en production.
Centraliser les envois d’un EA multi-symboles
Lorsque plusieurs symboles sont gérés, préférez un seul EA qui centralise l’envoi des requêtes, avec un seul limiteur, à une copie de l’EA par graphique. Ce point de passage unique permet aussi de prioriser : une clôture urgente passe avant un ajustement de trailing. La conception d’un EA de ce type est abordée dans EA multi-symboles.
Pour réduire la charge de façon plus structurelle, on peut aussi déplacer la gestion des positions dans OnTimer(), à intervalle fixe, au lieu de la déclencher à chaque tick. Une vérification toutes les secondes ou toutes les cinq secondes suffit à la plupart des trailing stops.
Pièges fréquents
- Augmenter la pause en ignorant la cause. Un
Sleep()ajouté au hasard masque le symptôme ; corrigez la logique qui génère trop de requêtes. - Utiliser
Sleep()dans un indicateur. Les indicateurs ne peuvent de toute façon pas trader ; et dans un EA, unSleep()long bloque le traitement des ticks suivants. - Oublier la comparaison des niveaux avant une modification.
- Valider en backtest. Le testeur ne reproduit pas la limitation du serveur : un EA trop bavard peut passer inaperçu jusqu’au réel.
Questions fréquentes
Combien de requêtes par seconde le serveur accepte-t-il ?
La documentation MQL5 ne fixe aucun seuil : il dépend du courtier et du serveur. Concevez votre EA pour n’envoyer que les requêtes nécessaires, avec un intervalle minimal de l’ordre de quelques centaines de millisecondes entre deux envois.
Mon trailing stop provoque des 10024, que faire ?
Ajoutez un pas minimal : ne modifiez le stop que lorsqu’il progresse d’un nombre de points significatif. Comparez aussi le nouveau niveau à l’actuel pour éviter les modifications identiques (10025).
Quelle différence entre 10024 et 10025 ?
10024 signale des requêtes trop fréquentes. 10025 (TRADE_RETCODE_NO_CHANGES) signale une requête qui ne change rien, par exemple une modification avec les niveaux déjà en place. Répéter des 10025 conduit souvent au 10024.
Faut-il réessayer après un 10024 ?
Oui, mais après une pause, en l’augmentant si le refus se répète. Réessayer immédiatement prolonge le problème.
- Erreurs de compilation MQL5
- Invalid pointer access
- GetLastError et gestion des erreurs
- Codes de retour du serveur de trading
- 10004 Requote
- 10006 Requête rejetée
- 10013 Requête invalide
- 10014 Volume invalide
- 10015 Prix invalide
- 10016 Stops invalides
- 10017 Trading désactivé
- 10018 Marché fermé
- 10019 Fonds insuffisants
- 10021 Pas de cotations
- 10027 Trading automatique désactivé
- 10030 Mode de remplissage non supporté
- 4756 Échec d’envoi de la requête
- Array out of range
- Division par zéro
