Liquidity sweeps and breaks of structure on the S&P 500 open
Micro E-mini S&P 500 (MES) · 1-minute bars · 2016 to 2026 · ICT and liquidity · Popularized by TJR
No edge after costs: profit factor 0.98 out of sample.
- Profit factor, out of sample
- 0.98
- Average trade, out of sample
- −0.03R
- Win rate, out of sample
- 25%
- Trades, 10 years
- 233
- Max drawdown
- $13,985
- Pass odds, median plan
- 0.7%
Hypothetical results. These results are based on simulated or hypothetical performance results that have certain inherent limitations. Unlike the results shown in an actual performance record, these results do not represent actual trading. Also, because these trades have not actually been executed, these results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated or hypothetical trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to these being shown.
Abstract
We backtested the liquidity sweep + break of structure rules on Micro E-mini S&P 500 (MES) 1-minute bars from 2016-01-11 to 2026-10-30: 233 trades, with commission and a tick of slippage on every market and stop fill. In sample (to 2023-08-03) it made −0.21R per trade with a profit factor of 0.75; out of sample (from 2023-08-04) −0.03R per trade and 0.98 over 81 trades. 2 of the 25 parameter settings we tried were profitable out of sample. Sized at $250 of risk a trade, simulated 50K evaluations passed 0% to 2% of the time across 36 tracked plans.
1Hypothesis
Wait for New York to run the stops above an overnight high or below an overnight low, then trade back the other way once a one-minute candle breaks the last swing. Enter on a pullback, stop beyond the sweep, target the next pool of liquidity.
If sweeps of the Asia, London and previous-day highs and lows mark stop runs that reverse, a reversal confirmed by a one-minute break of structure should earn more than its costs, with the stop beyond the sweep's wick.
2Data
- Instrument
- Micro E-mini S&P 500 (MES), traded on the ES price series (ES.c.0: front month, rolled on the calendar). CME Globex via Databento.
- Period
- 2016-01-11 to 2026-10-30: 2,794 sessions, 3,770,901 one-minute bars, built into 3,770,901 1-minute bars around the clock.
- Costs
- $0.75 commission a contract each way and 1 tick ($1.25) of slippage on every market and stop fill. Limit orders fill when price touches them; market orders fill at the next bar's open and stops at their price, each with one tick of slippage; when a bar touches both the stop and the target, the stop counts.
- Position size
- About $250 of risk a trade: micro contracts, rounded down, at least one. R is a trade's net P&L divided by its risk at entry.
- Out of sample
- The last 30% of weekdays: 2023-08-04 on (846 days), after 1,974 in-sample days. The rules were fixed before either side was run.
3Method
Our reading of the publicly described rules; the creator may trade it differently. The rules, exactly as the code runs them:
- Liquidity levels, fixed at the 09:30 ET open: the Asia range high and low (20:00-00:00 ET), the London range high and low (02:00-05:00 ET) and the previous trading day's high and low (the full 18:00-17:00 session). A level counts only if price has not traded through it before 09:30 and it sits on the right side of the open (highs above it, lows below it).
- Sweep: from 09:30 a 1-minute bar trades above a valid high (or below a valid low). The sweep's extreme keeps updating while price makes new highs.
- Break of structure: within confirm_bars (20) bars of the latest extreme, a 1-minute bar closes below the swing low, the lowest low of the bos_lookback (10) bars before the extreme (above the swing high after a low is swept). No break in time: the setup is dropped.
- Entry: a limit order at entry_retrace (50%) of the leg from the sweep's extreme to the break's close, cancelled after entry_expiry_bars (15) bars or if price reaches the target first.
- Stop: stop_buffer_ticks (2) ticks beyond the sweep's wick; no trade if the stop is closer than min_stop_pct (0.05%) or farther than max_stop_pct (0.4%) of price.
- Target: the nearest opposing liquidity (an unswept Asia or London level, the previous day's high or low, or the New York session's extreme so far) at least min_rr (1) R away, capped at max_rr (4) R. No such level: no trade.
- Orders only from 09:35 to 11:30 ET, at most max_trades_per_day (2), flat at 15:50 ET.
- Size: about risk_usd dollars of risk a trade (micro contracts, rounded down, at least 1 and at most max_contracts).
Not modelled: SMT divergence (the engine sees one market per bot), inverse FVGs, the 79% extension,
equal highs and lows, previous-week levels.
bot.py, the file the engine ran
"""Liquidity sweep + break of structure (popularized by TJR), on MES 1-minute bars, New York time. Our reading of the publicly described rules; the creator may trade it differently. Started from theowner's own TJR bot, with risk-based sizing added and its dollar daily stop removed (two trades a dayat most already caps a day's loss). Rules: 1. Liquidity levels, fixed at the 09:30 ET open: the Asia range high and low (20:00-00:00 ET), the London range high and low (02:00-05:00 ET) and the previous trading day's high and low (the full 18:00-17:00 session). A level counts only if price has not traded through it before 09:30 and it sits on the right side of the open (highs above it, lows below it). 2. Sweep: from 09:30 a 1-minute bar trades above a valid high (or below a valid low). The sweep's extreme keeps updating while price makes new highs. 3. Break of structure: within `confirm_bars` (20) bars of the latest extreme, a 1-minute bar closes below the swing low, the lowest low of the `bos_lookback` (10) bars before the extreme (above the swing high after a low is swept). No break in time: the setup is dropped. 4. Entry: a limit order at `entry_retrace` (50%) of the leg from the sweep's extreme to the break's close, cancelled after `entry_expiry_bars` (15) bars or if price reaches the target first. 5. Stop: `stop_buffer_ticks` (2) ticks beyond the sweep's wick; no trade if the stop is closer than `min_stop_pct` (0.05%) or farther than `max_stop_pct` (0.4%) of price. 6. Target: the nearest opposing liquidity (an unswept Asia or London level, the previous day's high or low, or the New York session's extreme so far) at least `min_rr` (1) R away, capped at `max_rr` (4) R. No such level: no trade. 7. Orders only from 09:35 to 11:30 ET, at most `max_trades_per_day` (2), flat at 15:50 ET. 8. Size: about `risk_usd` dollars of risk a trade (micro contracts, rounded down, at least 1 and at most `max_contracts`). Not modelled: SMT divergence (the engine sees one market per bot), inverse FVGs, the 79% extension, equal highs and lows, previous-week levels."""import qy def _hm(dt): return dt.hour * 60 + dt.minute RTH_OPEN, RTH_CLOSE = 9 * 60 + 30, 16 * 60ASIA_START, ASIA_END = 20 * 60, 24 * 60LONDON_START, LONDON_END = 2 * 60, 5 * 60DAY_START = 18 * 60 class Bot(qy.Strategy): """Sweep of Asia, London or previous-day liquidity, then a 1-minute break of structure.""" symbol = "MES" timeframe = "1m" session = None # overnight bars build the Asia and London ranges params = { "bos_lookback": 10, "confirm_bars": 20, "entry_retrace": 0.5, "entry_expiry_bars": 15, "stop_buffer_ticks": 2, "min_stop_pct": 0.05, "max_stop_pct": 0.4, "min_rr": 1.0, "max_rr": 4.0, "max_trades_per_day": 2, "risk_usd": 250, "max_contracts": 50, } max_position = 50 entry_window = ("09:35", "11:30") flatten_time = "15:50" overnight = False # ---------------------------------------------------------------- state def setup(self): self.i = 0 self.prev_high = self.prev_low = None self.day_high = self.day_low = None self._reset_day() def _reset_day(self): self.asia_h = self.asia_l = None self.post_asia_h = self.post_asia_l = None self.london_h = self.london_l = None self.post_london_h = self.post_london_l = None self.on_h = self.on_l = None # overnight 18:00-09:30 self.rth_h = self.rth_l = None self.levels_ready = False self.highs = [] # [(name, price)] unswept buy-side liquidity self.lows = [] # unswept sell-side liquidity self.short_setup = None self.long_setup = None self.pending = None def on_day_start(self, day): if self.day_high is not None: self.prev_high, self.prev_low = self.day_high, self.day_low self.day_high = self.day_low = None self._reset_day() def on_fill(self, fill): self.pending = None # ---------------------------------------------------------------- helpers @staticmethod def _mx(a, b): return b if a is None else max(a, b) @staticmethod def _mn(a, b): return b if a is None else min(a, b) def _tick(self, x): return round(x / self.tick_size) * self.tick_size def _size(self, risk_points): """Micro contracts for about risk_usd of risk: rounded down, at least 1, at most max_contracts.""" per_contract = risk_points * self.point_value n = int(self.p.risk_usd // per_contract) if per_contract > 0 else 1 return max(1, min(self.p.max_contracts, n)) def _swing_low(self): n = self.p.bos_lookback if len(self.low) <= n: return None return min(self.low[k] for k in range(1, n + 1)) def _swing_high(self): n = self.p.bos_lookback if len(self.high) <= n: return None return max(self.high[k] for k in range(1, n + 1)) def _build_levels(self, open_px): cands_h = [("Asia high", self.asia_h, self.post_asia_h), ("London high", self.london_h, self.post_london_h), ("PDH", self.prev_high, self.on_h)] cands_l = [("Asia low", self.asia_l, self.post_asia_l), ("London low", self.london_l, self.post_london_l), ("PDL", self.prev_low, self.on_l)] self.highs = [(n, v) for n, v, after in cands_h if v is not None and (after is None or v > after) and v > open_px] self.lows = [(n, v) for n, v, after in cands_l if v is not None and (after is None or v < after) and v < open_px] self.levels_ready = True for n, v in self.highs: self.hline(n, v, start="09:30", end="15:50", color="green", style="dashed", text=n) for n, v in self.lows: self.hline(n, v, start="09:30", end="15:50", color="red", style="dashed", text=n) def _can_enter(self, t_close): return (575 <= t_close < 690 and self.position.is_flat and self.pending is None and self.trades_today < self.p.max_trades_per_day) # ---------------------------------------------------------------- main def on_bar(self, bar): self.i += 1 t = _hm(bar.dt) h, l, c = bar.high, bar.low, bar.close self.day_high = self._mx(self.day_high, h) self.day_low = self._mn(self.day_low, l) # --- pre-market: build the liquidity map, never trade if t >= DAY_START or t < RTH_OPEN: self.on_h, self.on_l = self._mx(self.on_h, h), self._mn(self.on_l, l) if ASIA_START <= t < ASIA_END: self.asia_h, self.asia_l = self._mx(self.asia_h, h), self._mn(self.asia_l, l) if t < RTH_OPEN and self.asia_h is not None: self.post_asia_h = self._mx(self.post_asia_h, h) self.post_asia_l = self._mn(self.post_asia_l, l) if LONDON_START <= t < LONDON_END: self.london_h, self.london_l = self._mx(self.london_h, h), self._mn(self.london_l, l) if LONDON_END <= t < RTH_OPEN and self.london_h is not None: self.post_london_h = self._mx(self.post_london_h, h) self.post_london_l = self._mn(self.post_london_l, l) return if t >= RTH_CLOSE: return # --- regular session if not self.levels_ready: self._build_levels(bar.open) # a working limit entry: cancel it once it is stale or price reached the target without it if self.pending is not None and self.position.is_flat: pd = self.pending expired = self.i - pd["i"] >= self.p.entry_expiry_bars missed = (l <= pd["target"]) if pd["side"] == "short" else (h >= pd["target"]) if expired or missed: self.cancel_all() self.pending = None t_close = t + 1 self._short_logic(h, l, c, t_close) self._long_logic(h, l, c, t_close) self.rth_h, self.rth_l = self._mx(self.rth_h, h), self._mn(self.rth_l, l) # ---------------------------------------------------------------- short side def _short_logic(self, h, l, c, t_close): s = self.short_setup if s is None: swept = [(n, v) for n, v in self.highs if h > v] if swept and t_close < 690: sw = self._swing_low() if sw is not None: name, level = max(swept, key=lambda x: x[1]) self.short_setup = {"name": name, "level": level, "ext": h, "ext_i": self.i, "swing": sw} self.highs = [(n, v) for n, v in self.highs if h <= v] return if h > s["ext"]: s["ext"], s["ext_i"] = h, self.i sw = self._swing_low() if sw is not None: s["swing"] = sw self.highs = [(n, v) for n, v in self.highs if h <= v] elif c < s["swing"]: self.short_setup = None if self._can_enter(t_close): self._enter_short(s, c) elif self.i - s["ext_i"] > self.p.confirm_bars: self.short_setup = None def _enter_short(self, s, c): entry = self._tick(c + self.p.entry_retrace * (s["ext"] - c)) stop = self._tick(s["ext"] + self.p.stop_buffer_ticks * self.tick_size) risk = stop - entry if risk < self.p.min_stop_pct / 100 * c or risk > self.p.max_stop_pct / 100 * c: return pools = [v for _, v in self.lows] if self.rth_l is not None: pools.append(self.rth_l) pools = sorted((v for v in pools if v < entry), reverse=True) tgt = next((v for v in pools if (entry - v) / risk >= self.p.min_rr), None) if tgt is None: return tgt = self._tick(max(tgt, entry - self.p.max_rr * risk)) depth = round((s["ext"] - s["level"]) / self.tick_size) self.sell(self._size(risk), limit=entry, stop_price=stop, target_price=tgt, tag=f"Sweep {s['name']} short | f={depth}") self.pending = {"side": "short", "i": self.i, "target": tgt} # ---------------------------------------------------------------- long side def _long_logic(self, h, l, c, t_close): s = self.long_setup if s is None: swept = [(n, v) for n, v in self.lows if l < v] if swept and t_close < 690: sw = self._swing_high() if sw is not None: name, level = min(swept, key=lambda x: x[1]) self.long_setup = {"name": name, "level": level, "ext": l, "ext_i": self.i, "swing": sw} self.lows = [(n, v) for n, v in self.lows if l >= v] return if l < s["ext"]: s["ext"], s["ext_i"] = l, self.i sw = self._swing_high() if sw is not None: s["swing"] = sw self.lows = [(n, v) for n, v in self.lows if l >= v] elif c > s["swing"]: self.long_setup = None if self._can_enter(t_close): self._enter_long(s, c) elif self.i - s["ext_i"] > self.p.confirm_bars: self.long_setup = None def _enter_long(self, s, c): entry = self._tick(c - self.p.entry_retrace * (c - s["ext"])) stop = self._tick(s["ext"] - self.p.stop_buffer_ticks * self.tick_size) risk = entry - stop if risk < self.p.min_stop_pct / 100 * c or risk > self.p.max_stop_pct / 100 * c: return pools = [v for _, v in self.highs] if self.rth_h is not None: pools.append(self.rth_h) pools = sorted(v for v in pools if v > entry) tgt = next((v for v in pools if (v - entry) / risk >= self.p.min_rr), None) if tgt is None: return tgt = self._tick(min(tgt, entry + self.p.max_rr * risk)) depth = round((s["level"] - s["ext"]) / self.tick_size) self.buy(self._size(risk), limit=entry, stop_price=stop, target_price=tgt, tag=f"Sweep {s['name']} long | f={depth}") self.pending = {"side": "long", "i": self.i, "target": tgt}4Results
| Statistic | In sample | Out of sample | All |
|---|---|---|---|
| Trades | 152 | 81 | 233 |
| Net P&L | −$7,893 | −$289 | −$8,182 |
| Profit factor | 0.75 | 0.98 | 0.83 |
| Average trade | −0.21R | −0.03R | −0.15R |
| 95% interval of the average | −0.48 to 0.06 | −0.46 to 0.39 | −0.38 to 0.08 |
| t-statistic of trade R | −1.52 | −0.16 | −1.28 |
| Win rate | 26% | 25% | 25% |
| Average win / average loss | 2.17 | 2.99 | 2.44 |
| Max drawdown | $12,436 | $3,724 | $13,985 |
| Sharpe ratio (daily, annualized) | −2.02 | −0.12 | −1.31 |
| Longest losing streak | 12 | 8 | 12 |
| Long / short profit factor | 0.85 / 0.68 | 0.76 / 1.13 | 0.82 / 0.83 |
| Average holding time | 55 min | 46 min | 52 min |
| Commission paid | $3,356 | $968 | $4,323 |
Cumulative P&LDrawdown from the highOut of sample from 2023-08-04
Drag across the chart to zoom into a period, double-click to reset.
In sample (152 trades)Out of sample (81)Averages
Averages: −0.21R in sample, −0.03R out of sample.
In sampleOut of sampleQuintile mean, 95% intervalOLS fitDensity contours
Drag a box to zoom, double-click to reset.
5Robustness
We reran the strategy on a grid of 25 settings of its two main parameters, each on the full history with the same split. 2 were profitable in sample and 2 out of sample.
20
0.98
0.98
1.16
0.82
0.00
15
0.94
0.66
0.64
0.45
0.00
10
0.77
0.81
0.98
0.70
0.00
7
0.67
0.65
0.83
1.04
0.93
5
0.66
0.70
0.81
0.86
0.75
0.30
0.40
0.50
0.62
0.75
Entry retrace across, swing lookback (bars) up. Solid outline: the defaults we tested; dashed: the in-sample best.
Hover a cell for both sides of the split.
Entry retrace 0.30 to 0.75 across · Swing lookback (bars) 5.00 to 20.0 in depth · Profit factor, out of sample 0.00 to 1.16 as height and shade. Drag or use the arrow keys to turn it.
Drag to rotate; ctrl or ⌘ and scroll to zoom.
What would change it
Nothing on the grid helps. Its in-sample best, entry retrace 0.75 and swing lookback (bars) 7, had profit factor 1.34 in sample but 0.93 out of sample, against 0.98 for the defaults.
In-sample yearOut-of-sample year95% interval
Median25th to 75th percentile5th and 95thRuin: down $2,000
6Prop-firm implications
The backtest's sessions run through the rules of 36 tracked 50K evaluations: 2,000 runs of up to 60 sessions each, with the drawdown and daily limits checked against each trade's intraday low. Intervals are Wilson 95% intervals of the simulation. A simulation of the past, not the chance that anyone passes.
| Plan | Pass odds, 95% interval | Pass | Fail | Out of time | Median sessions |
|---|---|---|---|---|---|
| FundedNext Futures Flex Challenge 50K | 1.6% | 9% | 89% | 50 | |
| Alpha Futures Standard 50K Evaluation | 0.7% | 2% | 97% | 50 | |
| Alpha Futures Zero 50K Evaluation | 0.7% | 2% | 97% | 50 | |
| Apex Trader Funding 50K EOD Evaluation | 0.7% | 2% | 97% | 50 | |
| Apex Trader Funding 50K Intraday Trailing Drawdown Evaluation | 0.7% | 6% | 94% | 50 | |
| Bulenox 50K Qualification Account (Legacy, Option 1, trailing drawdown) | 0.7% | 0.9% | 98% | 50 | |
| Bulenox 50K Qualification Account (Legacy, Option 2, EOD drawdown) | 0.7% | 0.2% | 99% | 50 | |
| FTMO Futures Growth 50K Evaluation | 0.7% | 2% | 97% | 50 | |
| FTMO Futures Pro 50K Evaluation | 0.7% | 2% | 97% | 50 | |
| Funded Futures Family 50K Evaluation (standard plan) | 0.7% | 2% | 97% | 50 |
Scale 0 to 10%.
7Limitations
- One market (MES); the creator also uses SMT divergence between markets, which a single-market bot can't see.
- The rules are our reading of public videos; discretion such as skipping news days isn't modelled.
- Limit orders fill on a touch, which flatters entries a little; a real queue may not fill at the price.
- Stops this tight make costs large: commission and slippage are a bigger share of each trade's risk than on wider-stop strategies.
- A backtest on the past, with fills simulated from one-minute bars; live fills, queues and outages differ.
8Conclusion
No edge after costs: profit factor 0.98 out of sample. Nothing on the grid helps. Its in-sample best, entry retrace 0.75 and swing lookback (bars) 7, had profit factor 1.34 in sample but 0.93 out of sample, against 0.98 for the defaults. On this reading of the rules, with these costs, the historical record gives no reason to expect a profit.