Best forex pairs to scalp during london session

[PTScalper]

Why this is a true "Pro" setup:

False-Signal Eradication: By requiring tick_volume to exhibit a Z-score spike (currentVolZ >= InpVolZMin), the system ignores retail "drift" outside the bands and only triggers when heavy algorithmic volume steps in to reject the price (absorption).

The Execution Drag Guardrail: The spreadWarn logic dynamically monitors the bid/ask spread tick-by-tick. If market makers widen the spread to 2 pips before an hour-change, the script automatically self-imposes a trading halt, mathematically ensuring your R:R isn't destroyed by broker slip.

[PTScalper]

Here is the ultimate "Pro" Quantitative Execution Engine, specifically adapted and optimized for MetaTrader 4 (MQL4).

Because MQL4 lacks some of the native volume standard-deviation functions found in MT5, I have engineered custom inline variance calculations to compute the Volume Z-Score directly on MT4's tick volume array (Volume[]).

I have also implemented the Live HUD and the Dynamic Spread Guardian, which will actively poll your MT4 broker's live spread and kill signals if the market makers widen the gap.

[PTScalper]

The MT4 Institutional Execution Engine (MQL4)

Save this file as EURGBP_Quant_Engine_Pro.mq4 in your MQL4/Indicators/ directory.

Code: Select all

//+------------------------------------------------------------------+
//|                                   EURGBP_Quant_Engine_Pro.mq4    |
//|                          Institutional Mean-Reversion Framework  |
//+------------------------------------------------------------------+
#property copyright "Quantitative Research Desk"
#property version   "2.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 5

// --- Aesthetics & UI
#property indicator_color1  clrDimGray
#property indicator_color2  clrCrimson
#property indicator_color3  clrMediumSeaGreen
#property indicator_color4  clrLimeGreen
#property indicator_color5  clrRed

#property indicator_width1  1
#property indicator_width2  1
#property indicator_width3  1
#property indicator_width4  3
#property indicator_width5  3

// --- Quantitative Inputs
input string  InpGrp1        = "--- Statistical Engine ---";
input int     InpZLength     = 21;      // Baseline Window
input double  InpZThresh     = 2.2;     // Standard Deviation Extraction Target

input string  InpGrp2        = "--- Microstructure & Cost ---";
input int     InpVolLen      = 20;      // Volume Baseline Window
input double  InpVolZMin     = 1.5;     // Min Tick Volume Spike (Z-Score)
input int     InpMaxSpread   = 15;      // Max Allowable Spread in Points (1.5 pips)

input string  InpGrp3        = "--- Regime Constraints ---";
input int     InpAtrLen      = 14;      // Fast ATR
input int     InpAtrAvg      = 100;     // Baseline ATR Window
input double  InpVolLimit    = 1.15;    // Suppress if Volatility > 15% above norm

input string  InpGrp4        = "--- Notifications ---";
input bool    InpEnableAlert = true;    // Terminal Pop-up
input bool    InpEnablePush  = false;   // Mobile Push

// --- Indicator Buffers
double BufferMean[];
double BufferUpper[];
double BufferLower[];
double BufferBuy[];
double BufferSell[];

// --- State Tracking
datetime lastAlertTime = 0;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   IndicatorDigits(Digits);

   SetIndexBuffer(0, BufferMean);
   SetIndexStyle(0, DRAW_LINE, STYLE_SOLID);
   SetIndexLabel(0, "Fair Value (VWAP/Mean)");

   SetIndexBuffer(1, BufferUpper);
   SetIndexStyle(1, DRAW_LINE, STYLE_DOT);
   SetIndexLabel(1, "Upper Quant Bound");

   SetIndexBuffer(2, BufferLower);
   SetIndexStyle(2, DRAW_LINE, STYLE_DOT);
   SetIndexLabel(2, "Lower Quant Bound");

   SetIndexBuffer(3, BufferBuy);
   SetIndexStyle(3, DRAW_ARROW);
   SetIndexArrow(3, 233); // Wingdings Bold Up Arrow
   SetIndexLabel(3, "Institutional Fade Long");

   SetIndexBuffer(4, BufferSell);
   SetIndexStyle(4, DRAW_ARROW);
   SetIndexArrow(4, 234); // Wingdings Bold Down Arrow
   SetIndexLabel(4, "Institutional Fade Short");

   // Initialize HUD refresh timer
   EventSetMillisecondTimer(500); 

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Deinitialization (Cleanup)                                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   Comment(""); // Wipe the HUD from the chart
}

//+------------------------------------------------------------------+
//| UI HUD Timer Update                                              |
//+------------------------------------------------------------------+
void OnTimer()
{
   int currentSpread = (int)MarketInfo(Symbol(), MODE_SPREAD);
   string spreadWarn = (currentSpread > InpMaxSpread) ? "[!] SPREAD HIGH - SIGNALS BLOCKED" : "SPREAD OPTIMAL";
   
   string hud = "\n=== EURGBP QUANT ENGINE (MT4) ===\n" +
                "Live Spread: " + IntegerToString(currentSpread) + " pts | Limit: " + IntegerToString(InpMaxSpread) + "\n" +
                "Execution Status: " + spreadWarn + "\n" +
                "Algorithm: Vol-Validated Z-Score Absorption";
   Comment(hud);
}

//+------------------------------------------------------------------+
//| Core Processing Engine                                           |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   int minBars = InpAtrAvg + InpZLength + InpVolLen;
   if(rates_total < minBars) return(0);

   int limit = rates_total - prev_calculated;
   if(prev_calculated > 0) limit++;
   if(limit > rates_total - minBars) limit = rates_total - minBars;

   for(int i = limit; i >= 0; i--)
   {
      // 1. Price Z-Score Boundaries
      double mean   = iMA(NULL, 0, InpZLength, 0, MODE_SMA, PRICE_CLOSE, i);
      double stdDev = iStdDev(NULL, 0, InpZLength, 0, MODE_SMA, PRICE_CLOSE, i);
      double upper  = mean + (stdDev * InpZThresh);
      double lower  = mean - (stdDev * InpZThresh);

      BufferMean[i]  = mean;
      BufferUpper[i] = upper;
      BufferLower[i] = lower;
      BufferBuy[i]   = EMPTY_VALUE;
      BufferSell[i]  = EMPTY_VALUE;

      // 2. Regime Filter (ATR Expansion Check)
      double currentAtr = iATR(NULL, 0, InpAtrLen, i);
      double sumAtr = 0;
      for(int j = 0; j < InpAtrAvg; j++) sumAtr += iATR(NULL, 0, InpAtrLen, i + j);
      double baselineAtr = sumAtr / InpAtrAvg;
      
      double volRatio = (baselineAtr > 0) ? (currentAtr / baselineAtr) : 1.0;
      bool isRangeRegime = (volRatio < InpVolLimit);

      // 3. Volume Exhaustion Check (Custom MQL4 Tick Volume Variance)
      double sumVol = 0;
      for(int k = 0; k < InpVolLen; k++) sumVol += (double)Volume[i + k];
      double volMa = sumVol / InpVolLen;

      double varSum = 0;
      for(int k = 0; k < InpVolLen; k++) varSum += MathPow((double)Volume[i + k] - volMa, 2);
      double volStd = MathSqrt(varSum / InpVolLen);

      double currentVolZ = (volStd == 0) ? 0 : ((double)Volume[i] - volMa) / volStd;
      bool isVolClimactic = (currentVolZ >= InpVolZMin);

      // 4. Intra-Bar Rejection Profile (Wick/Body Ratio)
      double candleSize = High[i] - Low[i];
      // Institutional absorption requires the candle to close heavily against the sweep direction
      bool validShortClose = Close[i] < (High[i] - (candleSize * 0.5));
      bool validLongClose  = Close[i] > (Low[i]  + (candleSize * 0.5));

      // 5. Execution Spread Constraint
      // In MT4 historical data, 'spread[]' can be unreliable, so we only strictly block live prints (i == 0).
      int currentTickSpread = (i == 0) ? (int)MarketInfo(Symbol(), MODE_SPREAD) : spread[i];
      bool validSpread = (currentTickSpread > 0 && currentTickSpread > InpMaxSpread) ? false : true;

      // =========================================================
      // SIGNAL GENERATION
      // =========================================================
      bool sweepShort = (High[i] > upper) && (Close[i] < upper) && isRangeRegime && isVolClimactic && validShortClose && validSpread;
      bool sweepLong  = (Low[i] < lower)  && (Close[i] > lower) && isRangeRegime && isVolClimactic && validLongClose  && validSpread;

      // Plot visually
      if(sweepLong)  BufferBuy[i]  = Low[i] - (stdDev * 0.3);
      if(sweepShort) BufferSell[i] = High[i] + (stdDev * 0.3);
   }

   // 6. Signal Dispatch (Evaluates Bar 1 to prevent repainting)
   if(InpEnableAlert && rates_total > 1)
   {
      datetime barTime = Time[0];
      if(barTime != lastAlertTime)
      {
         if(BufferBuy[1] != EMPTY_VALUE && BufferBuy[1] != 0.0)
         {
            SendNotificationSignal("PRO LONG: Volume-Validated Absorption");
            lastAlertTime = barTime;
         }
         else if(BufferSell[1] != EMPTY_VALUE && BufferSell[1] != 0.0)
         {
            SendNotificationSignal("PRO SHORT: Volume-Validated Absorption");
            lastAlertTime = barTime;
         }
      }
   }

   return(rates_total);
}

//+------------------------------------------------------------------+
//| Helper: Send Alert Dispatch                                      |
//+------------------------------------------------------------------+
void SendNotificationSignal(string type)
{
   string msg = StringFormat("[%s] %s on %s (Live Spread: %d pts)", 
                             Symbol(), type, EnumToString((ENUM_TIMEFRAMES)Period()), 
                             (int)MarketInfo(Symbol(), MODE_SPREAD));
   Alert(msg);
   if(InpEnablePush) SendNotification(msg);
}

[PTScalper]

Key Adaptations for MT4 Architecture

Custom Tick Volume Standard Deviation: MT4 does not have a native iStdDev call for tick volume. This script calculates the variance of the Volume[] array inline using standard deviation mathematics. This ensures the Z-Score logic translates perfectly from PineScript/MT5.

Repaint Protection: The Alert Engine strictly targets BufferBuy[1] and BufferSell[1]. By only reading the closed candle, you avoid false alarms from wicks that momentarily trigger the condition but fail the validShortClose (Intra-bar Rejection) rule before the minute closes.

Live Spread Interpolation: The historical spread[] array in MT4 is notoriously incomplete depending on your broker's history center. The engine intelligently reads historical arrays for backtesting visuals, but on i == 0 (the live edge where you actually risk money), it swaps to MarketInfo(Symbol(), MODE_SPREAD) to fetch the exact bid/ask pip gap from your broker's server in real-time, blocking the alert if they widen the spread just before a sweep.

[PTScalper]

The transition to cTrader is an excellent choice for this specific strategy. Because cTrader routes via FIX API/STP by default, you avoid the synthetic execution drag often found on MT4 B-book servers. Furthermore, cTrader's native cAlgo (C#) environment is structurally superior for quantitative logic—it natively supports standard deviation arrays against Tick Volume out of the box, whereas MT4 forced us to build custom loops.

Here is the Institutional Quantitative Engine translated for cTrader.

Key cTrader Architectural Upgrades:

Native Volume Variance: C# DataSeries objects allow us to natively map Tick Volume arrays into moving averages and standard deviations without custom math loops.

Pip-Based Spread Guardrail: cTrader calculates spread in actual floating-point Pips (e.g., 1.5) rather than points, making the threshold parameter cleaner.

Static HUD API: cTrader’s Chart.DrawStaticText allows for a much cleaner, non-intrusive Heads-Up Display that updates tick-by-tick independently of the candlestick prints.

[PTScalper]

The cAlgo Indicator (C#)

Save this in cTrader under Automate -> Indicators -> New and name it EURGBP_QuantEnginePro.

Code: Select all

using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;
using cAlgo.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class EURGBP_QuantEnginePro : Indicator
    {
        // =========================================================================
        // PARAMETERS
        // =========================================================================
        [Parameter("Rolling Window", Group = "1. Statistical Engine", DefaultValue = 21)]
        public int ZLength { get; set; }

        [Parameter("Z-Score Extraction", Group = "1. Statistical Engine", DefaultValue = 2.2, Step = 0.1)]
        public double ZThresh { get; set; }

        [Parameter("Volume Baseline Window", Group = "2. Microstructure & Cost", DefaultValue = 20)]
        public int VolLen { get; set; }

        [Parameter("Min Volume Spike (Z-Score)", Group = "2. Microstructure & Cost", DefaultValue = 1.5, Step = 0.1)]
        public double VolZMin { get; set; }

        [Parameter("Max Spread (Pips)", Group = "2. Microstructure & Cost", DefaultValue = 1.5, Step = 0.1)]
        public double MaxSpreadPips { get; set; }

        [Parameter("Fast ATR", Group = "3. Regime Constraints", DefaultValue = 14)]
        public int AtrLen { get; set; }

        [Parameter("Baseline ATR Window", Group = "3. Regime Constraints", DefaultValue = 100)]
        public int AtrAvg { get; set; }

        [Parameter("Max Volatility Ratio", Group = "3. Regime Constraints", DefaultValue = 1.15, Step = 0.05)]
        public double VolLimit { get; set; }

        [Parameter("Enable Pop-up Alerts", Group = "4. Notifications", DefaultValue = true)]
        public bool EnableAlerts { get; set; }

        // =========================================================================
        // OUTPUT BUFFERS
        // =========================================================================
        [Output("VWAP/Mean", LineColor = "DimGray", PlotType = PlotType.Line, Thickness = 1)]
        public IndicatorDataSeries Mean { get; set; }

        [Output("Upper Quant Bound", LineColor = "Crimson", PlotType = PlotType.DiscontinuousLine, Thickness = 1)]
        public IndicatorDataSeries UpperBound { get; set; }

        [Output("Lower Quant Bound", LineColor = "MediumSeaGreen", PlotType = PlotType.DiscontinuousLine, Thickness = 1)]
        public IndicatorDataSeries LowerBound { get; set; }

        [Output("Fade Long", LineColor = "LimeGreen", PlotType = PlotType.Points, Thickness = 5)]
        public IndicatorDataSeries BuySignal { get; set; }

        [Output("Fade Short", LineColor = "Red", PlotType = PlotType.Points, Thickness = 5)]
        public IndicatorDataSeries SellSignal { get; set; }

        // =========================================================================
        // INTERNAL INDICATORS & STATE
        // =========================================================================
        private SimpleMovingAverage _sma;
        private StandardDeviation _stdDev;
        
        private AverageTrueRange _atr;
        private SimpleMovingAverage _atrBaseline;
        
        private SimpleMovingAverage _volSma;
        private StandardDeviation _volStdDev;

        private int _lastAlertIndex = -1;

        // =========================================================================
        // INITIALIZATION
        // =========================================================================
        protected override void Initialize()
        {
            // Price Z-Score Core
            _sma = Indicators.SimpleMovingAverage(Bars.ClosePrices, ZLength);
            _stdDev = Indicators.StandardDeviation(Bars.ClosePrices, ZLength, MovingAverageType.Simple);

            // Volatility Regime Core
            _atr = Indicators.AverageTrueRange(AtrLen, MovingAverageType.Simple);
            _atrBaseline = Indicators.SimpleMovingAverage(_atr.Result, AtrAvg);

            // Tick Volume Variance Core (cTrader handles this natively)
            _volSma = Indicators.SimpleMovingAverage(Bars.TickVolumes, VolLen);
            _volStdDev = Indicators.StandardDeviation(Bars.TickVolumes, VolLen, MovingAverageType.Simple);
        }

        // =========================================================================
        // CORE CALCULATION ENGINE (Runs per bar/tick)
        // =========================================================================
        public override void Calculate(int index)
        {
            // Wait for sufficient lookback data
            if (index < Math.Max(AtrAvg, Math.Max(ZLength, VolLen)))
                return;

            // 1. Calculate Price Statistical Boundaries
            Mean[index] = _sma.Result[index];
            double std = _stdDev.Result[index];
            UpperBound[index] = Mean[index] + (std * ZThresh);
            LowerBound[index] = Mean[index] - (std * ZThresh);

            // 2. Regime Filter (Volatility Expansion Guard)
            double baselineAtr = _atrBaseline.Result[index];
            double currentAtr = _atr.Result[index];
            double volRatio = baselineAtr > 0 ? (currentAtr / baselineAtr) : 1.0;
            bool isRangeRegime = volRatio < VolLimit;

            // 3. Volume Exhaustion Check
            double currentVol = Bars.TickVolumes[index];
            double volStd = _volStdDev.Result[index];
            double currentVolZ = volStd == 0 ? 0 : (currentVol - _volSma.Result[index]) / volStd;
            bool isVolClimactic = currentVolZ >= VolZMin;

            // 4. Intra-Bar Rejection (Candle must close aggressively away from the sweep)
            double high = Bars.HighPrices[index];
            double low = Bars.LowPrices[index];
            double close = Bars.ClosePrices[index];
            double candleSize = high - low;
            
            bool validShortClose = close < (high - (candleSize * 0.5));
            bool validLongClose = close > (low + (candleSize * 0.5));

            // 5. Live Spread Filter (Evaluates strictly on live data, assumed true historically)
            double currentSpreadPips = Symbol.Spread / Symbol.PipSize;
            bool validSpread = true;
            if (IsLastBar) 
            {
                validSpread = currentSpreadPips <= MaxSpreadPips;
                UpdateHUD(currentSpreadPips, validSpread, currentVolZ);
            }

            // =========================================================
            // SIGNAL GENERATION
            // =========================================================
            bool sweepShort = (high > UpperBound[index]) && (close < UpperBound[index]) && 
                              isRangeRegime && isVolClimactic && validShortClose && validSpread;

            bool sweepLong = (low < LowerBound[index]) && (close > LowerBound[index]) && 
                             isRangeRegime && isVolClimactic && validLongClose && validSpread;

            // Paint visual signals
            if (sweepLong)
                BuySignal[index] = low - (std * 0.3);
            if (sweepShort)
                SellSignal[index] = high + (std * 0.3);

            // =========================================================
            // ALERT DISPATCH (Checks index-1 to ensure candle is closed)
            // =========================================================
            if (IsLastBar && EnableAlerts)
            {
                int completedBarIndex = index - 1;
                if (_lastAlertIndex != completedBarIndex)
                {
                    if (!double.IsNaN(BuySignal[completedBarIndex]))
                    {
                        TriggerAlert("PRO LONG: Volume-Validated Absorption");
                        _lastAlertIndex = completedBarIndex;
                    }
                    else if (!double.IsNaN(SellSignal[completedBarIndex]))
                    {
                        TriggerAlert("PRO SHORT: Volume-Validated Absorption");
                        _lastAlertIndex = completedBarIndex;
                    }
                }
            }
        }

        // =========================================================================
        // UI AND NOTIFICATION HELPERS
        // =========================================================================
        private void UpdateHUD(double spreadPips, bool spreadValid, double volZ)
        {
            string status = spreadValid ? "SPREAD OPTIMAL" : "[!] SPREAD HIGH - SIGNALS BLOCKED";
            string statusColor = spreadValid ? "#00c853" : "#d50000"; // Green or Red hex for markup

            string hudText = 
                $"<span size='12' weight='bold'>=== EURGBP QUANT ENGINE (cTrader) ===</span>\n" +
                $"Live Spread: <span color='{statusColor}' weight='bold'>{Math.Round(spreadPips, 1)} pips</span> | Limit: {MaxSpreadPips}\n" +
                $"Volume Z-Score: {Math.Round(volZ, 2)}\n" +
                $"Status: <span color='{statusColor}' weight='bold'>{status}</span>";

            Chart.DrawStaticText("QuantHUD", hudText, VerticalAlignment.Top, HorizontalAlignment.Left, Color.White);
        }

        private void TriggerAlert(string direction)
        {
            string msg = $"[{Symbol.Name} - {TimeFrame}] {direction}";
            Notifications.PlaySound(SoundType.Doorbell);
            
            // Note: cTrader MessageBox halts the thread. We use DrawStaticText momentarily or native system sounds.
            Chart.DrawStaticText("AlertHUD", $"\n\n\n\nLAST SIGNAL: {msg} at {Server.Time}", VerticalAlignment.Top, HorizontalAlignment.Left, Color.Yellow);
            Print(msg); // Prints to Automate Log
        }
    }
}

[PTScalper]

Institutional cTrader Advantages Exposed Here:

HTML-Markup HUD: Unlike MT4's archaic Comment() function, cAlgo allows us to inject lightweight HTML tags into the Chart.DrawStaticText() API. Notice how the HUD will actively color-code your spread status dynamically (Green for optimal, Red if market makers widen beyond your pip limit).

Object-Oriented Architecture: Notice how we pass Bars.TickVolumes directly into the StandardDeviation indicator constructor. Because everything in cTrader inherits from DataSeries, the exact mathematical footprint of the PineScript Volume-Z-score calculates flawlessly here.

Execution Ready (IsLastBar Logic): The alert logic is explicitly bound to index - 1 while guarded by IsLastBar. This guarantees zero repainting. It only assesses the setup the millisecond the candlestick formally commits to the chart history.

This script is natively plug-and-play. If you want to turn this into an automated cBot later, you can directly reference these BuySignal and SellSignal outputs because they are exposed as public IndicatorDataSeries.

[LondonNewsTrader]

London Session Scalping Matrix Drop this into TradingView. It creates a real-time matrix on your chart comparing your A-list pairs.

Having ATR in pips side by side for the four pairs is genuinely handy when deciding what to focus on at the open.

The session input is UTC with 0800-1200 as default. That lines up with London only in winter; from late March to late October London opens at 07:00 UTC, so for half the year the matrix calls the first hour of the session inactive. Setting tz to "Europe/London" and the window to 0800-1200 local fixes it permanently, since the timezone handles the clock change.

The RVOL column is tick volume from OANDA's feed. A reasonable proxy for activity, but it reflects one broker's quote updates, not traded volume. It works better as 'busier than usual for this pair' than as a comparison between pairs.

What I'd really want next to ATR is cost. GBPJPY often shows the biggest pip range, but its spread is also a multiple of EURUSD's, so what you can actually capture after costs is less impressive than the raw number. Pine can't read live spread, but a manual typical-spread input per pair and a column of ATR divided by spread would rank the pairs by what a scalper really gets.

On the original question: EURUSD for cost, GBPUSD when UK data is on that morning's calendar.