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

MQL5 · Indicateurs

iMFI en MQL5 : le Money Flow Index et la détection de divergences

iMFI() calcule le Money Flow Index, un oscillateur de 0 à 100 qui combine prix typique et volume. Signature, calcul, choix du volume et code de divergence.

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

Pour lire le Money Flow Index dans un programme MQL5, créez un handle avec iMFI(symbol, period, ma_period, applied_volume) puis copiez le buffer 0 avec CopyBuffer(). Le MFI est souvent présenté comme un « RSI pondéré par le volume » : il oscille entre 0 et 100, et ses zones extrêmes (80 et 20 dans l’exemple de la documentation officielle) signalent des excès possibles. Cette page se concentre sur ce qui le distingue réellement du RSI et sur son usage le plus intéressant en algorithmique : la divergence entre le prix et le flux monétaire.

La signature d’iMFI

int iMFI(
   string               symbol,          // symbole, NULL = symbole courant
   ENUM_TIMEFRAMES      period,          // unité de temps, 0 = courante
   int                  ma_period,       // période de calcul, en bougies
   ENUM_APPLIED_VOLUME  applied_volume   // VOLUME_TICK ou VOLUME_REAL
   );

La fonction renvoie un handle, ou INVALID_HANDLE en cas d’échec. Notez ce qui manque par rapport à iRSI() : il n’y a pas de paramètre de prix appliqué. Le MFI travaille toujours sur le prix typique de la bougie, et le seul choix qui vous est laissé concerne le type de volume. L’exemple de la documentation utilise une période de 14 et VOLUME_TICK.

Comment le terminal calcule le MFI

L’aide de MetaTrader 5 décompose le calcul en cinq étapes :

  1. prix typique : TP = (HIGH + LOW + CLOSE) / 3 ;
  2. flux monétaire de la bougie : MF = TP × VOLUME ;
  3. le flux est compté comme positif si le prix typique monte par rapport à la bougie précédente, négatif s’il baisse ; on additionne séparément flux positifs et négatifs sur la période ;
  4. ratio monétaire : MR = flux positif / flux négatif ;
  5. MFI = 100 - 100 / (1 + MR).

La structure finale est exactement celle du RSI. La différence tient à ce qui est additionné : le RSI additionne des variations de prix, le MFI additionne des montants de flux (prix × volume), dont le signe dépend seulement de la direction du prix typique. Une petite hausse sur un gros volume pèse donc lourd dans le MFI, alors qu’elle compte peu dans le RSI. C’est ce qui rend les deux oscillateurs complémentaires : quand ils divergent l’un de l’autre, c’est le volume qui raconte une histoire différente du prix.

Le choix du volume, décision structurante

Avec VOLUME_TICK, le flux est pondéré par le nombre de changements de cotation, une approximation de l’activité disponible sur presque tous les symboles. VOLUME_REAL n’a de sens que si le serveur diffuse le volume échangé, ce qui concerne principalement les marchés organisés. Un détail pratique : si le volume vaut zéro sur toute la fenêtre, flux positif et négatif sont nuls et l’indicateur ne peut rien mesurer. Avant de lancer une optimisation, affichez le MFI sur le graphique avec les deux réglages et vérifiez que la courbe bouge.

Gardez aussi à l’esprit que le volume en ticks dépend du flux de cotations du serveur. Deux courtiers peuvent produire des MFI légèrement différents sur le même instrument, ce qui n’est pas le cas d’un RSI calculé sur les clôtures.

Exemple complet : détecter une divergence haussière prix/MFI

L’aide de MetaTrader 5 souligne que, lorsque le prix et le MFI évoluent en sens opposé, la probabilité d’un retournement augmente. Le script d’Expert Advisor suivant formalise une version simple et testable de cette idée : le prix fait un plus bas plus bas que lors de la fenêtre précédente, alors que le MFI, lui, fait un plus bas plus haut, et ce plus bas du MFI se situe sous la zone des 20.

//+------------------------------------------------------------------+
//| MfiDivergence.mq5 - divergence haussière entre le prix et le MFI |
//+------------------------------------------------------------------+
input int                 InpMfiPeriod = 14;          // période du MFI
input ENUM_APPLIED_VOLUME InpVolume    = VOLUME_TICK; // type de volume
input int                 InpRecent    = 5;           // fenêtre récente (bougies)
input int                 InpOlder     = 20;          // fenêtre de référence
input double              InpLowZone   = 20.0;        // zone de survente

int hMfi = INVALID_HANDLE;

int OnInit()
  {
   hMfi = iMFI(_Symbol, PERIOD_CURRENT, InpMfiPeriod, InpVolume);
   if(hMfi == INVALID_HANDLE)
     {
      PrintFormat("iMFI : échec de création, erreur %d", GetLastError());
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   if(hMfi != INVALID_HANDLE)
      IndicatorRelease(hMfi);
  }

//--- index du minimum d'un tableau entre from et to inclus
int IndexOfMin(const double &a[], int from, int to)
  {
   int best = from;
   for(int i = from + 1; i <= to; i++)
      if(a[i] < a[best])
         best = i;
   return(best);
  }

//--- true si une divergence haussière est détectée sur bougies closes
bool BullishDivergence()
  {
   int total = 1 + InpRecent + InpOlder;      // l'index 0 (bougie en cours) est ignoré
   double mfi[], low[];
   ArraySetAsSeries(mfi, true);
   ArraySetAsSeries(low, true);
   if(CopyBuffer(hMfi, 0, 0, total, mfi) < total) return(false);
   if(CopyLow(_Symbol, PERIOD_CURRENT, 0, total, low) < total) return(false);

   int r = IndexOfMin(low, 1, InpRecent);              // creux récent du prix
   int o = IndexOfMin(low, InpRecent + 1, total - 1);  // creux plus ancien

   bool priceLowerLow = low[r] < low[o];
   bool mfiHigherLow  = mfi[r] > mfi[o];
   bool fromOversold  = mfi[o] < InpLowZone;
   return(priceLowerLow && mfiHigherLow && fromOversold);
  }

void OnTick()
  {
   static datetime lastBar = 0;
   datetime bar = iTime(_Symbol, PERIOD_CURRENT, 0);
   if(bar == lastBar) return;
   lastBar = bar;

   if(BullishDivergence())
      PrintFormat("%s : divergence haussière prix/MFI détectée", _Symbol);
  }

La logique compare les mêmes bougies des deux côtés : on repère les creux sur la série des plus bas, puis on lit la valeur du MFI sur ces bougies précises. C’est plus robuste que de chercher séparément le minimum du prix et le minimum du MFI, qui peuvent tomber sur des bougies sans rapport entre elles. Les deux tableaux sont indexés en série pour que l’index 1 désigne, dans les deux cas, la dernière bougie clôturée. Le symétrique baissier se code en remplaçant les plus bas par les plus hauts, les minimums par des maximums et la zone 20 par la zone 80.

Seuils, période et unité de temps

Les niveaux 20 et 80 retenus par l’exemple officiel sont des repères, pas des constantes. Sur un instrument très directionnel, le MFI peut rester au-dessus de 80 pendant des dizaines de bougies : vendre à chaque franchissement serait alors une stratégie contre-tendance coûteuse. Dans un Expert Advisor, déclarez ces seuils en paramètres input pour pouvoir les tester, et méfiez-vous des réglages trop fins issus d’une optimisation : un seuil optimal à 23,5 sur un historique a peu de chances de le rester. La page Optimisation génétique explique comment encadrer ce type de recherche.

La période agit comme pour le RSI : plus elle est courte, plus le MFI touche souvent les extrêmes. Si vous construisez un signal de divergence, la période doit rester cohérente avec la taille de vos fenêtres de comparaison ; un MFI à 14 périodes comparé sur des fenêtres de 3 bougies réagit surtout au bruit.

Pièges fréquents

  • Lire la bougie en cours. mfi[0] évolue à chaque tick ; un creux détecté sur la bougie en cours peut disparaître avant la clôture. Basez vos signaux sur l’index 1 et au-delà.
  • Oublier que les données peuvent manquer. Juste après le chargement de l’EA ou lors d’un changement d’unité de temps, CopyBuffer() peut renvoyer moins d’éléments que demandé. La fonction ci-dessus renvoie alors false et le signal est simplement reporté.
  • Utiliser le MFI comme déclencheur unique. Une divergence signale un essoufflement, pas un point d’entrée précis. Combinez-la avec un déclencheur de prix (cassure d’un plus haut récent, par exemple) et un filtre de tendance.
  • Comparer des MFI de courtiers différents. Le volume en ticks varie d’un serveur à l’autre ; vos résultats de test n’ont de valeur que sur le flux de données que vous utiliserez en réel.

Si vous cherchez plutôt un indicateur de volume cumulé pour confirmer des cassures, la page iOBV : On Balance Volume traite ce cas. Pour situer le MFI parmi les autres oscillateurs disponibles, revenez à la rubrique Indicateurs en MQL5.

Les divergences sont des signaux statistiquement fragiles : elles apparaissent souvent, et beaucoup ne sont suivies d’aucun retournement. Validez toute règle par un backtest en ticks réels puis en démo, et limitez le risque par position avant de passer sur un compte réel.

FAQ

Quelle est la différence entre iMFI et iRSI ?

Les deux ont la même formule finale (100 - 100 / (1 + ratio)), mais le RSI additionne des variations de prix de clôture alors que le MFI additionne des flux monétaires, c’est-à-dire le prix typique multiplié par le volume. iMFI() n’a donc pas de paramètre de prix appliqué, mais un paramètre de type de volume.

Pourquoi mon MFI reste-t-il plat ou à une valeur constante ?

Le plus souvent, le volume choisi est nul sur le symbole : c’est typique de VOLUME_REAL sur un instrument dont le serveur ne diffuse pas de volume échangé. Passez à VOLUME_TICK et vérifiez la fenêtre de données.

Combien de buffers renvoie iMFI ?

Un seul, d’index 0, qui contient la valeur du MFI entre 0 et 100. Il se lit avec CopyBuffer(handle, 0, ...).

Peut-on utiliser le MFI d’une autre unité de temps dans un EA ?

Oui : passez l’unité de temps voulue en deuxième paramètre, par exemple PERIOD_H4. Attention alors à l’indexation : l’index 1 désigne la dernière bougie H4 clôturée, pas la dernière bougie de votre graphique.

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.