True Order Blocks & Liquidity LevelsTrue Order Blocks & Liquidity Levels — a comprehensive price action toolkit for market structure analysis, liquidity mapping, and institutional zone detection across any instrument and timeframe.
The logic behind order blocks, imbalances, and internal pullbacks is built in strict accordance with the inside bar methodology — one of the most precise approaches to identifying institutional points of interest. Every module accounts for whether a bar is an inside bar, which significantly improves signal quality and eliminates false zones that commonly appear with traditional approaches.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MODULES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
▸ Internal Pullbacks
Displays market structure as lines connecting sequential pivot highs and lows. Inside bars are ignored during structure building, keeping pullback lines clean and noise-free. The last open line redraws in real time as price develops.
Adjustable number of visible lines
Color, style (solid / dashed / dotted) and width customization
▸ Internal Liquidity
Horizontal lines automatically placed at each confirmed pivot high and low. A line persists until price crosses it — at that moment the line is removed and an alert fires. These levels mark clusters of stop orders and serve as potential targets for liquidity sweeps.
Independent limit on the number of visible levels
Color and style customization
Alert on level breach
▸ Imbalance (FVG)
Fair Value Gap detector built on three consecutive non-inside bars. The algorithm steps over inside bars when searching for the FVG — this means the gap can span more than 3 candles visually if inside bars appear in between, which is intentional and produces cleaner zones. Open-price gaps are handled by clipping FVG boundaries to the body of the middle candle.
Separate colors for bullish and bearish FVG zones
Maximum number of displayed zones
Midline drawn inside each zone for easier reference
▸ Order Blocks
Institutional interest zones formed by a strict algorithm: an order block is drawn only when the bar preceding a FVG performed a liquidity sweep — meaning it broke the high or low of the prior significant pivot. The block is placed on the candle immediately preceding the impulsive move. If an absorption candle stands between the OB candidate and the FVG, the candidate is reset — preventing false blocks from forming on overly aggressive moves.
Automatic mitigation tracking: when price touches the zone, the block changes to a "mitigated" color
Option to hide mitigated blocks entirely
Separate colors for bullish, bearish, and mitigated blocks
Adjustable history depth
Alerts on new block formation and on mitigation
▸ Inside Bars
Highlights bars that fit entirely within the range of the previous mother candle. A series of consecutive inside bars signals compression and accumulation ahead of a directional move.
Barcolor highlight with customizable color
Adjustable lookback depth
▸ Absorption
Marks candles that fully engulf the range of the previous mother candle (high > mother high and low < mother low). These candles often indicate absorption of accumulated positions and a short-term shift in intent.
Separate highlight color independent of Inside Bars
Alert on absorption candle formation
▸ PDH / PDL — Previous Day High & Low
Displays high and low levels from previous trading days (up to 7 days). Levels that have been fully engulfed by price are automatically hidden. Each level is labeled: the most recent is marked "PDH" / "PDL", older ones show the date in month/day format.
Adjustable number of days displayed
Unified color for all PDH/PDL levels
Alert when price crosses a level
▸ Market Sessions
Draws session boxes for each trading session over the last N days. Five fully independent sessions are supported — defaults are Asia, Frankfurt, London, New York, and one custom user-defined session.
Custom name, start and end time (UTC), and background color per session
Optional horizontal border lines showing session high and low
Border style and width customization
Adjustable display depth (number of days)
Alerts when price crosses the high or low of a closed session
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TREND FILTER
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Colors the chart background based on WaveTrend oscillator alignment across up to three independent timeframes. When all selected timeframes show WT above zero simultaneously — bullish background. When all show WT below zero — bearish background. When timeframes disagree — no background, signalling an unclear or transitional market state.
How WaveTrend is calculated: WT is built as a double-smoothed normalized channel index on HLC3. The first EMA measures the average deviation of price from its mean; the result is normalized and smoothed again to produce the final oscillator value. Values above zero indicate bullish bias, below zero — bearish.
Show trend filter — master on/off switch
WT Channel Length — EMA length for channel calculation. Shorter = more reactive
WT Average Length — smoothing EMA applied on top. Larger = calmer signal
TF 1 / TF 2 / TF 3 — each row has an enable toggle and a timeframe selector. Defaults: 15m, 1h, 4h. A disabled timeframe is treated as neutral and excluded from alignment check
Confirm trend on bar close — when enabled, background and alerts only react to values from the last closed HTF bar, eliminating intra-bar repainting. When disabled, the background updates in real time as the HTF bar forms
Bullish / Bearish background colors — customizable with transparency
Trend Changed alert — fires on bar close on any of the six possible state transitions: uptrend ↔ neutral ↔ downtrend and direct flip. Alert message specifies the exact transition
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DASHBOARD
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
A compact table showing WaveTrend values for each enabled timeframe. Only enabled timeframes are displayed — from one to three rows.
Column 1: timeframe label (15m, 1h, 4h etc.)
Column 2: current WT value rounded to one decimal. Cell background reflects signal strength: neutral grey (−10 to +10), weak green/red (±10 to ±40), saturated green/red (beyond ±40)
Position — 9 placement options across the chart
Text size — Tiny / Small / Normal / Large
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ALERTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Every module has its own independent alert toggle. All messages can optionally be prefixed with the instrument ticker — useful when monitoring multiple charts simultaneously.
Liquidity level breached
Absorption candle formed
New order block created
Order block mitigated
Session high or low crossed
PDH / PDL level crossed
Trend changed (WaveTrend multi-TF)
Indicator
Inducement Engine Liquidity Targets [MarkitTick]💡 The financial markets operate as a continuous auction process, constantly seeking liquidity to facilitate large transactions. We have developed a comprehensive analytical tool designed to systematically map these liquidity zones, specifically focusing on the concept of inducement (IDM). This tool tracks market structure in real-time, identifying areas where market participants are structurally trapped, and highlights the subsequent liquidity sweeps that often precede significant directional moves. By mapping these pivot points and applying stringent confluence filters, we provide a structured approach to analyzing price action without relying on lagging, derivative-based oscillators.
✨ Originality and Utility
Standard structural tools often map higher highs and lower lows but fail to categorize the internal liquidity that resides between these structural bounds. Our tool distinguishes itself by isolating inducement points—short-term swing highs or lows that form within an active leg of market structure.
Instead of treating all pivots equally, we categorize them based on their relationship to the overarching trend. Furthermore, this tool does not simply plot historical data; it actively tracks pending liquidity pools and waits for their invalidation to derive actionable zones.
This utility is enhanced by a built-in risk management engine that dynamically calculates entry, stop loss, and multiple take profit voids based on market volatility, offering a complete, end-to-end framework directly on the chart. The integration of volume volatility, exhaustion profiling, and structural imbalances creates a unified, logical system rather than an arbitrary assembly of unrelated indicators.
🔬 Methodology and Concepts
● The Mechanics of Inducement
Market Structure Tracking: We utilize an advanced, non-repainting pivot identification algorithm that maps confirmed structural highs and lows. This establishes the primary directional bias and prevents the plotting of unconfirmed future data.
Pending Liquidity Generation: When an internal pivot forms within the established structural range, it is categorized as a pending inducement point. These represent areas where early market participants place stop losses, creating pools of concentrated liquidity.
The Liquidity Sweep: The core engine monitors price action for the precise moment these inducement points are breached. A sweep indicates that the pending liquidity has been consumed, providing the fuel required for a potential reversal or trend continuation.
Multi-Layered Confluence: A sweep alone is insufficient for validation. We evaluate the trigger against several strict conditions. We require alignment with a higher timeframe trend, ensuring we trade with the dominant macro flow. We also measure volatility against a moving baseline to filter out low-momentum chop.
Exhaustion and Imbalance: Finally, we assess the structural integrity of the move by checking for price exhaustion through rejection wicks and the presence of underlying fair value gaps (FVGs) that validate the momentum.
🎨 Visual Guide
● Chart Elements
Pending IDM Lines: Dotted lines projecting horizontally from internal pivots. These represent untouched liquidity pools waiting to be swept.
IDM Sweep Labels: Distinct visual markers displaying "IDM ↑" and "IDM ↓". These appear exactly when price sweeps a pending liquidity level, signaling a potential reaction.
Entry Zones (Black Boxes): A solid, dark zone originating at the trigger point, highlighting the exact entry threshold for the setup.
Stop Loss Zones (Red Boxes): A colored zone delineating the maximum risk threshold, visually adapting to the current structural invalidation point and volatility padding.
Take Profit Voids (Blue/Cyan Boxes): A series of progressively lighter colored zones representing Take Profit 1, 2, and 3. These voids illustrate the projected risk-to-reward extensions based on the initial risk profile.
Target Lines: Horizontal dashed and dotted lines projecting the exact price levels for the entry, stop loss, and multiple take profit targets.
● The Live Dashboard
Header: Displays the active ticker and timeframe configuration.
Bias: Indicates the overarching structural trend (Bullish, Bearish, or Neutral).
Last IDM: Shows the direction of the most recently swept liquidity pool.
Coordinates: Displays the exact numerical price levels for Entry, TP1, TP2, TP3, and SL.
Duration Tracking: Tracks the exact number of bars since the last confirmed Bull or Bear IDM sweep, offering a measure of setup maturity.
Pending Count: A live counter of the currently active, untouched inducement points on the chart.
📖 How to Use
Observe the dashboard to determine the active market bias and monitor the creation of pending IDM levels.
Wait for price action to sweep a pending IDM line. The appearance of an IDM sweep label serves as the primary catalyst.
Verify that the dashboard registers the setup, meaning all selected smart filters (Time, HTF, Volatility, FVG) are aligned.
Utilize the dynamically plotted Entry, Stop Loss, and Take Profit boxes to structure your position sizing and risk profile.
The projected target voids can be used to manage risk or scale out of positions sequentially as price moves into higher extensions.
Avoid using this indicator in sideways market conditions to prevent false entries.
⚙️ Inputs and Settings
● Core Configuration
Swing Length: Adjusts the sensitivity of the pivot detection. Higher values filter noise, identifying more significant structural points.
ATR Length: Modifies the lookback period for volatility calculations used in risk mapping.
Max IDM Memory: Controls the historical limit for tracking untouched liquidity pools.
● Entry and Risk Parameters
ATR-Adaptive SL: When enabled, we pad the structural stop loss with an average true range multiplier to account for market noise.
ATR SL Mult: Defines the precise multiplier used for the adaptive padding.
Target Multipliers (TP1, TP2, TP3): Defines the precise risk-to-reward ratios for the sequential take-profit voids.
Line Toggles: Independent toggles to show or hide the Entry, Stop Loss, and Target lines to keep the chart clean.
● Smart Filters
Session Time Filter: Restricts signal generation to specific trading windows, avoiding low-liquidity periods.
HTF Trend Alignment: Enforces agreement with a moving average calculated on a higher timeframe.
HTF Timeframe & Length: Configures the resolution and period for the higher timeframe trend filter.
FVG Confluence: Requires a recent fair value gap to validate the momentum behind the setup.
Rejection Quality: Filters setups ensuring the trigger bar closes with distinct rejection characteristics.
Volatility Chop Filter: Suppresses setups when current volatility is below its historical average.
● Visuals and Alerts
Color Configurations: Extensive user-defined color inputs for Bull/Bear markers, Entry Fills, Target zones, and text elements.
Webhook Actions: Dedicated string inputs to format dynamic alert payloads, allowing seamless integration with third-party execution platforms.
🔍 Deconstruction of the Underlying Scientific and Academic Framework
Auction Market Theory: Our architecture is deeply rooted in Auction Market Theory, which postulates that price discovery relies on the continuous search for liquidity. By mapping inducement, we are effectively modeling the algorithmic search for counter-party volume. Markets move from areas of high liquidity to low liquidity, and tracking these pools provides a probabilistic edge.
Mean Reversion within Structural Bounds: The identification of internal sweeps relies on statistical mean reversion. When price deviates aggressively to sweep a pivot, it creates a temporary state of overextension. The subsequent reaction is a reversion to the mean of the macro structure, propelled by the trapped liquidity that was just consumed.
Volatility-Adjusted Risk Modeling: The integration of the Average True Range (ATR) for stop-loss padding utilizes basic heteroskedasticity principles. Financial time series exhibit volatility clustering; by padding risk dynamically, the model adapts to the current state of market variance rather than relying on static, arbitrary tick values that fail in highly volatile environments.
Volume Spread and Exhaustion: The rejection filter incorporates elements of Volume Spread Analysis. A sweep accompanied by price rejection signifies absorption—a scenario where the effort to push price beyond a level is met with overwhelming counter-force, statistically validating the structural trap.
⚠️ Disclaimer
All provided scripts and indicators are strictly for educational exploration and must not be interpreted as financial advice or a recommendation to execute trades. I expressly disclaim all liability for any financial losses or damages that may result, directly or indirectly, from the reliance on or application of these tools. Market participation carries inherent risk where past performance never guarantees future returns, leaving all investment decisions and due diligence solely at your own discretion. Indicator
Indicator
AG Pro Inducement & Trap Quality [AGPro Series]AG Pro Inducement & Trap Quality
OVERVIEW / WHAT IT DOES
AG Pro Inducement & Trap Quality is an overlay tool built to map short-lived trap behavior around smaller inducement levels rather than broad market structure alone. The script focuses on moments where price appears to invite participation through a nearby internal level, briefly pushes beyond that level, and then reclaims it quickly enough to suggest failed continuation pressure.
In practical terms, this tool is designed to highlight a very specific type of behavior: local liquidity engineering around minor swing references. Instead of treating every sweep as equally meaningful, it evaluates whether the move shows the characteristics of a more deliberate trap sequence. This helps separate routine noise from cleaner rejection events that may deserve closer attention.
The script identifies compact inducement references, monitors whether those levels are exceeded, and then evaluates the quality of the reclaim using a rules-based scoring model. The output is intentionally visual and compact: trap labels, score readouts, engineered-liquidity context, and a lightweight status panel that keeps the chart readable while still surfacing the most important state information.
This is not a broad “smart money everything” overlay, and it is not a general market-structure engine. Its role is narrower and more specific: to help users study micro trap behavior around inducement levels with a structured, visual framework.
UNIQUE EDGE
Many trap-style overlays simply mark local sweeps or label wick rejections without distinguishing between low-quality noise and more organized rejection behavior. This script takes a narrower path.
Its core distinction is that it is built around inducement-first logic. The process begins with smaller internal swing references that may function as local liquidity magnets. From there, the script evaluates whether price briefly runs that level and reclaims it with enough quality to qualify as a more meaningful trap event.
This makes the script materially different from tools that primarily map:
- full structure breaks,
- broad liquidity sweeps across larger swing highs and lows,
- order blocks or fair value gaps,
- or generic reversal candles.
The objective here is not to classify the whole market. The objective is to organize one specific event class: short-lived inducement failure and trap quality around internal levels.
METHODOLOGY
1) Inducement level detection
The script scans for smaller swing references that can function as local inducement levels. These are not intended to replace major support or resistance logic. They serve as nearby internal references around which short-term trap behavior may form.
2) Sweep and reclaim logic
After an inducement level is identified, the script monitors whether price briefly trades beyond that level. A trap candidate is only considered when the move fails to sustain beyond the level and price reclaims the reference within a limited confirmation window.
3) Quality model
Each trap candidate is scored using a rules-based quality framework. The score is not arbitrary. It is derived from components such as:
- reclaim speed,
- relative volume behavior,
- wick proportion,
- and overshoot control.
The purpose of the score is not prediction. It is prioritization. A higher score suggests that the rejection characteristics were cleaner according to the script’s internal rules.
4) Engineered liquidity context
When inducement logic becomes active, the script can visualize engineered-liquidity context so users can see where price is interacting with a recently relevant internal level. This is meant to improve readability and sequencing, not to imply certainty.
5) Visual decluttering and presentation controls
To keep the overlay usable, the script includes compact labeling, importance filtering, label spacing controls, and a small status panel. These features are presentation tools designed to reduce clutter without changing the underlying trap logic.
SIGNALS & ALERTS
The script can visualize bull and bear trap events after inducement-level interaction and reclaim confirmation.
Typical readouts include:
- TRAP labels,
- quality score values,
- inducement / engineered-liquidity context,
- and panel status information such as recent trap state and current watch state.
Alert conditions are designed around deterministic script events rather than discretionary interpretation. As with any alert-based study, users should confirm how they want to use those events inside their own workflow before relying on them in live conditions.
KEY INPUTS
Important controls typically include:
- inducement swing sensitivity,
- confirmation window / reclaim timing,
- volume and wick weighting inputs,
- overshoot tolerance,
- compact label display,
- importance filtering,
- panel visibility and position,
- and vertical label offset controls.
These settings allow the user to decide whether they want broader coverage or a stricter, more selective readout.
HOW THIS DIFFERS FROM OTHER AG PRO TOOLS
This script is intentionally specialized.
It is not a BOS / CHoCH engine and does not attempt to label full structural transitions.
It is not an order block tool and does not frame the chart through block logic.
It is not a fair value gap map and does not organize imbalance zones as its primary lens.
It is not a broad liquidity sweep tool built around larger external swing raids.
Instead, this script concentrates on micro inducement behavior: smaller internal references, brief level violations, fast reclaim structure, and the relative quality of the resulting trap.
That narrower scope is the point. The script is designed to help users study one recurring behavior class in a more disciplined and readable way.
LIMITATIONS & TRANSPARENCY
This script is a visual and analytical aid. It does not know intent, news context, execution conditions, or participant positioning.
A trap label does not guarantee reversal.
A higher quality score does not guarantee continuation.
A low-quality score does not mean the area is irrelevant.
Internal inducement levels can vary in significance depending on volatility regime, instrument behavior, and timeframe selection.
Like any rules-based overlay, this script is sensitive to parameter choices. More permissive settings may surface more events but also more noise. Stricter settings may improve selectivity while naturally reducing signal frequency.
Users should also understand that inducement and trap concepts are interpretive by nature. This script translates those ideas into a deterministic ruleset for chart study. That conversion is useful, but it is still a model.
RISK DISCLOSURE
This script is for chart analysis and educational use. It is not financial advice, not a trade signal service, and not a promise of outcome.
All trading and investing involve risk. Market conditions can change quickly, and no indicator or overlay can eliminate uncertainty. Users should evaluate signals in context, apply their own risk management, and avoid treating any single chart tool as a complete decision system.
WHAT THIS SCRIPT IS NOT
To make the scope clear, this script is not:
- a guaranteed reversal detector,
- a one-click trade system,
- a full market-structure replacement,
- or a standalone execution model.
It is a focused overlay for studying inducement-driven trap behavior with a cleaner visual framework.
NOTES
Best use cases typically come from combining this script with context that the user already trusts, such as trend structure, higher-timeframe location, or broader execution rules. The tool is intended to improve organization and observation around inducement and trap sequences, not to replace judgment.
If you prefer a cleaner chart, use the compact display and importance filter settings. If you prefer a more exploratory workflow, relax the filter and study how the scoring reacts across different conditions.
Indicator
Inducement [UAlgo]Inducement is a market structure tool designed to detect pullback liquidity levels that form during directional expansion and remain relevant until price comes back to sweep them. The script tracks directional legs, monitors the deepest retracement points that appear against the active move, and promotes those retracement extremes into active IDM levels once the trend resumes in the original direction.
The core idea is simple. During a bullish move, price often creates a temporary downside pullback before continuing upward. That pullback low can later act as an inducement point where liquidity rests below the market. In a bearish move, the opposite process happens, where an upside pullback forms before price continues lower. That pullback high can later become a bearish inducement point. This script automates that process and keeps those levels visible on the chart until they are eventually swept.
What makes the script useful is that it does not plot every fluctuation. It first filters out inside bars, tracks the active directional leg, records the most meaningful retracement extreme inside that leg, and only creates a new IDM when price resumes the main move by printing a fresh expansion. That makes the final levels cleaner and more structurally relevant.
Once an IDM is created, it is drawn as a horizontal reference with a label. If price later trades through that level, the script marks it as swept, updates the label, and changes the line style to reflect that the liquidity has been taken. This creates a very practical chart view for traders who want to monitor inducement behavior, liquidity sweeps, and the relationship between pullbacks and later price delivery.
🔹 Features
🔸 Directional Leg Tracking
The script maintains an internal bullish or bearish trend state and updates the active structural leg as price continues to expand. This gives the indicator a directional framework instead of treating each new bar independently.
🔸 Inside Bar Filtering
Inside bars are ignored for structural progression. This helps the script focus on meaningful range expansion rather than reacting to small compressive candles that do not add new directional information.
🔸 Pullback Extreme Detection
During a bullish leg, the script tracks the lowest downside pullback that forms before the next bullish expansion. During a bearish leg, it tracks the highest upside pullback before the next bearish expansion. These stored extremes are the raw candidates for inducement levels.
🔸 Automatic IDM Creation
A stored pullback extreme becomes an active IDM only when the market resumes the active leg and creates a fresh structural push. This means the indicator does not mark every retracement immediately. It waits for continuation confirmation.
🔸 Bullish and Bearish IDM Mapping
Bullish IDM levels are created from pullback lows inside bullish continuation.
Bearish IDM levels are created from pullback highs inside bearish continuation.
This gives the user a clean map of likely liquidity resting points below or above price.
🔸 Sweep Recognition
Once an IDM is active, the script checks every new bar to see whether price has swept it. Bullish IDM is considered swept when current low trades at or below the level. Bearish IDM is considered swept when current high trades at or above the level.
🔸 Live Visual State Changes
Active IDM levels are drawn with dashed lines and labeled as unswept. Once swept, the line style changes, the color becomes softer, and the label updates to show that the liquidity event has already occurred.
🔸 Lightweight Structure Display
The script keeps an internal array of active IDM levels and limits the array size to avoid uncontrolled growth. This keeps the display practical and suitable for live chart use.
🔹 Calculations
1) Defining the IDM Object
type InducementLevel
float price
int bIndex
int dir
line idmLine
label idmLabel
bool isSwept
This is the core data container used by the script.
Each inducement level stores:
its price,
the bar index where it originated,
its direction,
its line object,
its label object,
and whether it has already been swept.
The dir field controls the level type:
1 means bullish IDM
-1 means bearish IDM
So before any logic runs, the script already has a dedicated structure for tracking the full lifecycle of each inducement level from creation to sweep.
2) Drawing Active and Swept Levels
method draw(InducementLevel this, color c_bull, color c_bear) =>
color c = this.dir == 1 ? c_bull : c_bear
string txt = this.isSwept ? "IDM ✓" : "IDM ✗"
if na(this.idmLine)
this.idmLine := line.new(this.bIndex, this.price, bar_index, this.price, color=c, style=line.style_dashed)
else if not this.isSwept
this.idmLine.set_x2(bar_index)
if na(this.idmLabel)
this.idmLabel := label.new(bar_index, this.price, txt, style=label.style_none, textcolor=c, size=size.small, textalign=text.align_left)
else if not this.isSwept
this.idmLabel.set_x(bar_index)
this
This method is responsible for visualizing each inducement level.
First, it selects the correct color according to direction. Bullish levels use the bullish color input, and bearish levels use the bearish color input. Then it builds a text state:
"IDM ✗" means the level is still active and not yet swept.
"IDM ✓" means the level has already been swept.
If the line does not exist yet, the script creates a dashed horizontal line starting from the level’s origin bar to the current bar. If the line already exists and the level is still unswept, the line is extended to the latest bar.
The label follows the same logic. If no label exists, it is created. If the label already exists and the level is still active, its position is moved to the latest bar.
So visually, each active IDM behaves like a live horizontal liquidity reference that extends forward until price takes it.
3) Detecting Liquidity Sweeps
method checkSweep(InducementLevel this, float currLow, float currHigh, color c_bull, color c_bear) =>
if not this.isSwept
swept = false
if this.dir == 1 and currLow <= this.price
swept := true
else if this.dir == -1 and currHigh >= this.price
swept := true
This method determines whether an existing inducement level has been taken.
The logic is direction specific.
For bullish IDM:
if the current low trades at or below the level price, the level is considered swept.
For bearish IDM:
if the current high trades at or above the level price, the level is considered swept.
This matches the structural idea behind inducement. A bullish pullback low represents liquidity resting below price, and that liquidity is considered taken once price trades through it. A bearish pullback high represents liquidity resting above price, and that liquidity is considered taken once price pushes through it.
So this method is the event detector that turns an active liquidity level into a completed liquidity event.
4) Updating the Visual State After a Sweep
if swept
this.isSwept := true
color c = this.dir == 1 ? color.new(c_bull, 50) : color.new(c_bear, 50)
this.idmLine.set_color(c)
this.idmLine.set_style(line.style_dotted)
this.idmLine.set_x2(bar_index)
this.idmLabel.set_text("IDM ✓")
this.idmLabel.set_textcolor(c)
this.idmLabel.set_x(bar_index)
Once a sweep happens, the script changes both the internal state and the visual appearance.
The level is marked as swept with this.isSwept := true .
Then the line color becomes softer by applying transparency.
The line style changes from dashed to dotted.
The label text changes from IDM ✗ to IDM ✓ .
This is useful because it preserves the historical location of the inducement while also showing that the level is no longer pending. In other words, the chart keeps the context but changes the state.
5) Filtering Out Inside Bars
var float mHigh = high
var float mLow = low
bool isInside = high <= mHigh and low >= mLow
This small block is more important than it looks.
The script stores a reference range using mHigh and mLow . A bar is considered inside if its high is less than or equal to the stored high and its low is greater than or equal to the stored low.
In simple terms, an inside bar is a bar that remains contained within the prior meaningful structure range. The script ignores those bars for the purpose of leg progression.
This helps reduce noise because inside bars usually reflect compression rather than new structural information. By ignoring them, the indicator focuses on actual range expansion and meaningful pullback development.
6) Tracking Trend State and Leg Extremes
var int trend = 1
var float legHigh = high
var float legLow = low
var float pullbackLow = na
var int pullbackLowBar = na
var float pullbackHigh = na
var int pullbackHighBar = na
This block defines the internal market structure memory.
trend stores whether the script currently sees the market as bullish or bearish.
legHigh and legLow track the active structural extreme of the current leg.
pullbackLow and pullbackHigh store the most important retracement extreme that forms against the current trend.
So the script is always tracking two things at once:
the direction of the main move,
and the deepest retracement against that move.
That retracement extreme later becomes the candidate IDM if price resumes the original direction.
7) Bullish Leg Logic and Bullish IDM Creation
if trend == 1
if high > legHigh
if not na(pullbackLow)
activeIDMs.push(InducementLevel.new(pullbackLow, pullbackLowBar, 1, na, na, false))
pullbackLow := na
legHigh := high
else if brokeLow
if na(pullbackLow) or low < pullbackLow
pullbackLow := low
pullbackLowBar := bar_index
This is the heart of bullish inducement detection.
When the script is in bullish mode, it watches for two types of events.
First, if price makes a new leg high:
high > legHigh
That means bullish continuation has occurred. If a downside pullback low had been stored before this continuation, the script converts that pullback low into a new bullish IDM by pushing it into the active array.
That is the crucial idea:
the pullback low becomes inducement only after price proves continuation by printing a fresh high.
Second, if the current bar breaks below the stored micro range low:
brokeLow
Then the script updates pullbackLow if this new low is deeper than the previously stored pullback. This allows the script to keep tracking the deepest retracement inside the bullish leg until continuation happens.
So bullish IDM is created from the most meaningful downside retracement that occurs before the next bullish expansion.
8) Bearish Leg Logic and Bearish IDM Creation
else if trend == -1
if low < legLow
if not na(pullbackHigh)
activeIDMs.push(InducementLevel.new(pullbackHigh, pullbackHighBar, -1, na, na, false))
pullbackHigh := na
legLow := low
else if brokeHigh
if na(pullbackHigh) or high > pullbackHigh
pullbackHigh := high
pullbackHighBar := bar_index
This is the mirror image of the bullish logic.
When the script is in bearish mode, it waits for a new leg low:
low < legLow
If that happens and a prior upside pullback high was stored, the script converts that pullback high into a bearish IDM. This marks the retracement high as a future liquidity point above price.
If price does not yet continue lower but instead breaks upward inside the local structure:
brokeHigh
Then the script updates pullbackHigh if the new high is greater than the previously stored retracement high.
So bearish IDM is created from the strongest upside retracement that forms before the next bearish continuation.
9) Detecting Trend Reversal and Resetting the Pullback Memory
if low < legLow
trend := -1
legLow := low
pullbackLow := na
pullbackHigh := na
if high > legHigh
trend := 1
legHigh := high
pullbackHigh := na
pullbackLow := na
These blocks handle directional flips.
Inside bullish mode, if price breaks below the active leg low, the script changes its internal state to bearish.
Inside bearish mode, if price breaks above the active leg high, the script changes its internal state to bullish.
Whenever the trend flips, the stored pullback variables are cleared. That is important because retracement data from the old trend should not be reused after the market has structurally changed direction.
So the script always keeps its inducement logic aligned with the current structural leg rather than mixing information from opposite phases.
10) Updating the Reference Range After a Non Inside Bar
if not isInside
bool brokeLow = low < mLow
bool brokeHigh = high > mHigh
mHigh := high
mLow := low
This block updates the structure reference only when the current bar is not an inside bar.
Before resetting the reference range, the script checks whether the current bar expanded below the stored low or above the stored high. Those two booleans are then used in the bullish and bearish logic to decide whether the move represents pullback development or continuation.
After those checks are done, the reference high and low are updated to the current bar’s high and low.
So mHigh and mLow act like a rolling structural filter that helps the script ignore internal compression and focus on meaningful range expansion.
11) Managing All Active IDM Levels on Every Bar
if activeIDMs.size() > 0
for i = 0 to activeIDMs.size() - 1
idm = activeIDMs.get(i)
idm.checkSweep(low, high, colorBullIDM, colorBearIDM)
idm.draw(colorBullIDM, colorBearIDM)
This is the execution loop for all stored inducement levels.
On every bar, the script goes through each active IDM and does two things:
it checks whether the level has now been swept,
and it redraws or updates the level on the chart.
This means every stored level remains live and state aware. Unswept levels keep extending forward, while swept levels lock their appearance into a completed state.
So the script is always balancing two layers:
new IDM creation from ongoing structure,
and lifecycle management of previously created levels.
12) Limiting the Number of Stored Levels
if activeIDMs.size() > 50
activeIDMs.shift()
This last block keeps the internal IDM array from growing indefinitely.
If more than fifty inducement levels are stored, the oldest one is removed from the array. This helps keep memory usage under control and makes the indicator more practical for ongoing chart use.
The purpose here is not analytical. It is purely operational. The script limits historical storage so the active structure set remains manageable. Indicator
Indicator
Liquidity & inducementsHi all!
This indicator will show liquidity and inducements.
I will continue to try to add different types of liquidity and inducements, at this moment it contains 6 kinds of liquidity/inducement, they are:
• Grabs
• Big grabs
• Sweeps
• Turtle soups
• Equal highs/lows (liquidity and inducement)
• BSL & SSL
And 1 type of inducement:
• Retracement
This description will contain indicator examples of each individual liquidity and inducement. They will all be with the default settings.
Settings
First you will find settings for the market structure (BOS/CHoCH/CHoCH+). Select left and right pivot lengths and if the pivots should have a label or not.
This is the base foundation of this indicator and is possible with my library 'PriceAction' ().
You will see solid lines for break of structures (BOS), change of characters (CHoCH) and change of character plus (CHoCH+).
The pivots found will be the core of this indicator and will show you when the closing price breaks it. When that happens a break of structure (BOS) or a change of character (CHoCH or CHoCH+) will be created. The latest 5 pivots found within the current trend will be kept to take action on.
A break of structure is removed if an earlier pivot within the same trend is broken and the pivot's high price for a bullish trend or low price for a bearish trend is more extreme than the BOS pivot's price.
You are able to show the pivots that are used. "HH" (higher high), "HL" (higher low), "LH" (lower high), "LL" (lower low) and "H"/"L" (for pivots (high/low) when the trend has changed) are the labels used.
In the next section ('Liquidity ($$$)') you can select which types of liquidity you want to see. Note that 'Equal highs/lows' can also show inducement (more on that later).
In the section afterwards ('Inducement (IDM)') you can select if you want retracement inducements to be visible or not. More information on what they are later on.
The section for each individual liquidity and/or inducement can first contain a line named 'Pivot', where you can set the pivot lengths (first left, then right). Then you can set the 'Lookback', which means that the 'Lookback' number of past pivots is to take action on. After that you set the 'Timeframe' for the pivots used. That means that all available liquidity/inducements will be from your desired timeframe. Lastly you set the color of the liquidity/inducement (either a single color or bullish followed by bearish colors).
Lastly in the settings you can select the font sizes for the market structure and liquidity/inducements and what style liquidity/inducements lines will have. The sizes defaults to 7 and has a dotted line look.
Grabs
Liquidity grabs and liquidity sweeps are very similar. It all depends on if the current bar closed above/below the liquidity pivot and on if its a continuation or reversal. In a liquidity grab the bar that's above or below the liquidity pivot was not closed above or below it. Like this:
Or
The visual feedback will be a dotted line between the liquidity pivot and liquidity grab bar and a linefill between the high of the liquidity grab bar and the liquidity pivot.
Indicator example:
Big grabs
This is another 'grabs' option. You can show an additional grab if you want to. I suggest having this grab from a higher timeframe or with larger pivot lengths than the other grab.
The default is with the chart timeframe and 10/10 as pivot lengths.
Indicator example:
Sweeps
A liquidity sweep is like a liquidity grab but with the difference that price closes above/below and has a continuation instead of a reversal. If the liquidity pivot was at the same bar as a BOS/CHoCH/CHoCH+ it will not be a liquidity grab but a structural break instead.
They can look like this:
Indicator example;
Turtle soups
If only one candle is beyond the pivot it could be a liquidity grab. It's a grab if price didn't close beyond the liquidity pivot, if so it's invaliditet. Turtle soups are basically false breakouts that takes liquidity (is a false breakout from a pivot with the lengths and timeframe from the settings).
The turtle soup can have a confirmation in the terms of a change of character (CHoCH). You can enable this in the settings section for 'Turtle soups' through the 'Confirmation' checkbox (enabled by default). The turtle soup strategy usually comes with some sort of confirmation, in this case a CHoCH, but it can also be a market structure shift (MSS) or a change in state of delivery (CISD).
The addition of turtle soups is possible through my script 'Turtle soup' ().
The drawing will be a dotted line between the liquidity pivot and the last bar of the false breakout and a box from the start of the false breakout to the end of it.
Indicator example:
Equal highs/lows
Equal highs/lows will always show liquidity, but might also show inducement. Inducement will be shown on equal lows if the trend is bullish and on equal highs if it's bearish, like this:
Or
Equal highs can only be created if the second pivot is lower than the first one. Equal lows can only be created if the second pivot is higher than the first one. If that is not the case it could be a liquidity grab.
When equal highs or equal lows are find that produces inducement (equal lows in a bullish trend and equal highs in a bearish trend), the indicator will first display inducement and will show liquidity once traders are induced to enter the security. Stop loss placement, for liquidity, is 0.1 * the average true range (ATR, of length 14). They will look like this:
Only inducement:
Inducement and liquidity:
Indicator example:
Equal highs/lows inducements can not be triggered after a BOS/CHoCH/CHoCH+. They are cleared upon a structural break.
BSL & SSL
Buyside liquidity (BSL) and sellside liquidity (SSL) will be shown. A pivot that's been mitigated (touched by price) can never be BSL or SSL. The BSL/SSL available will be dynamic while price moves (work in Replay and lower timeframes that moves fast) and pick the latest pivot/s (with left and right lengths from the 'Market structure' section). You can define how many BSL/SSL you want to see with a default value of 1, meaning only 1 BSL and 1 SSL can be shown. If there is no unmitigated high (BSL) or low (SSL), no BSL/SSL will be available to show. If there are BSL/SSL available they're very useful to use as targets for entering a trade.
The will look like this when available;
And without BSL available:
Or
And without SSL available:
Note that the examples without BSL/SSL available could have liquidity available from previous price legs.
This can be an example of a BSL/SSL sequence:
First both buyside and sellside liquidity is available:
Then a new low appears and new sellside liquidity is available:
Then buyside liquidity is mitigated, so only sellside liquidity is available:
A new high pivot appears and buyside liquidity is available again:
Lastly a bearish CHoCH happens and sellside liquidity is mitigated, only buyside liquidity is available:
Retracement
The first retracement after a BOS/CHoCH/CHoCH+ is considered an inducement with the mission to get traders into a trade prematurely to get stopped out. This level is shown and look like this:
Or
A retracement inducement is removed when a new BOS/CHoCH/CHoCH+ appears and it's not triggered.
---------------------------
As of now there aren't any alerts available. You cannot use the Pine Screener from Tradingview either to see new liquidity/inducement events. I have this planned for future updates though.
I hope that this long description makes sense, let me know otherwise! Also let me know if you experience any bugs or have a feature request or just want to share good settings to use.
Best of trading luck! Indicator
Market Structure Inducements ICT [TradinFinder] CHoch BOS Sweeps🔵 Introduction
Market Structure is the foundation for identifying trends in the market, crucial in technical analysis and strategies like ICT and SMC. Understanding key concepts such as Break of Structure (BOS) and Change of Character (CHOCH) helps traders recognize critical shifts in the market. BOS, referring to a Market Structure Change (BMS), and CHOCH or Market Structure Shift (MSS) signal trend reversals in the market.
Additionally, the concept of Inducement, a vital tool in Smart Money strategies, allows traders to avoid price traps. Identifying valid pullback, valid inducement, POI, and Liquidity Grab helps traders find optimal entry and exit points and leverage Smart Money movements effectively.
Bullish Market Structure :
Bearish Market Structure :
🔵 How to Use
The Market Structure indicator is designed to help traders better understand market structure and detect price traps. By using this indicator, you can identify the right entry and exit points based on structural changes in the market and avoid unprofitable trades. Below, we explain the key concepts and how to apply them in trading.
🟣 Market Structure
Market Structure refers to the overall pattern of price movement in the market. Using this indicator, traders can identify uptrends and downtrends and make better trading decisions based on changes in market structure. The two key concepts here are Break of Structure (BOS) and Change of Character (CHOCH).
Change of Character (CHOCH) : CHOCH occurs when the market shifts from an uptrend to a downtrend or vice versa. These changes typically indicate a broader trend reversal, and the indicator assists you in identifying them accurately.
Break of Structure (BOS) : When the market breaks a key support or resistance level, it signals a change in market structure. This indicator helps you identify these breakouts in time and take advantage of trading opportunities.
🟣 Inducement
Inducement refers to price traps set by Smart Money to trick retail traders into making the wrong trades. This indicator helps you recognize these traps and avoid unprofitable trades.
Valid Inducement : Valid Inducement refers to deliberately created price traps by major market players to gather liquidity from retail traders. Once the market has collected sufficient liquidity, it makes the real move, and professional traders use this moment to enter.
🟣 Valid Pullback
A Valid Pullback refers to a temporary market retracement, indicating a price correction within the main trend. This concept is crucial in technical analysis as it helps traders enter trades at the right time and profit from the continuation of the trend. The Market Structure indicator can identify these valid retracements, allowing traders to enter trades with greater confidence.
🟣 Point of Interest (POI)
Another important concept in market analysis is the Point of Interest (POI), referring to key price areas on the chart. POI includes zones where significant price movements are likely to occur. The Market Structure indicator helps you locate these key points and use them as entry signals for trades.
🟣 Liquidity Grab
Liquidity Grab refers to a scenario where the market intentionally moves to areas where retail traders' stop losses are placed. The goal is to gather liquidity, allowing major players to execute trades at better prices. By using this indicator, you can spot these liquidity grabs and avoid falling into price traps.
🔵 Setting
ChoCh Detector Period : The period of identifying the major market levels that occur when they break ChoCh.
BoS & Liquidity Detector Period : The period of identifying minor levels, which are used to identify BoS and Liquidity levels.
Inducement Detector Period : The period of identification of Inducement levels.
Fast Trend Detector : This feature will help you update the major market structure levels sooner.
Inducement Type Detector : Two modes "Sweeps" and "Total" can be used to identify the levels of Inducement. In "Sweeps" mode only Levels detected by touch shadow. In "Total" mode, all Levels are detected.
🔵 Conclusion
In financial market analysis and forex trading, identifying Market Structure and Inducement is crucial. Market Structure helps you detect uptrends and downtrends, and understand Break of Structure (BOS) and Change of Character (CHOCH). The concept of Inducement also enables traders to spot Smart Money price traps and avoid unprofitable trades.
The Market Structure indicator is a powerful tool that, by analyzing the market structure and concepts like valid pullback and valid inducement, helps you make more precise trade entries. Additionally, by identifying POI and Liquidity Grab, the indicator gives you the ability to spot key market zones and use them to your advantage in trading.
Indicator
Indicator
Indicator
Indicator
