How prop firm spreads differ from IC Markets raw

[LondonScalper]

Prop firm spreads versus IC Markets raw is the comparison that keeps me honest about funded accounts.

Marketing pages blur. My sheet does not. I pick the same London hours, the same pairs I actually trade, and I write down what the platform showed — not what a review site scraped last year.

Columns that matter to me

• Median spread in the London killzone
• How often the quote flashes wide then snaps (usable vs trap)
• Whether commissions are buried so "spread" looks prettier than all-in cost

If the prop path is consistently wider, my lot ladder and playbook shrink. I do not try to force personal-account R-multiples onto a slower tape and then blame psychology.

For those running both: which pairs still look workable on the firm feed, and which did you exile back to personal capital only?

Commission schedules matter in the comparison too. A tighter raw spread with a fee can still beat a commission-free prop quote that prints wider every London open. All-in cost per round turn on a typical scalp size is the only number I argue from.

[PTScalper]

Prop firm spreads versus IC Markets raw is the comparison that keeps me honest about funded accounts.

Marketing pages blur. My sheet does not. I pick the same London hours, the same pairs I actually trade, and I write down what the platform showed — not what a review site scraped last year.

Columns that matter to me

• Median spread in the London killzone
• How often the quote flashes wide then snaps (usable vs trap)
• Whether commissions are buried so "spread" looks prettier than all-in cost

If the prop path is consistently wider, my lot ladder and playbook shrink. I do not try to force personal-account R-multiples onto a slower tape and then blame psychology.

For those running both: which pairs still look workable on the firm feed, and which did you exile back to personal capital only?

Commission schedules matter in the comparison too. A tighter raw spread with a fee can still beat a commission-free prop quote that prints wider every London open. All-in cost per round turn on a typical scalp size is the only number I argue from.

Hi LondonScalper,

Prop firms are in the risk management and fee-generation business; they route via B-book liquidity providers that inherently pad spreads during volatile transitions. IC Markets Raw provides true ECN aggregation, meaning its order book absorbs London open liquidity sweeps rather than artificially fading them with widened quotes.

When scalping 1-minute and 5-minute price action for 10-15 pip targets, an extra 0.4 pips in hidden costs degrades your R-multiple over a 100-trade sample size. A 0.0 pip raw spread with a $7/lot round-turn commission is a ~0.7 pip true cost on EURUSD. A prop firm advertising a "tight" 0.5 pip spread but burying a $6 commission is running a 1.1 pip true cost.

The Pair Exile List (Prop vs. Personal)

Workable on Prop Feeds: EURUSD, GBPUSD, and USDJPY. Baseline interbank liquidity on these majors is deep enough that even with a prop firm's artificial markup, the all-in cost rarely exceeds 1.2 pips during the London killzone. XAUUSD (Gold) also remains viable if you scale lot sizes to its ATR, as the point-value to spread ratio absorbs the B-book padding.

Exiled to IC Markets (Personal Capital Only): GBPJPY, GBPNZD, EURAUD, and XAGUSD (Silver). During the London open, prop feeds frequently flash-widen crosses by 3 to 5 pips. These synthetic spikes hunt structural stops that IC Markets' raw feed would never touch. Silver is notoriously toxic on prop accounts; the baseline spread is padded so heavily that scalping lower-timeframe structure becomes a negative expectancy game.

[PTScalper]

All-In Cost & Spike Logger (cTrader)

This cTrader indicator automates your spreadsheet tracking. It runs directly on your chart, calculates the real-time All-In Cost (live spread + your inputted commission converted dynamically to pips), and logs any flash-widenings to the cTrader Journal during your defined killzone.

Code: Select all

using System;
using cAlgo.API;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class TrueCostAndSpikeLogger : Indicator
    {
        [Parameter("RT Commission per Lot (Account Currency)", DefaultValue = 7.0)]
        public double Commission { get; set; }

        [Parameter("Spike Alert Threshold (Pips)", DefaultValue = 1.5)]
        public double SpikeThreshold { get; set; }

        [Parameter("Killzone Start (UTC Hour)", DefaultValue = 7)] // 7 UTC = 8 AM London
        public int SessionStart { get; set; }

        [Parameter("Killzone End (UTC Hour)", DefaultValue = 10)]  // 10 UTC = 11 AM London
        public int SessionEnd { get; set; }

        private double _maxSpread = 0;
        private int _spikeCount = 0;
        private bool _inSession = false;

        protected override void Initialize()
        {
            Print("True Cost Logger Initialized.");
        }

        public override void Calculate(int index)
        {
            // Only calculate on the live ticking bar
            if (!IsLastBar) return;

            // Convert round-turn commission to its exact pip equivalent
            double lotVolume = Symbol.QuantityToVolumeInUnits(1);
            double pipValuePerLot = Symbol.PipValue * lotVolume;
            
            if (pipValuePerLot == 0) return; // Guard against uninitialized symbol data

            double commissionPips = Commission / pipValuePerLot;
            double rawSpreadPips = Symbol.Spread / Symbol.PipSize;
            double allInCostPips = rawSpreadPips + commissionPips;

            // Track session timing
            DateTime now = Server.Time;
            bool currentlyInSession = now.Hour >= SessionStart && now.Hour < SessionEnd;

            if (currentlyInSession)
            {
                if (!_inSession)
                {
                    // Reset stats at the start of the killzone
                    _maxSpread = 0;
                    _spikeCount = 0;
                    _inSession = true;
                }

                if (allInCostPips > _maxSpread)
                    _maxSpread = allInCostPips;

                // Log flash widenings (traps) directly to the journal
                if (allInCostPips >= SpikeThreshold)
                {
                    _spikeCount++;
                    Print($"[{now:HH:mm:ss}] SPREAD SPIKE: {Symbol.Name} True Cost hit {Math.Round(allInCostPips, 2)} pips (Raw: {Math.Round(rawSpreadPips, 2)}).");
                }
            }
            else
            {
                if (_inSession)
                {
                    // Output session summary to journal when killzone ends
                    Print($"Session Ended. Max All-In Spread: {Math.Round(_maxSpread, 2)} pips. Total Spikes > {SpikeThreshold}p: {_spikeCount}");
                    _inSession = false;
                }
            }

            // Draw real-time HUD on the chart
            string displayText = $"All-In Cost: {Math.Round(allInCostPips, 2)} p\n" +
                                 $"(Raw: {Math.Round(rawSpreadPips, 2)} | Comm: {Math.Round(commissionPips, 2)})\n" +
                                 (currentlyInSession ? $"Session Max: {Math.Round(_maxSpread, 2)} p\nSpikes: {_spikeCount}" : "Waiting for Killzone");

            Chart.DrawStaticText("SpreadData", displayText, VerticalAlignment.Top, HorizontalAlignment.Left, Color.White);
        }
    }
}

[PTScalper]

MQL4 Indicator

Save this as TrueCostLogger.mq4 in your MQL4/Indicators folder. It calculates raw spread tick-by-tick, maps round-turn commission to exact pip value using current account currency tick values, tracks session-peak spread widening, and logs spike events to the Experts tab without log-flooding.

Code: Select all

//+------------------------------------------------------------------+
//|                                           TrueCostLogger.mq4     |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Custom Indicator"
#property link      ""
#property version   "1.00"
#property strict
#property indicator_chart_window

input double InpCommissionRT    = 7.0;  // RT Commission per Lot (Account Currency)
input double InpSpikeThreshold  = 1.5;  // Spike Alert Threshold (Pips)
input int    InpSessionStart    = 7;    // Killzone Start Hour (Broker Server Time)
input int    InpSessionEnd      = 10;   // Killzone End Hour (Broker Server Time)

double g_maxSpread   = 0.0;
int    g_spikeCount  = 0;
bool   g_inSession   = false;
bool   g_isSpiking   = false;

double GetPipSize()
{
   if(_Digits == 3 || _Digits == 5)
      return _Point * 10.0;
   return _Point;
}

int OnInit()
{
   g_maxSpread  = 0.0;
   g_spikeCount = 0;
   g_inSession  = false;
   g_isSpiking  = false;
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   Comment("");
}

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[])
{
   double pip = GetPipSize();
   if(pip <= 0.0) return(rates_total);

   double tickSize  = MarketInfo(_Symbol, MODE_TICKSIZE);
   double tickValue = MarketInfo(_Symbol, MODE_TICKVALUE);
   if(tickSize <= 0.0 || tickValue <= 0.0) return(rates_total);

   double pipValuePerLot = (pip / tickSize) * tickValue;
   if(pipValuePerLot <= 0.0) return(rates_total);

   double commissionPips = InpCommissionRT / pipValuePerLot;
   double rawSpreadPips  = (Ask - Bid) / pip;
   double allInCostPips  = rawSpreadPips + commissionPips;

   datetime now = TimeCurrent();
   MqlDateTime dt;
   TimeToStruct(now, dt);

   bool currentlyInSession = (dt.hour >= InpSessionStart && dt.hour < InpSessionEnd);

   if(currentlyInSession)
   {
      if(!g_inSession)
      {
         g_maxSpread  = 0.0;
         g_spikeCount = 0;
         g_isSpiking  = false;
         g_inSession  = true;
      }

      if(allInCostPips > g_maxSpread)
         g_maxSpread = allInCostPips;

      if(allInCostPips >= InpSpikeThreshold)
      {
         if(!g_isSpiking)
         {
            g_spikeCount++;
            g_isSpiking = true;
            Print(StringFormat("[%02d:%02d:%02d] SPREAD SPIKE: %s True Cost hit %.2f pips (Raw: %.2f)",
                  dt.hour, dt.min, dt.sec, _Symbol, allInCostPips, rawSpreadPips));
         }
      }
      else
      {
         g_isSpiking = false;
      }
   }
   else
   {
      if(g_inSession)
      {
         Print(StringFormat("[%s] Session Ended. Max All-In Spread: %.2f pips | Spikes > %.2fp: %d",
               _Symbol, g_maxSpread, InpSpikeThreshold, g_spikeCount));
         g_inSession = false;
         g_isSpiking = false;
      }
   }

   string sessionStatus = currentlyInSession
      ? StringFormat("Session Max: %.2f p\nSpikes: %d", g_maxSpread, g_spikeCount)
      : "Waiting for Killzone";

   string hud = StringFormat("--- True Cost Monitor (%s) ---\n" +
                             "All-In Cost: %.2f p\n" +
                             "(Raw: %.2f | Comm: %.2f p)\n" +
                             "%s",
                             _Symbol, allInCostPips, rawSpreadPips, commissionPips, sessionStatus);

   Comment(hud);
   return(rates_total);
}

[PTScalper]

MQL5 Indicator

Save this as TrueCostLogger.mq5 in your MQL5/Indicators folder. It uses MQL5 symbol property accessors (SYMBOL_TRADE_TICK_VALUE, SYMBOL_TRADE_TICK_SIZE) and SymbolInfoTick for tick timing.

Code: Select all

//+------------------------------------------------------------------+
//|                                           TrueCostLogger.mq5     |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Custom Indicator"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0

input double InpCommissionRT    = 7.0;  // RT Commission per Lot (Account Currency)
input double InpSpikeThreshold  = 1.5;  // Spike Alert Threshold (Pips)
input int    InpSessionStart    = 7;    // Killzone Start Hour (Broker Server Time)
input int    InpSessionEnd      = 10;   // Killzone End Hour (Broker Server Time)

double g_maxSpread   = 0.0;
int    g_spikeCount  = 0;
bool   g_inSession   = false;
bool   g_isSpiking   = false;

double GetPipSize()
{
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

   if(digits == 3 || digits == 5)
      return point * 10.0;
   return point;
}

int OnInit()
{
   g_maxSpread  = 0.0;
   g_spikeCount = 0;
   g_inSession  = false;
   g_isSpiking  = false;
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   Comment("");
}

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[])
{
   MqlTick lastTick;
   if(!SymbolInfoTick(_Symbol, lastTick))
      return(rates_total);

   double pip = GetPipSize();
   if(pip <= 0.0) return(rates_total);

   double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   if(tickSize <= 0.0 || tickValue <= 0.0) return(rates_total);

   double pipValuePerLot = (pip / tickSize) * tickValue;
   if(pipValuePerLot <= 0.0) return(rates_total);

   double commissionPips = InpCommissionRT / pipValuePerLot;
   double rawSpreadPips  = (lastTick.ask - lastTick.bid) / pip;
   double allInCostPips  = rawSpreadPips + commissionPips;

   MqlDateTime dt;
   TimeCurrent(dt);

   bool currentlyInSession = (dt.hour >= InpSessionStart && dt.hour < InpSessionEnd);

   if(currentlyInSession)
   {
      if(!g_inSession)
      {
         g_maxSpread  = 0.0;
         g_spikeCount = 0;
         g_isSpiking  = false;
         g_inSession  = true;
      }

      if(allInCostPips > g_maxSpread)
         g_maxSpread = allInCostPips;

      if(allInCostPips >= InpSpikeThreshold)
      {
         if(!g_isSpiking)
         {
            g_spikeCount++;
            g_isSpiking = true;
            Print(StringFormat("[%02d:%02d:%02d] SPREAD SPIKE: %s True Cost hit %.2f pips (Raw: %.2f)",
                  dt.hour, dt.min, dt.sec, _Symbol, allInCostPips, rawSpreadPips));
         }
      }
      else
      {
         g_isSpiking = false;
      }
   }
   else
   {
      if(g_inSession)
      {
         Print(StringFormat("[%s] Session Ended. Max All-In Spread: %.2f pips | Spikes > %.2fp: %d",
               _Symbol, g_maxSpread, InpSpikeThreshold, g_spikeCount));
         g_inSession = false;
         g_isSpiking = false;
      }
   }

   string sessionStatus = currentlyInSession
      ? StringFormat("Session Max: %.2f p\nSpikes: %d", g_maxSpread, g_spikeCount)
      : "Waiting for Killzone";

   string hud = StringFormat("--- True Cost Monitor (%s) ---\n" +
                             "All-In Cost: %.2f p\n" +
                             "(Raw: %.2f | Comm: %.2f p)\n" +
                             "%s",
                             _Symbol, allInCostPips, rawSpreadPips, commissionPips, sessionStatus);

   Comment(hud);
   return(rates_total);
}

[PTScalper]

Operational Considerations for MetaTrader

Server Time Offsets: MetaTrader brokers (including IC Markets) universally set their server clock to GMT+2 (or GMT+3 during US DST) to maintain 5 daily candles per week. Adjust InpSessionStart and InpSessionEnd to match the broker's clock (e.g., if London open is 07:00 UTC and the server is GMT+3, set InpSessionStart to 10).

State Hysteresis: Both scripts implement a latch (g_isSpiking) so that a single 3-second flash widening is counted and logged as one spike event rather than flooding your log with 100 entries for every tick while quotes stay elevated.

[PTScalper]

Here is the reality of bringing this to TradingView: Pine Script has a fatal blind spot for true spread logging.

TradingView charts are constructed using a single price feed (typically the Bid price). Pine Script does not have native, tick-by-tick access to simultaneous Ask and Bid variables like cAlgo or MQL. When a prop firm's B-book feed artificially widens the spread by pushing the Ask price up during the London open, it usually happens without a trade printing. To TradingView, that event is completely invisible.

Because we cannot track true spread manipulation in Pine, I have adapted this script to track the next best thing: Killzone Microstructure Volatility & Commission True Cost.

It dynamically converts your USD commission into its exact pip equivalent for the chart's specific pair, highlights your London killzone, and tracks 1-minute liquidity sweeps (whip-saw wicks) that act as a proxy for thin, toxic order books.

[PTScalper]

Pine Script v5: Killzone Cost & Volatility Logger

Open the Pine Editor, clear the default code, paste this in, and click Add to Chart.

Code: Select all

//@version=5
indicator("Killzone True Cost & Volatility Logger", overlay=true, max_labels_count=50)

// -----------------------------------------------------------------------------
// INPUTS
// -----------------------------------------------------------------------------
comm_usd     = input.float(7.0, title="RT Commission per Lot ($)", group="Cost & Alert Settings")
spike_thresh = input.float(3.0, title="Liquidity Sweep Alert (Pips)", group="Cost & Alert Settings", tooltip="Alerts if a single candle's range exceeds this during the Killzone.")
session_time = input.session("0800-1100", title="Killzone Session", group="Time Settings")
session_tz   = input.string("Europe/London", title="Timezone", group="Time Settings")

// -----------------------------------------------------------------------------
// PIP & COMMISSION MATH
// -----------------------------------------------------------------------------
// Calculate true pip size (handles JPY pairs correctly)
pip_size = syminfo.mintick * (str.contains(syminfo.ticker, "JPY") ? 100 : 10)

// Approximate Pip Value in USD (Assuming 1 Standard Lot = 100k units)
// This handles standard majors and JPY crosses dynamically.
quote_currency = syminfo.currency
pip_value_usd = if quote_currency == "USD"
    10.0
else if quote_currency == "JPY"
    1000.0 / close
else if quote_currency == "CAD" or quote_currency == "CHF"
    10.0 / close
else
    // Fallback for cross pairs like EURAUD (would require complex routing in Pine)
    10.0 

// Convert USD commission into hard pips for this specific pair
comm_in_pips = comm_usd / pip_value_usd

// -----------------------------------------------------------------------------
// SESSION TRACKING & VOLATILITY (PROXY FOR SPREAD)
// -----------------------------------------------------------------------------
in_killzone = not na(time(timeframe.period, session_time, session_tz))

var bool was_in_killzone = false
var float max_sweep_pips = 0.0
var int spike_count      = 0

// Measure the current candle's volatility (high - low) in pips
current_sweep_pips = (high - low) / pip_size

if in_killzone
    if not was_in_killzone
        // Reset stats on session open
        max_sweep_pips := 0.0
        spike_count    := 0
        was_in_killzone := true
    
    // Track maximum liquidity sweep
    if current_sweep_pips > max_sweep_pips
        max_sweep_pips := current_sweep_pips
    
    // Count spikes (only count once per candle to avoid tick-flooding)
    if current_sweep_pips >= spike_thresh and current_sweep_pips[1] < spike_thresh
        spike_count += 1
else
    if was_in_killzone
        was_in_killzone := false

// Highlight the Killzone on the chart
bgcolor(in_killzone ? color.new(color.blue, 95) : na, title="Killzone Background")

// -----------------------------------------------------------------------------
// HUD (HEADS UP DISPLAY)
// -----------------------------------------------------------------------------
var table hud = table.new(position.top_right, 1, 1, bgcolor=color.new(color.black, 20), border_color=color.gray, border_width=1)

if barstate.islast
    string session_status = in_killzone ? 
      "🟢 ACTIVE KILLZONE\nMax Sweep: " + str.tostring(max_sweep_pips, "#.##") + " p\nSpikes: " + str.tostring(spike_count) : 
      "🔴 WAITING FOR OPEN\nLast Max: " + str.tostring(max_sweep_pips, "#.##") + " p"

    string display_text = "--- TRUE COST & LIQUIDITY ---\n" +
                          "Base Comm Cost: " + str.tostring(comm_in_pips, "#.##") + " pips\n" +
                          "-----------------------------------\n" + 
                          session_status
    
    table.cell(hud, 0, 0, display_text, text_color=color.white, text_size=size.normal, text_halign=text.align_left)

[PTScalper]

Why your cTrader/MT5 scripts will always be superior for this:

Keep running the cTrader and MT4/MT5 versions on a cheap VPS. They calculate the spread array locally via direct TCP hookups to the execution server.

When a prop firm flashes a 4-pip spread on GBPJPY for 800 milliseconds right at 08:00:01 London time, the MT5 script logs it instantly. TradingView will never see it because a trade didn't execute at that Ask price to form a candle wick. Use this Pine script to visualize the Killzone and benchmark your baseline commission drag, but rely on your cTrader logs for the raw, unedited truth about platform manipulation.