Breakout Trading EA Development

Breakouts offer explosive profit potential. Here's how to build EAs that capture them while filtering fakes.

Breakout Types

1. Range Breakouts

• Price consolidates in range
• Breaks above resistance or below support
• Volume often confirms

2. Pattern Breakouts

• Triangles, rectangles, flags
• Clear entry levels
• Measured move targets

3. News Breakouts

• Economic releases
• Central bank decisions
• High volatility, wide spreads

Range Detection

Identifying Consolidation:

class CRangeDetector {
private:
    int m_min_bars;           // Minimum bars for valid range
    double m_max_range_pips;  // Maximum range size
    double m_range_high;
    double m_range_low;
    bool m_range_detected;
    
public:
    CRangeDetector(int min_bars = 20, double max_pips = 50) {
        m_min_bars = min_bars;
        m_max_range_pips = max_pips;
    }
    
    bool DetectRange(string symbol, ENUM_TIMEFRAMES tf) {
        MqlRates rates[];
        int copied = CopyRates(symbol, tf, 0, m_min_bars + 10, rates);
        if(copied < m_min_bars) return false;
        
        // Find high and low of recent bars
        double high = rates[0].high;
        double low = rates[0].low;
        
        for(int i = 1; i < m_min_bars; i++) {
            if(rates[i].high > high) high = rates[i].high;
            if(rates[i].low < low) low = rates[i].low;
        }
        
        double range_pips = (high - low) / _Point / 10;
        
        // Check if range is tight enough
        if(range_pips <= m_max_range_pips) {
            // Verify price is ranging (not trending)
            if(IsRanging(rates, m_min_bars)) {
                m_range_high = high;
                m_range_low = low;
                m_range_detected = true;
                return true;
            }
        }
        
        m_range_detected = false;
        return false;
    }
    
    bool IsRanging(MqlRates &rates[], int bars) {
        // Count touches of high and low zones
        int high_touches = 0;
        int low_touches = 0;
        double zone_size = (m_range_high - m_range_low) * 0.1;  // 10% zones
        
        for(int i = 0; i < bars; i++) {
            if(rates[i].high >= m_range_high - zone_size) high_touches++;
            if(rates[i].low <= m_range_low + zone_size) low_touches++;
        }
        
        // Valid range has multiple touches on both sides
        return high_touches >= 2 && low_touches >= 2;
    }
    
    double GetRangeHigh() { return m_range_high; }
    double GetRangeLow() { return m_range_low; }
    bool IsRangeDetected() { return m_range_detected; }
};

Breakout Confirmation

Multi-Factor Confirmation:

class CBreakoutConfirmation {
private:
    double m_min_breakout_pips;
    double m_min_volume_ratio;
    int m_candle_close_required;
    
public:
    struct BreakoutSignal {
        bool valid;
        ENUM_ORDER_TYPE direction;
        double entry_price;
        double stop_loss;
        double take_profit;
        double strength;  // 0-1
    };
    
    BreakoutSignal CheckBreakout(double range_high, double range_low, string symbol) {
        BreakoutSignal signal;
        signal.valid = false;
        
        double current_price = SymbolInfoDouble(symbol, SYMBOL_BID);
        double atr = GetATR(symbol, PERIOD_CURRENT, 14);
        
        // Check for bullish breakout
        if(current_price > range_high) {
            double breakout_distance = (current_price - range_high) / _Point;
            
            if(ConfirmBreakout(symbol, range_high, true, breakout_distance)) {
                signal.valid = true;
                signal.direction = ORDER_TYPE_BUY;
                signal.entry_price = current_price;
                signal.stop_loss = range_low - atr;
                signal.take_profit = current_price + (range_high - range_low) * 1.5;
                signal.strength = CalculateBreakoutStrength(symbol, true);
            }
        }
        
        // Check for bearish breakout
        if(current_price < range_low) {
            double breakout_distance = (range_low - current_price) / _Point;
            
            if(ConfirmBreakout(symbol, range_low, false, breakout_distance)) {
                signal.valid = true;
                signal.direction = ORDER_TYPE_SELL;
                signal.entry_price = current_price;
                signal.stop_loss = range_high + atr;
                signal.take_profit = current_price - (range_high - range_low) * 1.5;
                signal.strength = CalculateBreakoutStrength(symbol, false);
            }
        }
        
        return signal;
    }
    
    bool ConfirmBreakout(string symbol, double level, bool bullish, double distance) {
        // 1. Minimum distance
        if(distance < m_min_breakout_pips * 10) return false;
        
        // 2. Candle close confirmation
        if(m_candle_close_required > 0) {
            if(!HasCandleClosedBeyond(symbol, level, bullish, m_candle_close_required)) {
                return false;
            }
        }
        
        // 3. Volume confirmation
        if(!HasVolumeSpike(symbol, m_min_volume_ratio)) {
            return false;
        }
        
        // 4. Momentum confirmation
        if(!HasMomentum(symbol, bullish)) {
            return false;
        }
        
        return true;
    }
    
    bool HasCandleClosedBeyond(string symbol, double level, bool bullish, int candles) {
        MqlRates rates[];
        CopyRates(symbol, PERIOD_CURRENT, 1, candles, rates);
        
        for(int i = 0; i < candles; i++) {
            if(bullish && rates[i].close <= level) return false;
            if(!bullish && rates[i].close >= level) return false;
        }
        
        return true;
    }
    
    bool HasVolumeSpike(string symbol, double ratio) {
        long current_volume = iVolume(symbol, PERIOD_CURRENT, 0);
        long avg_volume = 0;
        
        for(int i = 1; i <= 20; i++) {
            avg_volume += iVolume(symbol, PERIOD_CURRENT, i);
        }
        avg_volume /= 20;
        
        return current_volume > avg_volume * ratio;
    }
    
    bool HasMomentum(string symbol, bool bullish) {
        double rsi = iRSI(symbol, PERIOD_CURRENT, 14, PRICE_CLOSE);
        CopyBuffer(rsi, 0, 0, 1, rsi_buffer);
        
        if(bullish && rsi_buffer[0] > 50) return true;
        if(!bullish && rsi_buffer[0] < 50) return true;
        
        return false;
    }
    
    double CalculateBreakoutStrength(string symbol, bool bullish) {
        double strength = 0;
        
        // Volume component (0-0.33)
        long current_vol = iVolume(symbol, PERIOD_CURRENT, 0);
        long avg_vol = GetAverageVolume(symbol, 20);
        strength += MathMin(0.33, (double)current_vol / avg_vol / 10);
        
        // Momentum component (0-0.33)
        // ... RSI strength calculation
        
        // Price action component (0-0.34)
        // ... Candle body analysis
        
        return MathMin(1.0, strength);
    }
};

False Breakout Filtering

Identifying Fakeouts:

class CFakeoutFilter {
private:
    int m_confirmation_bars;
    double m_max_wick_ratio;
    
public:
    bool IsPotentialFakeout(string symbol, double breakout_level, bool bullish) {
        MqlRates rates[];
        CopyRates(symbol, PERIOD_CURRENT, 0, 5, rates);
        
        // Check 1: Long wick reversal
        double body = MathAbs(rates[0].close - rates[0].open);
        double wick = bullish ? 
            rates[0].high - MathMax(rates[0].close, rates[0].open) :
            MathMin(rates[0].close, rates[0].open) - rates[0].low;
        
        if(body > 0 && wick / body > m_max_wick_ratio) {
            Print("Fakeout warning: Long wick detected");
            return true;
        }
        
        // Check 2: Divergence with oscillator
        if(HasDivergence(symbol, bullish)) {
            Print("Fakeout warning: RSI divergence");
            return true;
        }
        
        // Check 3: Counter-trend on higher timeframe
        if(IsCounterTrend(symbol, bullish)) {
            Print("Fakeout warning: Against higher timeframe trend");
            return true;
        }
        
        return false;
    }
    
    bool HasDivergence(string symbol, bool bullish) {
        // Check if price is making new highs but RSI isn't
        // Implementation here...
        return false;
    }
    
    bool IsCounterTrend(string symbol, bool bullish) {
        // Check trend on H4 if we're on H1
        ENUM_TIMEFRAMES htf = GetHigherTimeframe(PERIOD_CURRENT);
        double ma = iMA(symbol, htf, 50, 0, MODE_SMA, PRICE_CLOSE);
        double price = SymbolInfoDouble(symbol, SYMBOL_BID);
        
        if(bullish && price < ma) return true;  // Bullish breakout below MA
        if(!bullish && price > ma) return true;  // Bearish breakout above MA
        
        return false;
    }
};

Breakout Entry Strategies

Strategy 1: Immediate Entry

void EnterBreakout(BreakoutSignal &signal) {
    double lots = CalculateLots(signal.stop_loss, signal.entry_price);
    
    MqlTradeRequest request = {};
    request.action = TRADE_ACTION_DEAL;
    request.symbol = _Symbol;
    request.volume = lots;
    request.type = signal.direction;
    request.price = signal.entry_price;
    request.sl = signal.stop_loss;
    request.tp = signal.take_profit;
    
    // Execute immediately
    OrderSend(request, result);
}

Strategy 2: Retest Entry

class CRetestEntry {
private:
    double m_breakout_level;
    bool m_waiting_for_retest;
    datetime m_breakout_time;
    int m_max_wait_bars;
    
public:
    void SetupRetestEntry(double level, bool bullish) {
        m_breakout_level = level;
        m_waiting_for_retest = true;
        m_breakout_time = TimeCurrent();
    }
    
    bool CheckRetest(bool bullish) {
        if(!m_waiting_for_retest) return false;
        
        // Check if we've waited too long
        if(iBarShift(_Symbol, PERIOD_CURRENT, m_breakout_time) > m_max_wait_bars) {
            m_waiting_for_retest = false;
            return false;
        }
        
        double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
        
        if(bullish) {
            // Price pulled back to resistance-turned-support
            if(price <= m_breakout_level * 1.001 && price >= m_breakout_level * 0.999) {
                // Look for bullish rejection
                if(HasBullishRejection()) {
                    m_waiting_for_retest = false;
                    return true;
                }
            }
        } else {
            // Price pulled back to support-turned-resistance
            if(price >= m_breakout_level * 0.999 && price <= m_breakout_level * 1.001) {
                if(HasBearishRejection()) {
                    m_waiting_for_retest = false;
                    return true;
                }
            }
        }
        
        return false;
    }
};

Complete Breakout EA Logic

// Main EA components
CRangeDetector* rangeDetector;
CBreakoutConfirmation* breakoutConfirm;
CFakeoutFilter* fakeoutFilter;
CRetestEntry* retestEntry;

void OnTick() {
    // 1. Detect range
    if(rangeDetector.DetectRange(_Symbol, PERIOD_CURRENT)) {
        double high = rangeDetector.GetRangeHigh();
        double low = rangeDetector.GetRangeLow();
        
        // 2. Check for breakout
        BreakoutSignal signal = breakoutConfirm.CheckBreakout(high, low, _Symbol);
        
        if(signal.valid) {
            // 3. Filter fakeouts
            if(!fakeoutFilter.IsPotentialFakeout(_Symbol, 
                signal.direction == ORDER_TYPE_BUY ? high : low,
                signal.direction == ORDER_TYPE_BUY)) {
                
                // 4. Enter trade
                if(signal.strength > 0.6) {
                    EnterBreakout(signal);
                } else {
                    // Wait for retest on weaker breakouts
                    retestEntry.SetupRetestEntry(
                        signal.direction == ORDER_TYPE_BUY ? high : low,
                        signal.direction == ORDER_TYPE_BUY
                    );
                }
            }
        }
    }
    
    // Check for retest entries
    if(retestEntry.CheckRetest(pending_direction == ORDER_TYPE_BUY)) {
        ExecuteRetestEntry();
    }
}

Our Breakout EA Services

Viprasol develops sophisticated breakout EAs with:

• Multi-timeframe range detection
• Advanced fakeout filtering
• Volume confirmation
• Retest entry options

Need a breakout trading EA? Contact us for custom development.