Liquidity Sweeps and Failure Tests: Reclaims, Wick Stops and Risk

Video: The ONLY Liquidity Sweep Trading Strategy Beginners Need…
Creator: Mind Math Money
Original Video: Watch the original video
Difficulty: Intermediate

The Big Idea

A failure test occurs when price briefly moves beyond a support or resistance level, then closes back inside the structure. Mind Math Money presents it as an alternative to entering the initial breakout: wait for the failed attempt and trade the return instead.

The observable pattern is a break and reclaim. The accompanying story about institutions selling into breakout buyers and triggering their stops is an explanation offered by the presenter. An ordinary price chart does not identify the participants, their orders or their intent. The research question is whether the defined price pattern produces useful outcomes after realistic costs, not whether a wick proves that someone hunted stops.

The Source Rules

The presenter prefers a level with approximately two or three previous touches but says one touch can also be usable. That is a preference, not an absolute universal requirement. The touches must also be interpreted in context: repeated contact can accompany pressure toward a real breakout.

The transcript’s triangle explanation contains inconsistent wording about the direction of the highs or lows. Rather than treating that passage as a precise triangle rule, retain the practical warning: a level approached under sustained directional pressure may fail as a reversal reference.

Choose the Level Before the Sweep

The support or resistance reference must exist before the signal. Drawing the level after seeing a successful reversal can make a weak method look much better than it was in real time. Record the level, how it was selected, and what counts as a touch before measuring the next attempted break.

A visual zone may be more appropriate than a single exact price, but a zone introduces further choices. Does the wick need to exceed its outer edge? Must the candle close beyond the inner edge when it reclaims? Small changes can change which bars qualify, especially around spread and tick-size boundaries.

The baseline below uses prior rolling highs and lows to make the reference explicit. That is a mechanical substitute for the presenter’s hand-drawn levels. It does not automatically distinguish a stable range from a channel, a triangle or a trending market.

Two Contexts in the Video

A bullish pullback: The presenter shows a failure below support within a bull-flag pullback after an upward impulse. Here the failure test is the entry method and the pullback supplies the broader structure. This is different from buying every lower wick on an arbitrary chart.

A trading range: The Ethereum example illustrates failed attempts at both the upper and lower boundaries. The lower-boundary example has a hammer-like candle and reclaims support, yet the trade does not move smoothly toward its target. The presenter acknowledges that the example could have failed.

These contexts should be studied separately. A failure at the edge of a broad sideways range and a failure inside a continuation pullback may depend on different market conditions. The supplied transcript does not provide a mechanical bull-flag classifier or complete trend filter, so the research script does not claim to recreate that context.

Entry, Stop and Target

The close back inside the structure is what separates this setup from an unconfirmed wick through a level. Until the candle closes, price can still finish beyond support or resistance. Waiting for the close changes both the available information and the entry price.

The stop belongs past the extreme of the failed attempt, with an explicit buffer appropriate to the instrument. For an illustrative long at $50 with a $49 stop, planned price-distance risk is $1 per share and a 2R target is $52. A fill at $50.10 or a stop fill below $49 changes the realized multiple. This arithmetic does not guarantee the target is reachable.

The opposite range boundary also matters. A nominal 2R objective extending past nearby resistance asks price to accomplish more than merely cross the range. The video notes a target before resistance in one example; it does not establish a universal rule to reject every target beyond the boundary. That choice should be made explicitly in a research variant.

Make the Hypothesis Reproducible

The independent baseline uses the highest high and lowest low of the previous 20 completed bars. It excludes the current signal candle from the reference calculation. A bullish signal requires the current low to break below prior support and the close to return strictly inside the prior range. A bearish signal mirrors that logic. The previous close must also have been inside the range.

Prior touches are measured against the same fixed boundary used for that signal, with a tolerance of 0.15 times prior 14-period ATR. Consecutive touching candles count as one episode. The default minimum is two episodes. The rolling window, tolerance and episode definition are research assumptions, not settings supplied by the creator.

The model restricts the failed attempt and reclaim to the same candle. It does not implement multi-candle break-and-return sequences. If a single candle qualifies at both boundaries, it is skipped rather than assigning an arbitrary directional preference.

The default experiment is long-only, with optional shorts, no pyramiding and a single frozen stop/target bracket. An optional setting requires the 2R target to sit before the opposite range boundary; it is off by default so that filter can be assessed independently.

Pine Script Research Baseline

//@version=6
strategy("CandleChasers Failure Test Range Proxy", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, pyramiding=0, commission_type=strategy.commission.percent, commission_value=0.05, slippage=1, process_orders_on_close=true)
// Independent rolling-range proxy, not an institutional-order detector.
length = input.int(20, "Prior range bars", minval=5, maxval=250)
minTouches = input.int(2, "Minimum separate touch episodes", minval=1, maxval=10)
touchATR = input.float(0.15, "Touch tolerance / prior ATR", minval=0, step=0.05)
reward = input.float(2.0, "Signal-close target multiple", minval=0.1, step=0.5)
allowShorts = input.bool(false, "Enable short experiments")
requireTargetInside = input.bool(false, "Require target before opposite range boundary")
upper = ta.highest(high, length)[1]
lower = ta.lowest(low, length)[1]
atr = ta.atr(14)[1]
tolerance = touchATR * atr
// A consecutive cluster counts once. Levels are fixed for this signal's scan.
countTouches(float level, bool support, float allowance) =>
    int episodes = 0
    bool inCluster = false
    for i = 1 to length
        float point = support ? low[i] : high[i]
        bool hit = not na(point) and math.abs(point - level) <= allowance
        if hit and not inCluster
            episodes += 1
        inCluster := hit
    episodes
lowerTouches = countTouches(lower, true, tolerance)
upperTouches = countTouches(upper, false, tolerance)
ready = bar_index >= length + 14 and not na(atr) and atr > 0 and upper > lower
previousInside = close[1] >= lower and close[1] <= upper
longFailure = ready and previousInside and lowerTouches >= minTouches and low < lower and close > lower and close < upper
shortFailure = ready and previousInside and upperTouches >= minTouches and high > upper and close < upper and close > lower
bothSides = longFailure and shortFailure
var float fixedStop = na
var float fixedTarget = na
closedThisBar = strategy.closedtrades > nz(strategy.closedtrades[1], 0)
if barstate.isconfirmed and strategy.position_size == 0 and not closedThisBar and not bothSides
    if longFailure
        float stopCandidate = low - syminfo.mintick
        float targetCandidate = close + reward * (close - stopCandidate)
        if not requireTargetInside or targetCandidate < upper
            fixedStop := stopCandidate
            fixedTarget := targetCandidate
            strategy.entry("Long failure", strategy.long)
            strategy.exit("Long bracket", "Long failure", stop=fixedStop, limit=fixedTarget)
    else if allowShorts and shortFailure
        float stopCandidate = high + syminfo.mintick
        float targetCandidate = close - reward * (stopCandidate - close)
        if not requireTargetInside or targetCandidate > lower
            fixedStop := stopCandidate
            fixedTarget := targetCandidate
            strategy.entry("Short failure", strategy.short)
            strategy.exit("Short bracket", "Short failure", stop=fixedStop, limit=fixedTarget)
if strategy.position_size > 0
    strategy.exit("Long bracket", "Long failure", stop=fixedStop, limit=fixedTarget)
if strategy.position_size < 0
    strategy.exit("Short bracket", "Short failure", stop=fixedStop, limit=fixedTarget)
plot(upper, "Prior rolling resistance", color=color.red)
plot(lower, "Prior rolling support", color=color.green)
plot(strategy.position_size != 0 ? fixedStop : na, "Frozen wick stop", color=color.orange, style=plot.style_linebr)
plot(strategy.position_size != 0 ? fixedTarget : na, "Frozen target", color=color.blue, style=plot.style_linebr)

This complete Pine Script v6 strategy models entries at the confirmed signal close. Use standard candles. It applies 10% equity exposure per trade, illustrative commission of 0.05% per order and one tick of slippage. Exposure sizing is not fixed-risk sizing: larger reclaim candles produce larger stop-distance risk for the same exposure.

Validation status: The script has not been compiled in TradingView or backtested here. No win rate, return, drawdown or proven trading edge is claimed.

Execution Assumptions to Inspect

Modeling an order at the same closing tick as the completed signal can be optimistic for a live decision made only after that close, particularly at the end of a stock session. Compare a next-bar-entry variant before treating a historical result as an achievable fill sequence. TradingView’s strategy documentation (paid link) explains that order timing and broker-emulator assumptions affect simulated results.

The stop and target are calculated from the signal close and frozen. Slippage changes the actual entry price, so the realized fill-to-stop ratio need not equal exactly 2:1. The bracket is submitted with the entry rather than waiting until the next completed candle. No trailing stop, discretionary stop widening or confirmation add is implemented.

The script has no time exit or forced session close. A position can remain open overnight, and an unfinished final trade is not a completed result. If both bracket prices are touched within one historical candle, inspect the intrabar fill assumptions. A gap through the stop may produce more than the intended loss.

Because the range is recalculated on each new bar, the plotted boundaries can move during a trade. The trade’s stop and target do not follow those moving lines. This distinction prevents an after-entry recalculation from quietly redefining the original risk.

A Useful Testing Plan

Choose a documented market sample, timeframe, session setting and date interval before optimizing thresholds. The video includes cryptocurrency and day-trading examples. Applying the concept to daily stocks is a separate adaptation, not a reproduction of its intraday examples; gaps, session boundaries and overnight exposure deserve particular attention.

Compare one-, two- and three-touch requirements on training data, then evaluate the chosen rule on later data. Hold costs, sizing, stop placement and target multiple constant. Also compare the opposite-boundary target filter on and off. Evaluate whether it removes losing trades, profitable trades or simply most opportunities.

Report total signals, completed trades, net expectancy, average win/loss, drawdown and time in market. Distinguish range reversals from trend-continuation pullbacks instead of pooling them into one flattering statistic. Include failed examples and inspect sensitivity to a small change in the range window or touch tolerance.

A fixed-outcome system winning 2R and losing 1R breaks even at a one-third win rate before costs. That arithmetic is not a forecast of this pattern’s win rate. Fees, slippage, gaps and unfinished trades mean actual outcomes need not equal those idealized multiples.

Common Failure Modes

• A real breakout resumes: Reclaiming the range once does not guarantee price will stay there.
• A trend is mislabeled as a range: Rolling extremes alone do not establish sideways equilibrium.
• Touches are counted inconsistently: A cluster of adjacent candles is not necessarily several independent tests.
• The reference is chosen afterward: A level drawn around a known reversal introduces hindsight.
• The wick makes risk too large: An attractive-looking reclaim may have an impractical stop distance.
• Execution consumes the edge: Spread and slippage matter around small levels and narrow stop buffers.

Final Takeaway

The failure test offers a clear sequence to study: identify a reference in advance, observe an attempted break, wait for a close back inside, and define invalidation beyond the failed attempt’s extreme. Context and execution determine whether that sequence is useful.

The supplied examples support an explanation of the setup, not a universal claim that it is the only strategy beginners need. Treat the institutional narrative as a hypothesis and the script as an independent price-pattern experiment.

Risk Disclosure

This article is educational and is not personalized investment advice. Trading can cause substantial losses. Stop orders do not guarantee prices, and gaps, slippage and liquidity constraints can exceed planned risk. Short selling adds borrowing constraints and potentially unlimited loss. Historical simulations and selected examples do not guarantee future results.

Independence

CandleChasers is not affiliated with Mind Math Money or TradingView. This guide summarizes the supplied transcript without endorsing the creator’s course or performance claims. The research script is independently written and does not identify institutional orders or trader intent.