How many fills do you need before ranking two brokers?

[LondonScalper]

How many fills before ranking two brokers?

I see a lot of “Broker A is better” after a quiet Tuesday. That is anecdote, not a sample. When I compare two raw accounts I want enough fills that a few lucky positives do not decide the ranking.

My rough bar:

• Same pair, same session window, similar size
• At least a few hundred live market orders across both — more if you scalp metals
• Track median spread, slip, rejects — not just “felt fast”
• Re-run after a high-impact week; calm weeks flatter everyone

Still imperfect — LP mix shifts — but better than a weekend demo race. I would rather under-claim than crown a winner early.

What sample size do you trust? Do you compare on EURUSD first and only then on XAU, or the other way round? Practical methods only — no affiliate scoreboards. If your sample is smaller, say so; honesty about uncertainty is more useful than a premature league table.

[PTScalper]

How many fills before ranking two brokers?

I see a lot of “Broker A is better” after a quiet Tuesday. That is anecdote, not a sample. When I compare two raw accounts I want enough fills that a few lucky positives do not decide the ranking.

My rough bar:

• Same pair, same session window, similar size
• At least a few hundred live market orders across both — more if you scalp metals
• Track median spread, slip, rejects — not just “felt fast”
• Re-run after a high-impact week; calm weeks flatter everyone

Still imperfect — LP mix shifts — but better than a weekend demo race. I would rather under-claim than crown a winner early.

What sample size do you trust? Do you compare on EURUSD first and only then on XAU, or the other way round? Practical methods only — no affiliate scoreboards. If your sample is smaller, say so; honesty about uncertainty is more useful than a premature league table.

Hi LondonScalper,

Spot on. A quiet Tuesday afternoon in NY tells you nothing about a broker's true liquidity depth.

For a statistically significant sample, raw trade count matters less than the specific market conditions during those fills. I look for at least 200–300 live market orders executed specifically during high-volume windows (London open, NY overlap, or major macro prints). Aggregating 1,000 trades over a calm, range-bound week dilutes the data and flatters B-book brokers running tight synthetic spreads.

Regarding asset sequence, I always test them separately rather than sequentially.

EURUSD: I use this strictly to test baseline infrastructure latency and routing speed. It is highly liquid, so any anomalous slippage or execution delay here is an immediate red flag.

XAUUSD (Gold): This is where broker infrastructure actually breaks. Because I scalp raw price action and liquidity sweeps on 1-minute and 5-minute charts, gold’s volatile microstructure will instantly reveal if an LP mix is thin. You cannot correlate EURUSD execution quality to Gold; a broker can have top-tier FX liquidity but terrible metals routing.

To track this accurately, I build custom logging scripts to monitor automated order rejections and execution delays rather than relying on feel. Logging median spread is good, but tracking the exact milliseconds of execution delay and the exact tick slippage on limit order rejections is what separates real A-book routing from aggressive internalizers.

[PTScalper]

Here is a custom Pine Script to help visualize these execution environments. Since TradingView does not store historical bid/ask tick data for spread tracking, this script maps out "Execution Risk Zones" based on localized volatility and identifies liquidity sweeps—the exact moments where thin LP books will slip your market orders the hardest.

Code: Select all

//@version=5
indicator("Liquidity Sweep & Execution Risk", overlay=true)

// Inputs for baseline volatility
length = input.int(20, title="ATR Lookback")
slip_multiplier = input.float(1.5, title="Slippage Risk Multiplier")

// Calculate baseline execution environment (Average True Range)
avg_volatility = ta.atr(length)

// Identify Liquidity Sweeps (Where LPs pull liquidity and slippage spikes)
// Sweeping a recent 20-bar low, but closing bullish
bull_sweep = low < ta.lowest(low[1], length) and close > open
// Sweeping a recent 20-bar high, but closing bearish
bear_sweep = high > ta.highest(high[1], length) and close < open

// Plot execution risk zones (When price leaves this band, slippage risk is high)
upper_risk = ta.sma(close, length) + (avg_volatility * slip_multiplier)
lower_risk = ta.sma(close, length) - (avg_volatility * slip_multiplier)

p1 = plot(upper_risk, color=color.new(color.gray, 70), title="Upper Risk Band")
p2 = plot(lower_risk, color=color.new(color.gray, 70), title="Lower Risk Band")
fill(p1, p2, color=color.new(color.blue, 90), title="Stable Execution Zone")

// Flag the chart exactly where brokers are most likely to slip you
plotshape(bull_sweep, title="High Slippage Risk (Bull Sweep)", style=shape.triangleup, location=location.belowbar, color=color.new(color.red, 0), size=size.small)
plotshape(bear_sweep, title="High Slippage Risk (Bear Sweep)", style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.small)

// Alert conditions for automated logging
alertcondition(bull_sweep or bear_sweep, title="Liquidity Sweep Alert", message="High slippage risk detected - LP books likely thin.")

Track your fills exactly where this script plots the red sweep markers. If a broker is going to slip you or reject the order, that is exactly where it happens.

[PTScalper]

If you are using TradingView for visual analysis, keep in mind it does not store historical bid/ask tick data for spread mapping. However, you can proxy execution risk. I wrote this Pine Script to map localized volatility bands and flag structural liquidity sweeps—the exact moments where thin LP books will pull liquidity and slip your market orders the hardest.

Code: Select all

//@version=5
indicator("Liquidity Sweep & Execution Risk", overlay=true)

// Baseline volatility configuration
length = input.int(20, title="ATR Lookback")
slip_multiplier = input.float(1.5, title="Slippage Risk Multiplier")

// Calculate execution environment (Average True Range)
avg_volatility = ta.atr(length)

// Identify structural sweeps (Liquidity vacuums)
// Sweeping a 20-bar low, closing bullish (Sell-side liquidity sweep)
bull_sweep = low < ta.lowest(low[1], length) and close > open

// Sweeping a 20-bar high, closing bearish (Buy-side liquidity sweep)
bear_sweep = high > ta.highest(high[1], length) and close < open

// Map stable execution zones (Slippage risk increases exponentially outside this band)
upper_risk = ta.sma(close, length) + (avg_volatility * slip_multiplier)
lower_risk = ta.sma(close, length) - (avg_volatility * slip_multiplier)

p1 = plot(upper_risk, color=color.new(color.gray, 70), title="Upper Risk Band")
p2 = plot(lower_risk, color=color.new(color.gray, 70), title="Lower Risk Band")
fill(p1, p2, color=color.new(color.blue, 90), title="Stable Execution Zone")

// Flag LP withdrawal zones (High slippage probability)
plotshape(bull_sweep, title="High Slippage Risk (Bull Sweep)", style=shape.triangleup, location=location.belowbar, color=color.new(color.red, 0), size=size.small)
plotshape(bear_sweep, title="High Slippage Risk (Bear Sweep)", style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.small)

alertcondition(bull_sweep or bear_sweep, title="Liquidity Sweep Alert", message="Structural sweep detected: High execution risk / LP withdrawal imminent.")

[PTScalper]

Cross-reference your raw fills against the red sweep markers plotted by this script. If a broker is masking a weak LP pool or aggressively internalizing flow, that is precisely where you will see the latency spikes and negative slippage.

[PTScalper]

Moving this logic into the terminal is where execution logging actually becomes useful. TradingView has zero visibility into actual LP routing or the server-side order book. By porting this to MetaTrader, you can correlate these structural vacuums directly with automated rejection logs and latency trackers.

Because you are tracking raw price action on 15-minute and daily charts rather than relying on lagging indicators, these scripts strictly measure volatility structure. They map the outer boundaries of expected liquidity and flag the exact candles where LPs pull orders, which is where negative slippage hits hardest.

[PTScalper]

MQL4: Liquidity Sweep & Execution Risk

Place this in MQL4\Indicators. It uses native timeseries indexing (iLowest, iHighest) to flag liquidity voids in real-time.

Code: Select all

//+------------------------------------------------------------------+
//|                                     Liquidity_Sweep_Risk_MT4.mq4 |
//+------------------------------------------------------------------+
#property copyright "Execution Risk Mapping"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 clrDarkGray
#property indicator_color2 clrDarkGray
#property indicator_color3 clrRed
#property indicator_color4 clrRed

#property indicator_type1 DRAW_LINE
#property indicator_type2 DRAW_LINE
#property indicator_type3 DRAW_ARROW
#property indicator_type4 DRAW_ARROW

input int InpLength = 20;               // ATR & SMA Lookback
input double InpSlipMultiplier = 1.5;   // Slippage Risk Multiplier
input bool InpEnableAlerts = true;      // Enable Terminal Alerts

double BufferUpper[];
double BufferLower[];
double BufferBullSweep[];
double BufferBearSweep[];
datetime lastAlertTime;

int OnInit() {
    SetIndexBuffer(0, BufferUpper);
    SetIndexBuffer(1, BufferLower);
    SetIndexBuffer(2, BufferBullSweep);
    SetIndexBuffer(3, BufferBearSweep);
    
    SetIndexStyle(0, DRAW_LINE, STYLE_SOLID, 1);
    SetIndexStyle(1, DRAW_LINE, STYLE_SOLID, 1);
    
    SetIndexStyle(2, DRAW_ARROW);
    SetIndexArrow(2, 233); // Up Arrow for Bull Sweep
    
    SetIndexStyle(3, DRAW_ARROW);
    SetIndexArrow(3, 234); // Down Arrow for Bear Sweep
    
    IndicatorShortName("Execution Risk Band");
    return(INIT_SUCCEEDED);
}

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[]) {
                
    if (rates_total < InpLength + 1) return(0);
    
    int limit = rates_total - prev_calculated;
    if(prev_calculated > 0) limit++; 
    if(limit >= rates_total) limit = rates_total - 1;
    
    for (int i = limit; i >= 0; i--) {
        double atr = iATR(Symbol(), 0, InpLength, i);
        double sma = iMA(Symbol(), 0, InpLength, 0, MODE_SMA, PRICE_CLOSE, i);
        
        BufferUpper[i] = sma + (atr * InpSlipMultiplier);
        BufferLower[i] = sma - (atr * InpSlipMultiplier);
        
        BufferBullSweep[i] = EMPTY_VALUE;
        BufferBearSweep[i] = EMPTY_VALUE;
        
        if (i >= 0 && rates_total - i > InpLength) {
            int lowestIdx = iLowest(Symbol(), 0, MODE_LOW, InpLength, i + 1);
            int highestIdx = iHighest(Symbol(), 0, MODE_HIGH, InpLength, i + 1);
            
            bool bullSweep = (low[i] < low[lowestIdx]) && (close[i] > open[i]);
            bool bearSweep = (high[i] > high[highestIdx]) && (close[i] < open[i]);
            
            if (bullSweep) BufferBullSweep[i] = low[i] - (atr * 0.5);
            if (bearSweep) BufferBearSweep[i] = high[i] + (atr * 0.5);
            
            if (i == 0 && InpEnableAlerts && (bullSweep || bearSweep) && time[0] != lastAlertTime) {
                Alert("Liquidity Sweep Detected on ", Symbol(), " - LP withdrawal imminent.");
                lastAlertTime = time[0];
            }
        }
    }
    return(rates_total);
}

[PTScalper]

MQL5: Liquidity Sweep & Execution Risk

Place this in MQL5\Indicators. MQL5 handles arrays differently, so this implementation forces ArraySetAsSeries and uses CopyBuffer to pull indicator handles smoothly without memory leaks.

Code: Select all

//+------------------------------------------------------------------+
//|                                     Liquidity_Sweep_Risk_MT5.mq5 |
//+------------------------------------------------------------------+
#property copyright "Execution Risk Mapping"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   4

#property indicator_label1  "Upper Risk Band"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDarkGray
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

#property indicator_label2  "Lower Risk Band"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrDarkGray
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1

#property indicator_label3  "Bull Sweep Risk"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrRed

#property indicator_label4  "Bear Sweep Risk"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed

input int InpLength = 20;               // ATR & SMA Lookback
input double InpSlipMultiplier = 1.5;   // Slippage Risk Multiplier
input bool InpEnableAlerts = true;      // Enable Terminal Alerts

double BufferUpper[];
double BufferLower[];
double BufferBullSweep[];
double BufferBearSweep[];

int handle_atr;
int handle_sma;
datetime lastAlertTime;

int OnInit() {
    SetIndexBuffer(0, BufferUpper, INDICATOR_DATA);
    SetIndexBuffer(1, BufferLower, INDICATOR_DATA);
    SetIndexBuffer(2, BufferBullSweep, INDICATOR_DATA);
    SetIndexBuffer(3, BufferBearSweep, INDICATOR_DATA);
    
    PlotIndexSetInteger(2, PLOT_ARROW, 233);
    PlotIndexSetInteger(3, PLOT_ARROW, 234);
    
    ArraySetAsSeries(BufferUpper, true);
    ArraySetAsSeries(BufferLower, true);
    ArraySetAsSeries(BufferBullSweep, true);
    ArraySetAsSeries(BufferBearSweep, true);
    
    handle_atr = iATR(_Symbol, _Period, InpLength);
    handle_sma = iMA(_Symbol, _Period, InpLength, 0, MODE_SMA, PRICE_CLOSE);
    
    if (handle_atr == INVALID_HANDLE || handle_sma == INVALID_HANDLE) {
        Print("Failed to load indicator handles");
        return(INIT_FAILED);
    }
    
    IndicatorSetString(INDICATOR_SHORTNAME, "Execution Risk Band");
    return(INIT_SUCCEEDED);
}

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[]) {
                
    if(rates_total < InpLength + 1) return(0);
    
    ArraySetAsSeries(open, true);
    ArraySetAsSeries(high, true);
    ArraySetAsSeries(low, true);
    ArraySetAsSeries(close, true);
    ArraySetAsSeries(time, true);
    
    int limit = rates_total - prev_calculated;
    if(prev_calculated > 0) limit++; 
    if(limit >= rates_total) limit = rates_total - 1;
    
    double atrArray[], smaArray[];
    ArraySetAsSeries(atrArray, true);
    ArraySetAsSeries(smaArray, true);
    
    if (CopyBuffer(handle_atr, 0, 0, limit + 1, atrArray) <= 0) return(0);
    if (CopyBuffer(handle_sma, 0, 0, limit + 1, smaArray) <= 0) return(0);
    
    for (int i = limit; i >= 0 && !IsStopped(); i--) {
        BufferBullSweep[i] = EMPTY_VALUE;
        BufferBearSweep[i] = EMPTY_VALUE;
        
        BufferUpper[i] = smaArray[i] + (atrArray[i] * InpSlipMultiplier);
        BufferLower[i] = smaArray[i] - (atrArray[i] * InpSlipMultiplier);
        
        if (i + InpLength < rates_total && i >= 0) {
            int lowestIdx = ArrayMinimum(low, i + 1, InpLength);
            int highestIdx = ArrayMaximum(high, i + 1, InpLength);
            
            bool bullSweep = (low[i] < low[lowestIdx]) && (close[i] > open[i]);
            bool bearSweep = (high[i] > high[highestIdx]) && (close[i] < open[i]);
            
            if (bullSweep) BufferBullSweep[i] = low[i] - (atrArray[i] * 0.5);
            if (bearSweep) BufferBearSweep[i] = high[i] + (atrArray[i] * 0.5);
            
            if (i == 0 && InpEnableAlerts && (bullSweep || bearSweep) && time[0] != lastAlertTime) {
                Alert("Liquidity Sweep Detected on ", _Symbol, " - LP withdrawal imminent.");
                lastAlertTime = time[0];
            }
        }
    }
    
    return(rates_total);
}

[PTScalper]

Cross-reference your execution EA's transaction history with the red sweep markers generated by these scripts. If you find your cAlgo or MT5 scripts logging RETCODE_REJECT or massive latency spikes precisely where the arrows plot, the broker's liquidity pool is failing right when you need it most.

[PTScalper]

Porting this into cTrader is where you gain a massive architectural advantage. Because cAlgo is entirely C# (.NET), you can seamlessly bridge this indicator's output directly into a cBot to log the exact execution delta between Symbol.Ask at the moment of a liquidity sweep and the actual Position.EntryPrice returned by the server.

cTrader handles historical data arrays and tick processing much cleaner than MT4/MT5. Instead of wrestling with buffer memory leaks, you can plot the execution risk bands natively and expose the sweep data series to your execution algorithms.