Butterfly Harmonic Pattern EA: Trade Fibonacci Reversals

Introduction

Ahoy, future forex treasure hunter! Picture the forex market as a vast treasure map, where prices weave intricate paths leading to hidden reversal points marked by Butterfly harmonic patterns. The Butterfly Harmonic Pattern EA is your master cartographer, pinpointing these Fibonacci-driven bullish and bearish patterns with precision, drawing them with triangles and lines, and automating trades with clear entry and exit points. This article is your expedition journal, guiding you through the MQL5 code on MetaTrader 5 with vivid detail. We’ll unpack every major function with clarity for beginners, weaving humor and flow like a tale spun by a campfire. By the end, you’ll be ready to let this Expert Advisor (EA) unearth market riches for you. Let’s start charting!

Strategy Blueprint

The Butterfly Harmonic Pattern EA targets the Butterfly pattern, a five-point (X, A, B, C, D) formation defined by Fibonacci ratios signaling reversals:

• Bullish Butterfly: Forms at a downtrend’s end, with D below X, triggering a buy.

• Bearish Butterfly: Appears at an uptrend’s peak, with D above X, triggering a sell.

• Fibonacci Ratios:

  • B retraces ~78.6% of XA.

  • BC retraces 38.2–88.6% of XA.

  • CD extends 127–161.8% of XA, with D beyond X.

The EA scans pivots (highs/lows) over a 5-candle window, validates ratios with 10% tolerance, and draws triangles (blue for bullish, red for bearish), trendlines, and dotted lines for entry (at D), three take-profit levels (TP1, TP2, TP3 at C), and a stop loss (3x TP2 distance). Trades (0.01 lots) execute on the next candle if no positions are open, ensuring confirmation. It’s like finding a glowing X on the map and digging for Fibonacci gold.

Code Implementation

Let’s embark on the MQL5 code like treasure hunters charting a map, unfolding the logic as a seamless expedition. Our journey starts with setting up the EA, moves to defining visualization tools, scans for pivots, validates Butterfly patterns, draws them, and ends with trading. Each function builds on the last, with transitions that keep the narrative flowing like a river to treasure. We’ll explain every major function in detail, quoting variables (e.g., "pivots") and functions (e.g., "OnInit()") for clarity, keeping it beginner-friendly with a treasure-hunting theme.

Charting the Map: Header, Inputs, and Standard Functions

Our quest begins by unrolling the map, preparing the EA to hunt for patterns.

//+------------------------------------------------------------------+
//|                                Butterfly Harmonic Pattern EA.mq5 |
//|                        Copyright 2025, Allan Munene Mutiiria      |
//|                            https://t.me/Forex_Algo_Trader         |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Allan Munene Mutiiria"
#property link      "https://t.me/Forex_Algo_Trader"
#property version   "1.00"

#include <Trade/Trade.mqh>
CTrade obj_Trade;

input int PivotLeft = 5;
input int PivotRight = 5;
input double Tolerance = 0.10;
input double LotSize = 0.01;
input bool AllowTrading = true;

struct Pivot{
   datetime time;
   double price;
   bool isHigh;
};

Pivot pivots[];

int g_patternFormationBar = -1;
datetime g_lockedPatternX = 0;

int OnInit(){
   return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason){
}

The header declares the EA as “Butterfly Harmonic Pattern EA,” crafted by Allan in 2025, with a link to your Telegram channel and version 1.00, setting the map’s borders.

• Inputs: Define user-configurable settings: "PivotLeft" and "PivotRight" (5 candles for pivot scanning), "Tolerance" (0.1 for Fibonacci flexibility), "LotSize" (0.01), and "AllowTrading" (true to enable trades), like a map’s legend.

• Struct: The "Pivot" struct holds "time", "price", and "isHigh" for pivot points, like marking X’s on the map.

• Globals: "pivots[]" stores pivot data, "g_patternFormationBar" (-1) tracks pattern formation, and "g_lockedPatternX" (0) locks the X point to prevent repainting.

• "OnInit()": The EA’s starting point, called when attached to a chart. It returns INIT_SUCCEEDED, signaling a smooth launch, as no setup is needed, like unrolling a pristine map.

• "OnDeinit()": The cleanup function, called when removed. It’s empty, like leaving the map unmarred, as no resources need freeing.

These elements prepare the EA to chart the market’s Fibonacci paths.

Crafting the Tools: Visualization Functions

Before hunting, we craft tools to draw the map’s patterns, like a cartographer’s quill.

void DrawTriangle(string name, datetime t1,double p1, datetime t2, double p2, datetime t3, double p3, color cl, int width, bool fill, bool back){
   if (ObjectCreate(0,name,OBJ_TRIANGLE,0,t1,p1,t2,p2,t3,p3)){
      ObjectSetInteger(0,name,OBJPROP_COLOR,cl);
      ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
      ObjectSetInteger(0,name,OBJPROP_WIDTH,width);
      ObjectSetInteger(0,name,OBJPROP_FILL,fill);
      ObjectSetInteger(0,name,OBJPROP_BACK,back);
      ChartRedraw();
   }
}
void DrawTrendLine(string name, datetime t1, double p1, datetime t2, double p2, color cl, int width, int style){
   if (ObjectCreate(0,name,OBJ_TREND,0,t1,p1,t2,p2)){
      ObjectSetInteger(0,name,OBJPROP_COLOR,cl);
      ObjectSetInteger(0,name,OBJPROP_STYLE,style);
      ObjectSetInteger(0,name,OBJPROP_WIDTH,width);
      ChartRedraw();
   }
}
void DrawDottedLine(string name, datetime t1, double p, datetime t2, color lineColor){
   if (ObjectCreate(0,name,OBJ_TREND,0,t1,p,t2,p)){
      ObjectSetInteger(0,name,OBJPROP_COLOR,lineColor);
      ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
      ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
      ChartRedraw();
   }
}
void DrawTextEx(string name,string text, datetime t, double p, color cl, int fontSize, bool isHigh){
   if (ObjectCreate(0,name,OBJ_TEXT,0,t,p)){
      ObjectSetString(0,name,OBJPROP_TEXT,text);
      ObjectSetInteger(0,name,OBJPROP_COLOR,cl);
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,fontSize);
      ObjectSetString(0,name,OBJPROP_FONT,"Arial Bold");
      if (isHigh)
         ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
      else
         ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_TOP);
      ObjectSetInteger(0,name,OBJPROP_ALIGN,ALIGN_CENTER);
      ChartRedraw();
   }
}

These functions craft the map’s visuals:

• "DrawTriangle()": Draws a triangle ("OBJ_TRIANGLE") connecting points ("t1,p1", "t2,p2", "t3,p3") with color "cl" (blue/red), width, fill, and background settings, like sketching a pattern’s outline.

• "DrawTrendLine()": Draws a trendline ("OBJ_TREND") from ("t1,p1") to ("t2,p2") with color, width, and style (e.g., "STYLE_SOLID"), like tracing Fibonacci paths.

• "DrawDottedLine()": Draws a dotted horizontal line ("OBJ_TREND") at price "p", like marking entry/TP levels.

• "DrawTextEx()": Places text ("OBJ_TEXT") at "t,p" with label "text", color, font size, and anchor (top/bottom based on "isHigh"), like labeling map points.

• "ObjectCreate()": Creates graphical objects, returning true if successful.

• "ObjectSetInteger()", "ObjectSetString()": Set object properties (e.g., "OBJPROP_COLOR", "OBJPROP_TEXT").

• "ChartRedraw()": Refreshes the chart to display objects, like unveiling the map.

These tools prepare the EA to draw patterns, setting the stage for the hunt.

Scanning the Terrain: OnTick (Pivot Detection)

With tools ready, we scan the market for pivots—the map’s peaks and valleys—using the first part of "OnTick()".

void OnTick(){
   static datetime lastBarTime = 0;
   datetime currentBarTime = iTime(_Symbol,_Period,1);
   if (currentBarTime == lastBarTime)
      return;
   lastBarTime = currentBarTime;
   
   ArrayResize(pivots, 0);
   
   int barsCount = Bars(_Symbol,_Period);
   
   int start = PivotLeft;
   int end = barsCount - PivotRight;
   
   for (int i=end-1; i>=start; i--){
      bool isPivotHigh = true;
      bool isPivotLow = true;
      
      double currentHigh = iHigh(_Symbol,_Period,i);
      double currentLow = iLow(_Symbol,_Period,i);
      
      for (int j=i-PivotLeft; j <= i+PivotRight; j++){
         if (j < 0 || j >= barsCount)
            continue;
         if (j==i)
            continue;
         if (iHigh(_Symbol,_Period,j) > currentHigh)
            isPivotHigh = false;
         if (iLow(_Symbol,_Period,j) < currentLow)
            isPivotLow = false;
      }
      if (isPivotHigh || isPivotLow){
         Pivot p;
         p.time = iTime(_Symbol,_Period,i);
         p.price = isPivotHigh ? currentHigh : currentLow;
         p.isHigh = isPivotHigh;
         
         int size = ArraySize(pivots);
         ArrayResize(pivots,size+1);
         pivots[size] = p;
      }
   }
   // ... (rest of OnTick follows)
}

The "OnTick()" function is the EA’s expedition, running on every price tick to hunt patterns. This segment scans pivots:

• "iTime()": Fetches the previous candle’s timestamp (index 1), stored in "currentBarTime". If it matches "lastBarTime", the EA skips to avoid reprocessing, updating "lastBarTime" on new candles, like checking the map at dawn.

• "ArrayResize()": Resets "pivots[]" to zero, then resizes it to store new pivots, like clearing old markings.

• "Bars()": Returns the total bar count ("barsCount"), setting the scan range.

• "iHigh()", "iLow()": Fetch high ("currentHigh") and low ("currentLow") prices for candle i.

• Pivot Logic: Loops from "end-1" (bars minus "PivotRight") to "start" ("PivotLeft"), checking if candle i is a pivot by comparing its high/low to "PivotLeft" and "PivotRight" neighbors. If no higher high or lower low exists, "isPivotHigh" or "isPivotLow" stays true, storing the pivot in "pivots[]" with "time", "price", and "isHigh".

• "ArraySize()": Returns the current size of "pivots[]".

This scans the terrain, marking peaks and valleys like X’s on the map.

Uncovering the Pattern: OnTick (Butterfly Detection)

With pivots marked, the EA hunts for Butterfly patterns, validating Fibonacci ratios.

// Inside OnTick()
int pivotCount = ArraySize(pivots);
if (pivotCount < 5){
   g_patternFormationBar = -1;
   g_lockedPatternX = 0;
   return;
}

Pivot X = pivots[pivotCount -5];
Pivot A = pivots[pivotCount -4];
Pivot B = pivots[pivotCount -3];
Pivot C = pivots[pivotCount -2];
Pivot D = pivots[pivotCount -1];

bool patternFound = false;

if (X.isHigh && (!A.isHigh) && B.isHigh && (!C.isHigh) && D.isHigh){
   double diff = X.price - A.price;
   if (diff > 0){
      double idealB = A.price + 0.786*diff;
      if (MathAbs(B.price - idealB) <= Tolerance*diff){
         double BC = B.price - C.price;
         if ((BC >= 0.382*diff) && (BC <= 0.886*diff)){
            double CD = D.price - C.price;
            if ((CD >= 1.27*diff) && (CD <= 1.618*diff) && (D.price > X.price))
               patternFound = true;
         }
      }
   }
}
if ((!X.isHigh) && A.isHigh && (!B.isHigh) && C.isHigh && (!D.isHigh)){
   double diff = A.price - X.price;
   if (diff > 0){
      double idealB = A.price - 0.786*diff;
      if (MathAbs(B.price - idealB) <= Tolerance*diff){
         double BC = C.price - B.price;
         if ((BC >= 0.382*diff) && (BC <= 0.886*diff)){
            double CD = C.price - D.price;
            if ((CD >= 1.27*diff) && (CD <= 1.618*diff) && (D.price < X.price))
               patternFound = true;
         }
      }
   }
}

string patternType = "";
if (patternFound){
   if (D.price > X.price)
      patternType = "Bearish";
   else if (D.price < X.price)
      patternType = "Bullish";
}

This segment hunts the Butterfly pattern:

• Pivot Check: If fewer than 5 pivots exist, resets "g_patternFormationBar" and "g_lockedPatternX", exiting, like abandoning a faded map.

• Pivot Assignment: Assigns the last five pivots to "X", "A", "B", "C", "D".

• Bearish Butterfly: Checks if X, B, D are highs, A, C are lows, with Fibonacci ratios:

  • XA retraces to B at ~78.6% ("idealB"), within "Tolerance".

  • BC retraces 38.2–88.6% of XA.

  • CD extends 127–161.8% of XA, with D above X.

• Bullish Butterfly: Checks if X, B, D are lows, A, C are highs, with similar ratios, D below X.

• "MathAbs()": Calculates absolute differences for ratio checks.

• Pattern Type: Sets "patternType" to “Bullish” or “Bearish” if "patternFound".

This uncovers the treasure, validating the Butterfly pattern like finding the map’s X.

Drawing the Treasure: OnTick (Visualization)

With the pattern found, the EA draws it, like inking the map with triangles and lines.

// Inside OnTick()
if (patternFound){
   Print(patternType," Butterfly pattern detected at ",TimeToString(D.time,TIME_MINUTES),", X = ",X.price);
   
   string signalPrefix = "BF_"+IntegerToString(X.time);
   color triangleColor = (patternType == "Bullish") ? clrBlue : clrRed;
   
   DrawTriangle(signalPrefix+"_Triangle1",X.time,X.price,A.time,A.price,B.time,B.price,triangleColor,2,true,true);
   DrawTriangle(signalPrefix+"_Triangle2",B.time,B.price,C.time,C.price,D.time,D.price,triangleColor,2,true,true);
   
   DrawTrendLine(signalPrefix+"_TL_XA",X.time,X.price,A.time,A.price,clrBlack,2,STYLE_SOLID);
   DrawTrendLine(signalPrefix+"_TL_AB",A.time,A.price,B.time,B.price,clrBlack,2,STYLE_SOLID);
   DrawTrendLine(signalPrefix+"_TL_BC",B.time,B.price,C.time,C.price,clrBlack,2,STYLE_SOLID);
   DrawTrendLine(signalPrefix+"_TL_CD",C.time,C.price,D.time,D.price,clrBlack,2,STYLE_SOLID);
   DrawTrendLine(signalPrefix+"_TL_XB",X.time,X.price,B.time,B.price,clrBlack,2,STYLE_SOLID);
   DrawTrendLine(signalPrefix+"_TL_BD",B.time,B.price,D.time,D.price,clrBlack,2,STYLE_SOLID);
   
   double point = SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   
   double offset = 15*point;
   
   double textY_X = (X.isHigh ? X.price+offset : X.price-offset);
   double textY_A = (A.isHigh ? A.price+offset : A.price-offset);
   double textY_B = (B.isHigh ? B.price+offset : B.price-offset);
   double textY_C = (C.isHigh ? C.price+offset : C.price-offset);
   double textY_D = (D.isHigh ? D.price+offset : D.price-offset);
   
   DrawTextEx(signalPrefix+"_Text_X","X",X.time,textY_X,clrBlack,11,X.isHigh);
   DrawTextEx(signalPrefix+"_Text_A","A",A.time,textY_A,clrBlack,11,A.isHigh);
   DrawTextEx(signalPrefix+"_Text_B","B",B.time,textY_B,clrBlack,11,B.isHigh);
   DrawTextEx(signalPrefix+"_Text_C","C",C.time,textY_C,clrBlack,11,C.isHigh);
   DrawTextEx(signalPrefix+"_Text_D","D",D.time,textY_D,clrBlack,11,D.isHigh);
   
   datetime centralTime = (X.time+B.time)/2;
   double centralPrice = D.price;
   
   if (ObjectCreate(0,signalPrefix+"_Text_Center",OBJ_TEXT,0,centralTime,centralPrice)){
      ObjectSetString(0,signalPrefix+"_Text_Center",OBJPROP_TEXT,(patternType=="Bullish" ? "Bullish Butterfly" : "Bearish Butterfly"));
      ObjectSetInteger(0,signalPrefix+"_Text_Center",OBJPROP_COLOR,clrBlack);
      ObjectSetInteger(0,signalPrefix+"_Text_Center",OBJPROP_FONTSIZE,11);
      ObjectSetString(0,signalPrefix+"_Text_Center",OBJPROP_FONT,"Arial Bold");
      ObjectSetInteger(0,signalPrefix+"_Text_Center",OBJPROP_ALIGN,ALIGN_CENTER);
   }
   
   datetime lineStart = D.time;
   datetime lineEnd = D.time + PeriodSeconds(_Period)*2;
   
   double entryPricelevel, TP1Level,TP2Level,TP3Level, tradeDiff;
   
   if (patternType == "Bullish"){
      entryPricelevel = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      TP3Level = C.price;
      tradeDiff = TP3Level-entryPricelevel;
      TP1Level = entryPricelevel+tradeDiff/3;
      TP2Level = entryPricelevel+2*tradeDiff/3;
   }
   else {
      entryPricelevel = SymbolInfoDouble(_Symbol,SYMBOL_BID);
      TP3Level = C.price;
      tradeDiff = entryPricelevel-TP3Level;
      TP1Level = entryPricelevel-tradeDiff/3;
      TP2Level = entryPricelevel-2*tradeDiff/3;
   }
   
   DrawDottedLine(signalPrefix+"_EntryLine",lineStart,entryPricelevel,lineEnd,clrMagenta);
   DrawDottedLine(signalPrefix+"_TP1Line",lineStart,TP1Level,lineEnd,clrForestGreen);
   DrawDottedLine(signalPrefix+"_TP2Line",lineStart,TP2Level,lineEnd,clrGreen);
   DrawDottedLine(signalPrefix+"_TP3Line",lineStart,TP3Level,lineEnd,clrDarkGreen);
   
   datetime labelTime = lineEnd+PeriodSeconds(_Period)/2;
   
   string entryLabel = (patternType == "Bullish") ? "BUY (" : "SELL (";
   entryLabel+=DoubleToString(entryPricelevel,_Digits)+")";
   DrawTextEx(signalPrefix+"_EntryLabel",entryLabel,labelTime,entryPricelevel,clrMagenta,11,true);
   
   string tp1label = "TP1 ("+DoubleToString(TP1Level,_Digits)+")";
   DrawTextEx(signalPrefix+"_TP1Label",tp1label,labelTime,TP1Level,clrForestGreen,11,true);
   
   string tp2label = "TP2 ("+DoubleToString(TP2Level,_Digits)+")";
   DrawTextEx(signalPrefix+"_TP2Label",tp2label,labelTime,TP2Level,clrGreen,11,true);

   string tp3label = "TP3 ("+DoubleToString(TP3Level,_Digits)+")";
   DrawTextEx(signalPrefix+"_TP3Label",tp3label,labelTime,TP3Level,clrDarkGreen,11,true);
}

This segment draws the pattern:

• "Print()", "TimeToString()": Log the pattern detection with D’s timestamp.

• "IntegerToString()": Creates a unique "signalPrefix" for object names.

• Drawing: Calls "DrawTriangle()" for XA-B and BC-D, "DrawTrendLine()" for XA, AB, BC, CD, XB, BD, and "DrawTextEx()" for X, A, B, C, D labels and a central “Bullish/Bearish Butterfly” label.

• "SymbolInfoDouble()": Fetches "SYMBOL_POINT" for offset calculations.

• Levels: Sets "entryPricelevel" (ask/bid), "TP3Level" (C’s price), "TP1Level", "TP2Level" (1/3, 2/3 to TP3), and draws dotted lines with labels via "DrawDottedLine()", "DrawTextEx()".

• "PeriodSeconds()": Calculates timeframe seconds for line extensions.

This inks the map, drawing the Butterfly pattern like a glowing treasure path.

Digging for Gold: OnTick (Trade Execution)

With the pattern drawn, the EA executes trades, unearthing the treasure.

// Inside OnTick()
int currentBarIndex = Bars(_Symbol,_Period) - 1;
if (g_patternFormationBar == -1){
   g_patternFormationBar = currentBarIndex;
   g_lockedPatternX = X.time;
   Print("Pattern detected on bar ",currentBarIndex,". Waiting for confirmation on the next bar.");
   return;
}
if (currentBarIndex == g_patternFormationBar){
   Print("Pattern is repainting; still on locked formation bar, ",currentBarIndex,". No trade yet.");
   return;
}
if (currentBarIndex > g_patternFormationBar){
   if (g_lockedPatternX == X.time){
      Print("Confirmed pattern (Locked on bar ",g_patternFormationBar,"). Opening trade on bar ",currentBarIndex);
      g_patternFormationBar = currentBarIndex;
      if (AllowTrading && PositionsTotal() <= 0){
         double entryPriceTrade = 0, stoploss = 0, takeprofit = 0;
         point = SymbolInfoDouble(_Symbol,SYMBOL_POINT);
         bool tradeResult = false;
         
         if (patternType == "Bullish"){
            entryPriceTrade = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
            double diffTrade = TP2Level - entryPriceTrade;
            stoploss = entryPriceTrade - diffTrade*3;
            takeprofit = TP2Level;
            tradeResult = obj_Trade.Buy(LotSize,_Symbol,entryPriceTrade,stoploss,takeprofit,"Butterfly Signal");
            if (tradeResult)
               Print("Buy order opened successfully.");
            else
               Print("Buy order failed: ",obj_Trade.ResultRetcodeDescription());
         }
         else if (patternType == "Bearish"){
            entryPriceTrade = SymbolInfoDouble(_Symbol,SYMBOL_BID);
            double diffTrade = entryPriceTrade - TP2Level;
            stoploss = entryPriceTrade + diffTrade*3;
            takeprofit = TP2Level;
            tradeResult = obj_Trade.Sell(LotSize,_Symbol,entryPriceTrade,stoploss,takeprofit,"Butterfly Signal");
            if (tradeResult)
               Print("Sell order opened successfully.");
            else
               Print("Sell order failed: ",obj_Trade.ResultRetcodeDescription());
         }
      }
      else {
         Print("A position is already open for ",_Symbol,". No new trade executed.");
      }
   }
   else {
      g_patternFormationBar = currentBarIndex;
      g_lockedPatternX = X.time;
      Print("Pattern has changed; updating lock on bar ",currentBarIndex,". Waiting for confirmation.");
      return;
   }
}
else {
   g_patternFormationBar = -1;
   g_lockedPatternX = 0;
}

This segment digs for gold:

• "Bars()": Gets the current bar index ("currentBarIndex").

• Confirmation Logic: If no pattern is locked ("g_patternFormationBar == -1"), sets it to "currentBarIndex" and locks "g_lockedPatternX". If on the same bar, waits to avoid repainting. If on the next bar with the same X, confirms the pattern and trades.

• "PositionsTotal()": Checks for open positions, ensuring none exist.

• "Buy()", "Sell()": Open trades with "LotSize" (0.01), entry ("SYMBOL_ASK"/"SYMBOL_BID"), stop loss (3x TP2 distance), and take profit (TP2), logging results with "Print()", "ResultRetcodeDescription()".

This unearths the treasure, executing trades like digging at the map’s X. See below.

Putting It All Together

To launch this EA:

1. Open MetaEditor in MetaTrader 5.

2. Paste the code into a new Expert Advisor file.

3. Compile (F5). If errors appear, check your copy-paste.

4. Drag the EA onto your chart, set inputs (e.g., "LotSize", "AllowTrading"), enable AutoTrading, and watch for blue/red triangles signaling trades.

5. Trade smart—don’t bet your map on one pattern!

Conclusion

The Butterfly Harmonic Pattern EA is your cartographer, charting Fibonacci reversals with triangles, lines, and automated trades. We’ve explored its MQL5 code with clear, detailed explanations, so you understand every step like a seasoned treasure hunter. Now you’re set to automate your trades and unearth market riches. Want to see it in action? Check our video guide on the website!

Disclaimer: Trading’s like hunting treasure in a storm—exciting but risky. Losses can exceed deposits. Test on a demo account before going live.