Indicator
Indicator
Indicator
Indicator
Inside / Outside BarsThis indicator highlights Inside Bars and Outside Bars directly on the chart, helping identify consolidation and expansion phases in price action.
Key Features:
Inside Bar Detection
An Inside Bar is a candle whose high and low are fully contained within the range of the previous candle.
This typically signals consolidation, reduced volatility, and potential buildup before a breakout.
Outside Bar Detection
An Outside Bar is a candle whose high is higher than the previous high and whose low is lower than the previous low.
This reflects range expansion, increased volatility, and possible reversal or continuation momentum.
Visual Highlighting
Inside and Outside Bars are clearly marked on the chart with customizable colors, allowing quick recognition without manual analysis.
Clean and Minimal Design
-The indicator is designed to avoid clutter, focusing only on key price action signals.
-Works on Any Market
-Can be applied to crypto, forex, stocks, and indices.
Use Cases:
-Identify breakout setups after consolidation (Inside Bars)
-Spot volatility expansion and potential reversals (Outside Bars)
-Combine with higher timeframe levels and liquidity concepts for improved decision-making
This tool is built for traders who rely on pure price action and want a clear, automated way to track key candle patterns. 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
Indicator
Smart NR2-NR20 and Inside Bar (Zeiierman)█ Overview
Smart NR2–NR20 + Inside Bar (Zeiierman) is a compression + breakout scanner that searches for the tightest Narrow Range (NR) condition across NR2…NR20, plus optional Inside Bar detection. When a valid compression forms, it draws a box around the setup, projects the high/low levels forward, and triggers on the first breakout. Optional Trend Filter logic can restrict triggers to trend-aligned breakouts, and optional Exit markers can annotate TP / SL / Time exits after a trigger.
🔘 What It Detects
The Smart Narrow Range (NR2…NR20) script continuously checks NR lengths from 2 to 20 and selects the most extreme contraction (tightest relative range vs history) inside the current Look Back window, highlighting the strongest “compression” zones where expansion risk is building. Optionally, it can also treat an Inside Bar as a valid compression trigger.
█ How It Works
⚪ 1) Compression Scan (NR Ranking Engine)
For each bar, the script evaluates NR2…NR20:
It calculates the N-bar range (highest high − lowest low).
It compares that range to prior N-bar ranges over Look Back.
It ranks candidates by “tightness” and keeps the strongest one.
Key effect:
Higher Look Back = fewer but higher-quality compressions
Lower Look Back = more frequent compressions
⚪ 2) Adaptive Look Back (Static or ADX-Adaptive)
Look Back can be:
Static: fixed comparison window
ADX Adaptive: Look Back dynamically shifts between LB Min and LB Max depending on trend strength
Conceptually:
Higher ADX (strong trend) — shorter Look Back (more responsive)
Lower ADX (chop/range) — longer Look Back (more selective)
█ How to Use
⚪ Bullish Setup
Wait for a tight range to form
Enter on a breakout above the range high
Stop below the opposite side of the range
Target a multiple of the range size or trail with momentum
Optional: wait for a small breakout retest before entering
⚪ Bearish Setup
Wait for a tight range to form
Enter on breakout below the range low
Stop above the opposite side of the range
Target a multiple of the range size or trail with weakness
Optional: enter on breakdown retest
█ Settings
Enable Inside Bar — toggles Inside Bar detection.
Look Back (compare window) — history window used to judge contraction quality.
Enable Trend Filter — gates long/short triggers relative to Trend MA.
Show Trend MA — plots the Trend MA on chart.
Trend MA Mode — Static or NR-Adaptive (length follows Look Back × multiplier).
MA Type — EMA or RMA smoothing for the Trend MA.
NR — MA Multiplier — scales adaptive MA length from Look Back.
Static MA Length — used when Trend MA Mode is Static.
Look Back Mode — Static or ADX Adaptive.
ADX Length / ADX Low / ADX High — controls adaptive response to trend strength.
LB Min / LB Max — bounds for adaptive Look Back range.
-----------------
Disclaimer
The content provided in my scripts, indicators, ideas, algorithms, and systems is for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or a solicitation to buy or sell any financial instruments. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information.
All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
Indicator
Indicator
Inside Candle Positional StrategyIntroduction
This strategy implements a structured Inside Candle breakout model designed to capture expansion moves following short-term price compression.
An inside candle represents a temporary contraction in volatility, where the entire range of the current bar is contained within the previous bar. The preceding bar becomes the Mother Candle, and its range defines the potential breakout boundaries.
The model focuses purely on price structure and predefined risk parameters rather than trend-following overlays or momentum filters.
Core Logic and Structure
Inside Candle Detection
An inside candle is defined as:
Current High < Previous High
Current Low > Previous Low
When this condition occurs, the previous bar is marked as the Mother Candle. Only one breakout attempt is allowed per identified structure to prevent repeated entries within the same consolidation phase.
Trade Entry Rules
Entries are executed at market on confirmed bar close.
Long Position
Close > Mother Candle High
No active position
Short Position
Close < Mother Candle Low
No active position
This ensures breakout confirmation rather than anticipatory positioning.
Risk Management Framework
Risk control is fully rule-based and determined at the moment of entry.
For each trade:
Initial Stop Loss = Opposite boundary of the Mother Candle
Risk = Distance between entry price and initial stop
Target = Entry ± (Risk × Risk-Reward Ratio)
The Risk-Reward Ratio is user configurable.
Only one position is active at any time (pyramiding disabled).
Optional ATR-Based Trailing Stop
An optional trailing mechanism may be enabled:
Trailing Stop updates on every confirmed bar.
Calculated using ATR × Multiplier.
Moves only in the direction of profit.
Never worsens beyond the initial stop level.
If disabled, exits rely solely on the fixed stop and target.
Execution Model
All signals are calculated on confirmed bar closes.
Entries are market orders.
Stop and target levels are evaluated using bar OHLC values.
No repainting logic is used.
No intrabar order sequencing assumptions are applied.
Backtest performance may differ from live execution due to slippage, spread, liquidity, and market conditions.
Visual Components
Inside candles are highlighted (default: yellow).
Entry, Initial Stop, Trailing Stop (if enabled), and Target levels are displayed using line-break formatting for clarity.
Designed to maintain structural visibility without excessive chart clutter.
Strategy Defaults
Initial Capital: $1000
Commission: 0.05%
Position Size: 1 (fixed quantity)
Pyramiding: Disabled
These defaults can be adjusted in the Strategy Properties panel.
Intended Application
This strategy is suited for studying breakout behavior after short-term consolidation phases.
Performance characteristics will vary depending on instrument volatility, timeframe, and market regime.
It is presented as a structural breakout framework and should be tested and adapted according to individual risk tolerance and trading objectives.
Disclaimer
Trading involves significant risk. This script is provided for educational and research purposes only and does not constitute financial advice. Users are responsible for evaluating its suitability for their own trading decisions. Strategy
Indicator
Toby Crabel's HisVolAs in Linda Raschke's Street smarts..... . This indicator shows the signals of Toby Crabel's Historical Volatility 6/100 strategy. The strategy assumes, that volatility contraction measured by two measures would give better results.
There is one other script that is a strategy , but it assumes that the signal requires both inside bar and narrowest range, what is not as in Linda Raschke's.
The strategy and what does the script do:
1) measures short-term unannualized volatility (by default six), long term uannualized volatility (by default 100), and measures the ratio of short volatility / long volatility.
2) checks if the current bar is an inside bar or has narrowest range out of last X bar (by default 4), or both,
3) puts an etiquette if short volatility / long volatility is equal to or smaller than 0,5 AND the day is inside bar, has narrowest range, or both.
Next day both buy-stop and sell-stop should be set. Buy-stop at the high and sell-stop at the low of the bar with etiquette.
This is by no means any financial advice, nor the historical results guarantee future gain.
Indicator
Indicator
Indicator
Indicator
Indicator
Indicator
Candle Range Detector by TradeTech AnalysisCandle Range Detector by TradeTech Analysis
This advanced indicator identifies and visualizes price compression zones based on inside bar formations, then tracks how price behaves around those zones — offering valuable insights into liquidity sweeps, range expansions, and trap/mitigation behavior.
The script builds upon the foundational concept of range-based price action, commonly used by institutional traders, and adds automation, mitigation tracking, and sweep detection to map how price reacts around these critical ranges.
🔍 How It Works:
• Range Formation: A new range is detected when the current candle forms entirely within the high and low of the previous candle (i.e., an inside bar). This behavior often indicates price compression and potential breakout zones.
• Range Extension: Once a range is confirmed, the script projects upper and lower boundaries (using either a percentage-based multiplier or Fibonacci log extension), providing context for expected breakout zones.
• Mitigation Tracking: The script continuously monitors whether price breaks above or below the projected extensions, marking that range as mitigated — useful for confirming whether liquidity was absorbed.
• Sweep Detection: If price re-visits a mitigated zone and shows signs of a liquidity sweep (via wick + close behavior), the indicator triggers visual sweep labels and optional alerts.
🧠 Optional Visual Enhancements:
• Highlight range-forming candles with light blue background (toggle on/off)
• Midpoint dotted line for symmetry analysis
• Labels for “Range High” and “Range Low” for visual clarity
• Dynamic box drawing that adapts upon mitigation or continuation
⚙️ Customizable Features:
• Choose between Normal and Fibonacci-based detection modes
• Toggle visibility of range boxes, extension lines, and sweep markers
• Configure sweep alerts, mitigation window size, and visual transparency
⸻
🧪 Use Cases
• Identify consolidation zones before major price moves
• Confirm liquidity sweeps for entry/exit traps
• Visualize and test mitigation behavior of past zones
• Combine with Order Flow or Volume Profile tools to enhance context
⸻
⚠️ This is a fully original implementation that goes beyond classical inside-bar scanners by incorporating mitigation, extension projection, and liquidity sweeps — making it a powerful tool for intraday, swing, and even Smart Money-based trading setups. Indicator
Indicator
Indicator
Inside Bar with Swing PointsSwing Points with Inside Bar
This script combines swing point analysis with an inside bar pattern visualization, merging essential concepts to identify and visualize key price levels and potential trend reversals. This is especially useful for traders looking to understand price action through swing levels and reactions within inside bar boundaries, making it effective for short-term trend analysis and reversal zone identification.
Script Features:
Swing Point Analysis:
The script identifies swing points based on fractals with a configurable number of bars, allowing for a choice between three and five bars, helping traders fine-tune sensitivity to price movements.
Swing points are visualized as labels, highlighting potential reversal or continuation zones in the price chart.
Inside Bar Visualization:
Inside bars are defined as bars where both the high and low are contained within the previous bar. These often signal consolidation before a potential breakout.
The script displays boundaries of the mother bar (the initial bar encompassing inside bars) and colors candles accordingly, highlighting those within these boundaries.
This feature helps traders focus on price areas where a breakout or trend shift may occur.
Utility and Application:
The script enables traders to visualize inside bars and swing points, which is particularly useful for short-term traders focused on reversal or trend continuation strategies.
Combining swing point analysis with inside bar identification offers a unique approach, helping traders locate key consolidation zones that may precede significant price moves.
This provides not only strong support and resistance levels but also insights into probable breakout points.
How to Use the Script:
Set the number of bars for swing point analysis (3 or 5) to adjust fractal sensitivity.
Enable mother bar boundary visualization and color indication for inside bars to easily spot consolidation patterns.
Pay attention to areas with multiple swing points and inside bars, as these often signal potential reversal or breakout zones.
This script offers flexible tools for analyzing price movements through both swing analysis and consolidation zone identification, aiding decision-making under uncertainty and enhancing market structure understanding. Indicator
Indicator
