Order Block Strategy

An "order block" is a price-action concept popularised in the smart-money / ICT trading community. It refers to the last opposing candle (or cluster) right before an impulsive, structure-breaking move — for example the last down-candle before a sharp rally — which traders treat as a reference zone where price may react if it returns. This page explains how traders define, mark, and use order blocks for entries, exits, and risk, and gives a valid Pine Script v6 example. Because the real concept relies on discretionary structure reading and zone "mitigation," it does not reduce to one mechanical strategy, so the script below is an illustrative detection/marker, clearly labelled as such. This is educational only: nothing here predicts price, no profit or win-rate is implied, and trading carries the risk of loss. Terms like "order block," "smart money," and "ICT" are referenced descriptively; any related trademarks belong to their respective owners. To turn your own order-block rules into validated Pine v6 and check them for look-ahead bias and repainting, run them through the ForexCodes Strategy Validator (try it free).

How it works

An order block is not an indicator with a formula — it is a way traders label a specific candle on the chart after the fact. The common definition is: the last candle of the opposite colour immediately before an impulsive move that breaks recent market structure. A bullish order block is the last down-candle before price rallies up and takes out a prior swing high; a bearish order block is the last up-candle before price drops and breaks a prior swing low. The body and/or the full high-low range of that candle is then treated as a "zone."

The reasoning traders attach to it (a narrative, not a mechanism the market is obliged to follow) is that this candle marks an area where a large amount of buying or selling stepped in to start the move. If price later returns to that zone — referred to as the zone being "mitigated" or "tested" — some traders watch for a reaction in the original direction. None of this is predictive; many marked zones are simply traded straight through.

Three pieces have to be defined to make the idea concrete: (1) what counts as the impulsive move and structure break (commonly a close beyond a recent swing high or low, sometimes called a break of structure, BOS); (2) which candle before that move is the order block (typically the last opposite-colour candle); and (3) what counts as a valid "test" of the zone and what would invalidate it (usually a close all the way through the zone against the intended direction). Different traders draw the zone differently (body only vs. full wick), use different swing-detection settings, and add filters such as requiring an unfilled Fair Value Gap nearby or trading only with a higher-timeframe bias.

Because steps (1)–(3) involve choices and discretion — especially deciding when a zone is "fresh," when it has been "mitigated," and when to act on a return — the concept does not collapse into a single mechanical entry rule the way a moving-average crossover does. That is why the script below is an illustrative detection/marker: it locates candidate order blocks from a mechanical structure-break rule and draws them so you can study the idea on a chart, rather than firing automatic trades. It also makes the concept's main hidden danger visible: order blocks are defined by looking back from a confirmed structure break, so it is very easy to code them in a way that repaints or peeks at future bars.

Entry rules

Define structure first: identify recent swing highs and swing lows (e.g. with pivot detection) and require a close beyond one of them to count as an impulsive, structure-breaking move (a break of structure).
Bullish order block: after price closes above a prior swing high, mark the last down-candle (close < open) before that up-move as the candidate zone. The zone is typically the candle's open-to-close body, or its full low-to-high range if you prefer a wider area.
Bearish order block: after price closes below a prior swing low, mark the last up-candle (close > open) before that down-move as the candidate zone.
Treat the zone as a reference area, not an instant signal. Many traders wait for price to trade back into the zone (a 'test' or 'mitigation') and then look for their own confirmation before considering an entry rather than entering the moment the block forms.
Common confluence filters traders add (all discretionary, not part of the core definition): only take zones in the direction of a higher-timeframe bias, require an unfilled Fair Value Gap inside or beside the block, or require a clean break of structure rather than a marginal one.
Only confirm the order block and any test on closed bars (barstate.isconfirmed). A zone identified intrabar can move or disappear before the candle closes.

Exit rules

Invalidation / stop reference: a bullish order block is commonly considered invalid if price closes back below the bottom of the zone (and a bearish block if price closes above the top). Traders often place a protective stop just beyond the far edge of the zone.
Reference target: a frequent choice is the next opposing liquidity pool or structure level — e.g. a prior swing high for a long taken from a bullish block, or a prior swing low for a short from a bearish block.
Fixed risk-to-reward variant: some traders define the exit purely as a multiple of the initial risk (distance from entry to the zone's far edge) so the study is mechanical and repeatable.
Time / structure exit: exit if the underlying idea is broken — for example price closes decisively through the zone against the intended direction, or the broader structure flips against the position.
Whichever exit you choose, fix it before entering. Mixing zone-based, structure-based, and fixed-RR exits after the fact makes any backtest impossible to interpret.

Risk notes

Nothing about an order block is predictive. A clearly marked zone can be — and often is — traded straight through. Trading carries the risk of loss, including loss of capital.
The concept is inherently discretionary: where you place swings, whether you use the body or the full wick, and what counts as 'mitigated' all change which zones appear and how they behave. Two traders applying 'the same' rules can mark different blocks.
Order blocks are identified by looking back from a confirmed move, which makes look-ahead bias and repainting easy to introduce by accident. A zone that looks perfectly timed in hindsight may not have existed when the bar was live.
Behaviour depends heavily on instrument, timeframe, session, spread, and slippage. A setup that looks clean on a higher timeframe can be dominated by costs on a lower one.
Any backtest of an order-block rule set is illustrative only — past behaviour does not indicate future results, and live execution will differ from a simulation.
Position sizing and stop placement determine real-world risk far more than which candle you label as the block; never risk more than you can afford to lose.

Pine v6 example

//@version=6
// Order Block — ILLUSTRATIVE DETECTION / MARKER (educational only).
// The order-block concept relies on discretionary structure reading and zone
// "mitigation", so it does NOT reduce to one mechanical strategy. This script
// only DETECTS and DRAWS candidate order blocks from a simple structure-break
// rule so you can study the idea on a chart. It does not place trades and is
// not predictive. Backtests/visuals are illustrative; past behaviour does not
// indicate future behaviour. Trading involves the risk of loss.
indicator("Order Block (illustrative marker)", overlay = true, max_boxes_count = 60, max_labels_count = 60)

// --- Inputs ---
pivotLen   = input.int(10, "Swing lookback (pivot length)", minval = 2)
searchBack = input.int(50, "Max bars to search back for the block candle", minval = 1, maxval = 300)
useBody    = input.bool(true, "Zone = candle body (off = full high/low range)")
showBoxes  = input.bool(true, "Draw order-block zones")

// --- Structure: confirmed swing highs/lows ---
// ta.pivothigh/low return a value only once the pivot is fully confirmed
// (pivotLen bars after it formed), so they do not repaint on the live bar.
// The returned value already IS the pivot price.
ph = ta.pivothigh(high, pivotLen, pivotLen)
pl = ta.pivotlow(low, pivotLen, pivotLen)

// Track the most recent confirmed swing levels.
var float lastSwingHigh = na
var float lastSwingLow  = na
if not na(ph)
    lastSwingHigh := ph
if not na(pl)
    lastSwingLow := pl

// --- Break of structure on the CURRENT closed bar ---
bullBreak = not na(lastSwingHigh) and close > lastSwingHigh
bearBreak = not na(lastSwingLow) and close < lastSwingLow

// --- Find the order-block candle: last opposite-colour candle before the move ---
// Search back from the previous bar for the most recent qualifying candle.
// Returns the bar offset (>=1), or na if none found within searchBack bars.
findBlock(bool isBull) =>
    int idx = na
    for i = 1 to searchBack
        bool bodyDown = close[i] < open[i]   // down candle
        bool bodyUp   = close[i] > open[i]   // up candle
        if (isBull and bodyDown) or (not isBull and bodyUp)
            idx := i
            break
    idx

// Act only on confirmed (closed) bars to avoid acting on a signal that
// could still change before the bar closes.
if bullBreak and barstate.isconfirmed
    int i = findBlock(true)
    if not na(i)
        float top = useBody ? math.max(open[i], close[i]) : high[i]
        float bot = useBody ? math.min(open[i], close[i]) : low[i]
        if showBoxes
            box.new(bar_index[i], top, bar_index, bot,
                 border_color = color.new(color.teal, 0),
                 bgcolor = color.new(color.teal, 85))
        label.new(bar_index[i], bot, "Bull OB", style = label.style_label_up,
             color = color.new(color.teal, 20), textcolor = color.white, size = size.tiny)

if bearBreak and barstate.isconfirmed
    int i = findBlock(false)
    if not na(i)
        float top = useBody ? math.max(open[i], close[i]) : high[i]
        float bot = useBody ? math.min(open[i], close[i]) : low[i]
        if showBoxes
            box.new(bar_index[i], top, bar_index, bot,
                 border_color = color.new(color.maroon, 0),
                 bgcolor = color.new(color.maroon, 85))
        label.new(bar_index[i], top, "Bear OB", style = label.style_label_down,
             color = color.new(color.maroon, 20), textcolor = color.white, size = size.tiny)

// Markers on the bar where a structure break confirmed a candidate block.
plotshape(bullBreak and barstate.isconfirmed, title = "Bull break",
     style = shape.triangleup, location = location.belowbar,
     color = color.new(color.teal, 0), size = size.tiny)
plotshape(bearBreak and barstate.isconfirmed, title = "Bear break",
     style = shape.triangledown, location = location.abovebar,
     color = color.new(color.maroon, 0), size = size.tiny)

// Educational tool only. Not financial advice and not predictive. Validate any
// order-block strategy for look-ahead bias and repainting with the ForexCodes
// Strategy Validator before reading anything into a backtest.

Pitfalls

Look-ahead / hindsight bias: an order block is defined by looking back from a confirmed structure break, so it is dangerously easy to mark zones using information that did not exist at the time. Always anchor detection to confirmed swings (pivots only resolve pivotLen bars later) and act on closed bars.
Repainting: detecting blocks or 'tests' on the live, unclosed bar makes zones appear, move, and vanish, so the chart you study no longer matches what you could have traded. Gate logic on barstate.isconfirmed.
Discretion masquerading as a rule: 'last opposite candle before the move', 'fresh vs. mitigated', and 'valid test' are judgement calls. If they are not pinned down precisely, the concept is not actually mechanical and results are not reproducible.
Body vs. wick ambiguity: using the candle body gives a tighter zone than the full high-low range. The choice changes every stop and every 'test', so decide once and keep it fixed.
Swing-setting overfitting: nudging the pivot length until the historical zones line up nicely usually just curve-fits past noise and rarely carries forward.
Treating a zone as a guarantee: marked order blocks are reference areas, not forecasts. Price frequently trades straight through them; a returning move proves nothing on its own.
Ignoring costs: lower-timeframe order-block entries are sensitive to spread and slippage, which a naive backtest can understate.
Calling a marker a strategy: this script detects and draws candidate zones — it deliberately does not auto-trade. Wiring it into entries without defining test/invalidation/exit rules would not represent the concept faithfully.

FAQ

What exactly is an order block, in plain terms?

It is a label traders put on a specific candle: the last opposite-colour candle right before an impulsive move that breaks recent market structure. The last down-candle before a strong rally is a bullish order block; the last up-candle before a sharp drop is a bearish one. The candle's body or full range is then treated as a zone price may react to if it returns. It is a way of marking an area of interest, not a formula and not a prediction.

Why is the Pine example a detection/marker instead of a full buy/sell strategy?

Because the real concept is partly discretionary. Deciding what counts as the impulsive move, which candle is the block, when a zone is 'fresh' versus 'mitigated', and what counts as a valid test are all judgement calls that different traders make differently. Forcing all of that into one mechanical strategy would misrepresent the idea, so the script mechanically detects candidate order blocks from a clear structure-break rule and draws them for study, leaving entry timing and exits to you. That is also the honest way to present it.

Do order blocks repaint or look ahead?

They can, very easily, if coded carelessly. An order block is identified by looking back from a confirmed structure break, so a script can accidentally use information that was not available when the bar was live, or mark and un-mark zones intrabar. Anchoring detection to confirmed swing pivots and acting only on closed bars (barstate.isconfirmed) avoids the worst of it. This is exactly the class of bug the ForexCodes Strategy Validator is built to catch — paste your order-block script in (or try it free) to confirm it is clean before you read anything into a backtest.

Is an order block strategy profitable or high win-rate?

We can't and won't make profit or win-rate claims. Nothing about order blocks is predictive — marked zones are frequently traded straight through — and trading carries the risk of loss. It is a framework for organising observations about structure and prior activity. How any specific rule set behaves depends on the instrument, timeframe, costs, and risk management, and even a clean backtest is illustrative only because past behaviour does not indicate future results.

Want this as a clean, validated Pine script? run it through the Validator → or convert a trading strategy to Pine Script →

Educational & software only — not financial advice, not a recommendation to trade. Backtests are illustrative; past performance does not predict future results. Trading involves substantial risk of loss.