The IC Markets "Dump": Surviving Spread Spikes & My Ultimate Scalping Setup Dump

[PTScalper]

Hi traders, scalpers,

I've been seeing a lot of threads popping up lately about "IC Markets dumps"—people complaining about sudden price drops, massive spread spikes taking out tight stop-losses, and general slippage during volatile sessions. Since scalping is literally our bread and butter here, I decided to do a massive knowledge dump on what is actually happening at IC Markets, how to avoid getting wrecked by liquidity dumps, and how to optimize your setup for 2026.

Here is the breakdown:

1. The "Midnight Spread Dump" (Why your stops are getting hunted)

If you are swing trading, you might not care, but as scalpers, a 2-pip variation can completely ruin a risk-to-reward ratio. The most common "dump" people experience on IC isn't the broker actively trading against you (they are a true ECN broker routing massive volume through Equinix NY4 servers). It is the liquidity dump at 00:00 GMT server time (Daily Rollover).

During this 30 to 60-second window, banks reset their books. Liquidity vanishes, and spreads on pairs like EUR/USD or GBP/JPY can violently dump from 0.0 pips up to 10–20 pips.

The Fix: Never hold tight scalps over the daily rollover. Close everything out by 23:55 GMT. If you absolutely have to hold a position open, disable your tight stop-loss temporarily or widen it drastically to survive the spread widening.

[PTScalper]

2. The News Flash-Dumps

The other massive dump happens during high-impact news (NFP, CPI, FOMC). You hit buy/sell, and you get filled 5 pips away from your target. Again, this is an order book reality. During major economic releases, Tier-1 liquidity providers (LPs) pull their limit orders to protect themselves, leaving a gaping hole in the order book.

The Fix: Stop trading 15 minutes before Tier-1 news and wait until 5 to 10 minutes after the release. Scalping requires absolute predictability; trading into a news dump is just gambling on the spread.

[PTScalper]

3. My Ultimate IC Markets Setup Dump (How to actually scalp here)

If you want to scalp IC Markets profitably, you need every technical edge you can get. Here is my optimized setup:

Account Type: Raw Spread Account. Do not touch the Standard account. If you are targeting a 3–10 pip move, a 0.7 pip spread on a Standard account will eat up to 27% of your potential profit. On Raw Spread, EUR/USD comfortably sits at 0.0 to 0.1 pips during the London and NY sessions.

Platform: cTrader. I know many of you are heavily invested in MT4/MT5 Expert Advisors, but cTrader is objectively superior for manual scalpers. It natively displays the spread on the chart, has incredibly fast one-click execution, and most importantly, offers Level II Market Depth (DOM) so you can actually read the real-time order book.

VPS: If you are running high-frequency EAs, rent a VPS physically located in the Equinix NY4 data center in New York. You want your latency to be under 5 milliseconds. IC Markets averages execution speeds under 40 milliseconds, but minimizing your end of the lag is critical.

[PTScalper]

4. The Commission Hack (Save your profits)

Scalpers trade ridiculous volume. If you are doing 50 lots a day, standard IC Markets commissions ($7 per round lot on MT4) will bleed your account dry over a month.

The Fix: Connect your account to an Introducing Broker (IB) or a reputable rebate provider. You can get up to a 21% discount on commissions. Saving $1.50 per lot when you are trading 50 lots a day equals $75 saved daily ($1,500/month). For a scalper, this is often the difference between a break-even system and a highly profitable one.

[PTScalper]

5. Best Pairs & Time Windows

Don't force trades in dead markets. Avoid scalping European pairs during the Asian session as the wider spreads will slowly drain your account.

The Sweet Spot: The London-New York overlap (13:00 - 16:00 GMT). This is when global liquidity is at its absolute deepest, and spreads are non-existent.

Top Pairs: Stick strictly to EUR/USD (0.0 - 0.1 pips), USD/JPY (0.0 - 0.2 pips), and GBP/USD (0.1 - 0.3 pips). If you like to scalp Gold (XAU/USD), be prepared for 0.5 to 1.5 pip spreads, which requires adjusting your stop-loss buffers accordingly.

TL;DR: IC Markets isn't maliciously "dumping" on your trades, but standard liquidity drops and spread spikes will absolutely wreck you if you aren't managing your execution times. Move to a Raw Spread cTrader account, secure a commission rebate, and avoid 00:00 GMT like the plague.

What has your experience been lately? Has anyone noticed worse slippage during the US open this month, or is it just me? Drop your EA settings, experiences, or rants below! Let's discuss.

[PTScalper]

Here is a complete cTrader Automate C# script (cBot) designed to act as a utility protector for your account. You can attach it to any chart to monitor spreads in real-time and automatically liquidate open positions before the massive midnight liquidity drop.

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class ICMarketsScalpProtector : Robot
    {
        [Parameter("Close Before Midnight (Rollover)?", DefaultValue = true, Group = "Rollover Protection")]
        public bool EnableRolloverProtection { get; set; }

        [Parameter("Close Hour (Server Time / UTC)", DefaultValue = 23, MinValue = 0, MaxValue = 23, Group = "Rollover Protection")]
        public int RolloverHour { get; set; }

        [Parameter("Close Minute (Server Time / UTC)", DefaultValue = 55, MinValue = 0, MaxValue = 59, Group = "Rollover Protection")]
        public int RolloverMinute { get; set; }

        [Parameter("Max Allowed Spread (Pips)", DefaultValue = 1.0, Group = "Spread Monitor")]
        public double MaxSpreadPips { get; set; }

        [Parameter("Auto-Close Trades on High Spread?", DefaultValue = false, Group = "Spread Monitor")]
        public bool CloseOnHighSpread { get; set; }

        private bool _hasClosedForRollover = false;

        protected override void OnStart()
        {
            Print("IC Markets Scalp Protector Started. Server Time: {0}", Server.Time);
        }

        protected override void OnTick()
        {
            MonitorSpread();
            CheckRollover();
        }

        private void MonitorSpread()
        {
            // Calculate real-time spread in pips
            double currentSpread = Math.Round(Symbol.Spread / Symbol.PipSize, 1);
            
            if (currentSpread > MaxSpreadPips)
            {
                Chart.DrawStaticText("SpreadAlert", string.Format("⚠️ SPREAD SPIKE: {0} Pips! (Max: {1})", currentSpread, MaxSpreadPips), VerticalAlignment.Top, HorizontalAlignment.Left, Color.Red);
                
                // WARNING: Closing during a spread spike guarantees you will pay the massive spread.
                // Leave this parameter 'false' unless you specifically want to bail out during news events.
                if (CloseOnHighSpread)
                {
                    CloseAllSymbolPositions("Spread Spike");
                }
            }
            else
            {
                Chart.DrawStaticText("SpreadAlert", string.Format("✅ Spread: {0} Pips (Safe)", currentSpread), VerticalAlignment.Top, HorizontalAlignment.Left, Color.LimeGreen);
            }
        }

        private void CheckRollover()
        {
            if (!EnableRolloverProtection) return;

            // Check if current server time is within the rollover danger window (e.g. 23:55 to 23:59)
            if (Server.Time.Hour == RolloverHour && Server.Time.Minute >= RolloverMinute)
            {
                if (!_hasClosedForRollover)
                {
                    Print("⚠️️ Midnight rollover approach detected. Liquidating all open positions for {0}.", SymbolName);
                    CloseAllSymbolPositions("Rollover Auto-Close");
                    _hasClosedForRollover = true;
                }
                
                Chart.DrawStaticText("RolloverAlert", "⛔ TRADING LOCKED: Daily Rollover In Progress", VerticalAlignment.Bottom, HorizontalAlignment.Left, Color.Orange);
            }
            else
            {
                // Reset flag and remove chart text for the next trading day once the rollover hour passes
                _hasClosedForRollover = false;
                Chart.DrawStaticText("RolloverAlert", "", VerticalAlignment.Bottom, HorizontalAlignment.Left, Color.Transparent);
            }
        }

        private void CloseAllSymbolPositions(string reason)
        {
            // Finds all active positions matching the chart's symbol, including manual trades
            var openPositions = Positions.Where(p => p.SymbolName == SymbolName).ToList();
            
            foreach (var position in openPositions)
            {
                Print("Closing Position {0} due to: {1}", position.Id, reason);
                ClosePositionAsync(position);
            }
        }
        
        // UTILITY METHOD: You can call this logic in your own entry bots to block bad trades
        public bool IsSafeToTrade()
        {
            double currentSpread = Symbol.Spread / Symbol.PipSize;
            if (currentSpread > MaxSpreadPips) return false;
            
            if (EnableRolloverProtection && Server.Time.Hour == RolloverHour && Server.Time.Minute >= RolloverMinute) return false;
            
            return true;
        }
    }
}

[PTScalper]

How this script fixes the "Dump"

The 23:55 Auto-Close: The core feature checks Server.Time to identify the daily rollover window. It automatically triggers ClosePositionAsync() at exactly 23:55 UTC. This ensures you never have a scalping position open when the order book empties at midnight and stops out tight stop-losses.

Real-Time Spread HUD: The script calculates Symbol.Spread / Symbol.PipSize on every tick. It paints a green, non-intrusive status on your chart. If Tier-1 news drops or liquidity vanishes, the text turns bright red so you know visually to keep your hands off the mouse.

Manual & EA Coverage: Because it uses Positions.Where(p => p.SymbolName == SymbolName), this script acts as an overarching account supervisor. It will find and kill any open trade for that pair, regardless of whether you opened it manually with cTrader's one-click feature or if another EA opened it.

[PTScalper]

Installation Steps

1.) Open cTrader and click on the Automate tab on the left-side panel.

2.) Click the New cBot button and name it ICMarketsScalpProtector.

3.) Delete the default code template and paste the C# script above.

4.) Press Ctrl + B (or click the Build icon at the top) to compile the algorithm.

5.) Under the cBot tab, click Add Instance, select your target pair (e.g., EURUSD), configure your max spread parameter, and click play.

[PTScalper]

To integrate a live economic calendar into your cTrader bot, you must elevate its network permissions and parse an external JSON feed. The easiest and most reliable free feed used by the cTrader community is the Forex Factory JSON API (nfs.faireconomy.media).

Here is the fully modified ICMarketsScalpProtector script.

Code: Select all

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.Json;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    // MUST be set to FullAccess to allow HTTP requests
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]
    public class ICMarketsScalpProtector : Robot
    {
        [Parameter("Enable Rollover Protection?", DefaultValue = true, Group = "Rollover")]
        public bool EnableRolloverProtection { get; set; }

        [Parameter("Close Hour (UTC)", DefaultValue = 23, MinValue = 0, MaxValue = 23, Group = "Rollover")]
        public int RolloverHour { get; set; }

        [Parameter("Close Minute (UTC)", DefaultValue = 55, MinValue = 0, MaxValue = 59, Group = "Rollover")]
        public int RolloverMinute { get; set; }

        [Parameter("Max Spread (Pips)", DefaultValue = 1.0, Group = "Spread")]
        public double MaxSpreadPips { get; set; }

        [Parameter("Enable News Protection?", DefaultValue = true, Group = "News Filter")]
        public bool EnableNewsProtection { get; set; }

        [Parameter("Pause Minutes BEFORE News", DefaultValue = 15, MinValue = 1, Group = "News Filter")]
        public int PauseMinutesBefore { get; set; }

        [Parameter("Pause Minutes AFTER News", DefaultValue = 15, MinValue = 1, Group = "News Filter")]
        public int PauseMinutesAfter { get; set; }

        private bool _hasClosedForRollover = false;
        private List<NewsEvent> _highImpactEvents = new List<NewsEvent>();
        private string _baseCurrency;
        private string _quoteCurrency;

        // Class structure matching the Forex Factory JSON layout
        public class NewsEvent
        {
            public string title { get; set; }
            public string country { get; set; }
            public string date { get; set; } 
            public string impact { get; set; }
        }

        protected override void OnStart()
        {
            _baseCurrency = SymbolName.Substring(0, 3);
            _quoteCurrency = SymbolName.Substring(3, 3);
            
            Print("IC Markets Protector Started. Extracting currencies: {0} / {1}", _baseCurrency, _quoteCurrency);
            
            if (EnableNewsProtection)
            {
                FetchWeeklyNews();
            }
        }

        protected override void OnTick()
        {
            MonitorSpread();
            CheckRollover();
            
            if (EnableNewsProtection)
            {
                CheckNewsWindow();
            }
        }

        private void FetchWeeklyNews()
        {
            try
            {
                // cAlgo's built-in Http method for API calls
                var response = Http.Get("https://nfs.faireconomy.media/ff_calendar_thisweek.json");
                
                if (response.IsSuccessful)
                {
                    var allEvents = JsonSerializer.Deserialize<List<NewsEvent>>(response.Body);
                    
                    // Filter only "High" impact news for the pair on this chart
                    _highImpactEvents = allEvents.Where(e => 
                        e.impact == "High" && 
                        (e.country == _baseCurrency || e.country == _quoteCurrency)
                    ).ToList();
                    
                    Print("Loaded {0} high-impact events for {1} this week.", _highImpactEvents.Count, SymbolName);
                }
                else
                {
                    Print("Failed to fetch news data. Server returned status: " + response.StatusCode);
                }
            }
            catch (Exception ex)
            {
                Print("API Error fetching calendar: " + ex.Message);
            }
        }

        private void CheckNewsWindow()
        {
            foreach (var newsEvent in _highImpactEvents)
            {
                if (DateTime.TryParse(newsEvent.date, out DateTime eventTimeUtc))
                {
                    eventTimeUtc = eventTimeUtc.ToUniversalTime();
                    var timeUntilNews = eventTimeUtc - Server.Time;
                    
                    // If we are inside the defined news window
                    if (timeUntilNews.TotalMinutes <= PauseMinutesBefore && timeUntilNews.TotalMinutes >= -PauseMinutesAfter)
                    {
                        Chart.DrawStaticText("NewsAlert", $"🚨 NEWS FREEZE: {newsEvent.title} ({newsEvent.country})", VerticalAlignment.Bottom, HorizontalAlignment.Right, Color.Red);
                        
                        // Close open positions to protect capital during the flash dump
                        CloseAllSymbolPositions("High-Impact News Release");
                        return; // Exit out, we are in a news freeze
                    }
                }
            }
            // Clear text if safe
            Chart.DrawStaticText("NewsAlert", "", VerticalAlignment.Bottom, HorizontalAlignment.Right, Color.Transparent);
        }

        private void MonitorSpread()
        {
            double currentSpread = Math.Round(Symbol.Spread / Symbol.PipSize, 1);
            if (currentSpread > MaxSpreadPips)
            {
                Chart.DrawStaticText("SpreadAlert", $"⚠️ SPREAD: {currentSpread} Pips", VerticalAlignment.Top, HorizontalAlignment.Left, Color.Red);
            }
            else
            {
                Chart.DrawStaticText("SpreadAlert", $"✅ SPREAD: {currentSpread} Pips", VerticalAlignment.Top, HorizontalAlignment.Left, Color.LimeGreen);
            }
        }

        private void CheckRollover()
        {
            if (!EnableRolloverProtection) return;

            if (Server.Time.Hour == RolloverHour && Server.Time.Minute >= RolloverMinute)
            {
                if (!_hasClosedForRollover)
                {
                    CloseAllSymbolPositions("Rollover Auto-Close");
                    _hasClosedForRollover = true;
                }
                Chart.DrawStaticText("RolloverAlert", "⛔ TRADING LOCKED: Daily Rollover", VerticalAlignment.Bottom, HorizontalAlignment.Left, Color.Orange);
            }
            else
            {
                _hasClosedForRollover = false;
                Chart.DrawStaticText("RolloverAlert", "", VerticalAlignment.Bottom, HorizontalAlignment.Left, Color.Transparent);
            }
        }

        private void CloseAllSymbolPositions(string reason)
        {
            var openPositions = Positions.Where(p => p.SymbolName == SymbolName).ToList();
            foreach (var position in openPositions)
            {
                Print("Closing Position {0} due to: {1}", position.Id, reason);
                ClosePositionAsync(position);
            }
        }
        
        public bool IsSafeToTrade()
        {
            double currentSpread = Symbol.Spread / Symbol.PipSize;
            if (currentSpread > MaxSpreadPips) return false;
            
            if (EnableRolloverProtection && Server.Time.Hour == RolloverHour && Server.Time.Minute >= RolloverMinute) return false;
            
            if (EnableNewsProtection)
            {
                foreach (var newsEvent in _highImpactEvents)
                {
                    if (DateTime.TryParse(newsEvent.date, out DateTime eventTimeUtc))
                    {
                        var timeUntilNews = eventTimeUtc.ToUniversalTime() - Server.Time;
                        if (timeUntilNews.TotalMinutes <= PauseMinutesBefore && timeUntilNews.TotalMinutes >= -PauseMinutesAfter)
                            return false; 
                    }
                }
            }
            return true;
        }
    }
}

[PTScalper]

2. Key Modifications Explained

Elevated Permissions (FullAccess): The robot attribute at the top of the file is changed to [Robot(AccessRights = AccessRights.FullAccess)]. This is mandatory; without it, cTrader blocks bots from executing API requests.

JSON Deserialization: The System.Text.Json library translates the web request body directly into a list of the custom NewsEvent C# objects.

Targeted Filtering: The FetchWeeklyNews() method parses your current chart symbol (e.g., slicing EURUSD into EUR and USD). It then ignores global noise and grabs only "High" impact events that affect your pair.

Automated Liquidation Window: During OnTick(), the logic evaluates the distance from the server time to the UTC news time. If the time difference breaches your PauseMinutesBefore threshold, the script triggers the CloseAllSymbolPositions() function and paints a bright red warning on your chart.