The upper edge of the band, as a number line — e.g. a Bollinger upper or a Keltner upper channel.

upper

The lower edge of the band, as a number line — e.g. a Bollinger lower or a Keltner lower channel.

lower

Band Re-Entry fires when price leaves a band (a Bollinger or Keltner channel, an envelope, anything with an upper and lower edge) and then comes back inside. It’s a classic mean-reversion trigger: the snap-back after a stretch, not the stretch itself.

Fires when price dips below the lower band and then climbs back up through it — a snap-back from oversold.

Fires when price pokes above the upper band and then falls back down through it — a fade from overbought.

A bundle reporting the re-entry: whether price came back inside the chosen band this bar, plus the supporting context for downstream stages.

Which band edge to watch for the re-entry — ‘lower’ catches price climbing back up through the lower band (a long setup), ‘upper’ catches price falling back down through the upper band (a short setup).

side

How many bars the re-entry may take after price first exited the band; if price doesn’t come back inside within this many bars the pending setup is dropped. Smaller demands a quick snap-back; larger tolerates a slow drift back.

within_n

The first number line (e.g. a fast moving average).

series_a

The second number line (e.g. a slow moving average or a level).

series_b

First bar of the scan window (windowed_count mode).

start_offset

Last bar of the scan window (windowed_count mode).

end_offset

Cross watches two lines and fires true on every bar where the relationship you picked happens. It's the workhorse for crossover strategies: a fast line crossing a slow line, a price touching a level, or two lines pulling apart.

Fires on the exact bar the two lines cross.

Fires if a cross happened within the last few bars.

Counts how many crosses fall inside a bar window.

Fires only after the new side holds for `dwell` bars.

Fires once the lines separate by `min_gap` after crossing.

Fires when the lines come within `epsilon` of each other.

Fires when the lines touch then pull apart.

Fires while the gap between the lines is shrinking.

Fires while the gap between the lines is widening.

Only when series_a rises through series_b.

Only when series_a falls through series_b.

Evaluates only finished bars — never repaints.

Reacts inside the forming bar in tick mode.

min_gap / epsilon are raw price differences.

min_gap / epsilon are a percent of the midpoint.

A move off exact equality counts as a cross.

Carries the prior side forward through equality.

A boolean that is true on each bar the chosen cross event occurs.

Picks which crossing event to detect: instant_cross, recent_cross, windowed_count, confirmed_cross, threshold_cross, touch, touch_and_reject, convergence, or divergence.

mode

Which side fires the signal — 'up' when series_a rises through series_b, 'down' when it falls through, or 'any' for both.

direction

'Closed' (recommended) evaluates only finished bars so nothing repaints; 'live' reacts inside the current bar in tick mode but can flip before the bar closes.

bar_alignment

How many bars back the event may have happened and still count; 1 means this bar only, larger values accept later entries.

lookback

When on, searches future bars instead of past ones — safe only with indicators already plotted into the future; leave off for normal indicators.

forward

How many bars in a row the gap must shrink (convergence) or widen (divergence) to fire; larger values trigger rarely but with more conviction.

window

The smallest number of crossings the window must contain to fire; 1 is the classic 'at least one cross' gate.

min_count

The largest number of crossings the window may contain; -1 means no upper cap, and Min and Max both at 0 makes a 'no crosses allowed' gate.

max_count

Off (recommended) slides the window bar-by-bar so each bar gets its own answer; on fixes the window in time for legacy Shayan setups.

absolute

How many bars the new trend must hold before a confirmed cross fires; higher gives later but more reliable entries.

dwell

How far the lines must separate after a threshold cross before it fires; a re-cross before this distance cancels the pending signal.

min_gap

How close the lines must be to count as touching; 0 requires exact equality, a small positive value means 'close enough'.

epsilon

Units for min_gap and epsilon — 'price' uses the raw difference, 'percent' uses percent of the midpoint so it scales across symbols.

gap_unit

What to do when the lines were exactly equal last bar — 'treat_as_cross' (recommended) counts the move off equality, 'ignore' blocks it, 'hold_state' carries the prior side forward.

equality_policy

After a cross fires, ignore further crosses for this many bars to stop rapid back-and-forth signals; 0 disables it.

recross_suppress

The first number line (e.g. price or a fast moving average).

The second number line to measure against the first (e.g. a slow moving average or a level).

Absolute Distance reports the size of the gap between two number lines on each bar, ignoring which one is higher. It is simply the absolute value of a minus b, so the result is never negative.

A non-negative line: the absolute gap between the two inputs each bar. It shrinks to zero where the lines meet and grows as they pull apart.

The price line whose pivots are compared against the indicator (usually the close).

The indicator line checked for disagreement with price (a momentum oscillator works well).

Divergence compares the swings of price against the swings of an indicator and flags when they disagree — for example price making a higher high while the indicator makes a lower high. Such disagreements often warn that a move is losing strength.

A bundle describing any detected divergence — its kind (regular or hidden), direction (bullish or bearish), and the pivot points that formed it.

How many bars on each side a swing must dominate to count as a pivot. Larger values keep only the major turning points and give rarer, higher-conviction divergences; smaller values catch minor swings and fire more often.

pivot_lookback

The wave 1 leg of the impulse, as a zigzag leg (its start and end pivots). Wire it from a zigzag pattern detector that labels the impulse legs.

wave_1

The wave 3 leg, as a zigzag leg. Together with wave 1 it sets the net 1–3 distance used by the w5_net mode.

wave_3

The wave 4 leg, as a zigzag leg. Its end pivot is the anchor that wave-5 targets are measured from.

wave_4

The wave A leg of a correction, as a zigzag leg. The c_by_type mode projects wave C from this leg’s length.

wave_a

Elliott Wave Projection takes the legs you have already counted in an impulse and forecasts where the next wave should end. Feed it waves 1, 3 and 4 to project the top (or bottom) of wave 5, or feed it wave A to project where a corrective wave C should finish.

Projects wave 5 to the same price length as wave 1, measured off the end of wave 4.

Sizes wave 5 as a Fibonacci ratio of the net distance travelled across waves 1 through 3.

Projects the end of corrective wave C, sizing it from wave A according to the chosen corrective shape.

Draws the 0.618 multiple of the net 1–3 move — a shallow wave-5 target.

Draws the 1.0 multiple — wave 5 travels the full net distance of waves 1 through 3.

Draws the 1.618 multiple — an extended wave 5 that overshoots the net 1–3 move.

Sizes wave C like a sharp 5-3-5 zigzag, where C extends well beyond the end of wave A.

Sizes wave C like a shallow 3-3-5 flat, where C ends near the level of wave A.

A bundle of projected target levels — the price (or prices) where the forecast wave should end, ready to wire into a level read or an order’s take-profit.

What to project: w5_equality sets wave 5 equal to wave 1, w5_net sizes wave 5 by a Fibonacci ratio of the net waves 1–3, and c_by_type projects corrective wave C from wave A using the corrective shape.

Which Fibonacci multiples of the net 1–3 move to draw in w5_net mode — any combination of 0.618 (shallow), 1.0 (equal) and 1.618 (extended). Each selected ratio adds one projected wave-5 target level.

net_ratio

How c_by_type sizes wave C — 'zigzag' for a sharp correction where C runs far past wave A, or 'flat' for a shallow correction where C finishes near wave A.

corrective_type

The first Fibonacci source — a bundle of levels from one retracement, extension, or projection.

source_0

The second Fibonacci source, pooled with the others when source_count ≥ 2.

source_1

The third Fibonacci source, used when source_count ≥ 3.

source_2

The fourth Fibonacci source, used when source_count ≥ 4.

source_3

The fifth Fibonacci source, used when source_count ≥ 5.

source_4

The sixth Fibonacci source, used when source_count is 6 (the maximum).

source_5

An ATR line used to scale the clustering band when tolerance_mode is atr; ignored by the percent and points modes.

Fibonacci Cluster finds price zones where Fibonacci levels drawn from several different swings stack up close together. When levels from many sources land near the same price, that price is a high-confluence area traders watch for reactions.

The clustering band is scaled by current ATR, so it widens in volatile conditions and tightens in quiet ones.

The band is a percent of price, so the same setting behaves consistently whether price is 1.10 or 1900.

The band is a fixed number of points, ignoring volatility and price level entirely.

A bundle of cluster zones — each a price band where enough source levels stacked up, with its member count signalling confluence strength.

How many of the six source slots are live, from 1 to 6. Only that many bundles are pooled when searching for clusters; the rest are ignored even if wired. More sources means more potential confluence but also more noise.

source_count

How the clustering band is measured: 'atr' scales it by current ATR, 'percent' makes it a percent of price, 'points' uses a fixed price width.

tolerance_mode

The ATR multiple defining the band width when tolerance_mode is atr; e.g. 0.25 groups levels within a quarter of an ATR of each other.

tolerance_atr_mult

The band width as a percent of price when tolerance_mode is percent; e.g. 0.1 means levels within 0.1% of each other join the same cluster.

tolerance_percent

The band width in fixed points when tolerance_mode is points; the absolute price distance under which levels merge.

tolerance_points

The fewest separate levels a group must contain to be emitted as a cluster. 2 reports any pair of agreeing levels; raise it to demand stronger confluence.

min_members

The leg the fan radiates from — wire the Fibonacci Anchor's leg or any zigzag leg. Sparse legs (pattern matches) are forward-filled to the last confirmed one.

Optional per-bar price tested against each ray — usually the bar close. Left unwired, the above/below gates simply stay false while the ray prices still flow.

price

Fibonacci Fan draws MT5's classic fan rays for one leg: straight lines from the leg's start pivot through its 38.2 / 50 / 61.8 retracement levels at the leg's end, extended forward. Each ray's per-bar price is a wireable handle, and above/below gates tell you which side of a ray price is on.

A bundle with a per-bar validity gate, the leg direction, one ray price per active slot (a wireable price handle — cross it with close for ride/break, or feed order TP/SL), and above_N / below_N gates that read the optional price input.

How many fan rays to draw, from 1 to 6. The default 3 is MT5's classic trio 38.2 / 50 / 61.8; higher counts add the 23.6 / 78.6 / 100 extensions. Only the first fan_count of the fan_N_pct percents are used.

fan_count

Percent retracement anchoring ray #0: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 38.2.

fan_0_pct

Percent retracement anchoring ray #1: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 50.

fan_1_pct

Percent retracement anchoring ray #2: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 61.8.

fan_2_pct

Percent retracement anchoring ray #3: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 23.6.

fan_3_pct

Percent retracement anchoring ray #4: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 78.6.

fan_4_pct

Percent retracement anchoring ray #5: the ray passes through end + (start − end) × (pct / 100) at the leg's end bar (0 = the leg's end, 100 = its start). Default 100.

fan_5_pct

The swing leg to retrace, as a zigzag leg (its start and end pivots). Wire it from a zigzag or swing detector; its low and high anchor the 0 and 1.0 of the OTE scale.

The current price line tested against the zone — usually the bar close. The output flags true on bars where this price sits inside the OTE band.

Fibonacci OTE marks the ICT “Optimal Trade Entry” zone — the slice of a pullback between roughly the 62% and 79% retracement where smart-money entries are said to cluster. It also flags the 50% equilibrium that splits a leg into a discount half and a premium half.

A bundle describing the OTE band and equilibrium plus a flag for whether the wired price is currently inside the zone — wire the flag into a filter, or the zone bounds into an order’s entry and stop.

The shallow edge of the OTE zone, as a retracement fraction of the leg — the classic value is 0.62 (a 62% pullback). Price must retrace at least this far to enter the zone.

ote_low_pct

The center of the OTE zone — its preferred fill point, typically 0.705 (the midpoint of 0.62 and 0.79). Use it to rank entries that land deepest in the sweet spot.

ote_mid_pct

The deep edge of the OTE zone, classically 0.79 (a 79% pullback). Past this the retrace is treated as too deep and the setup is usually invalidated.

ote_high_pct

The fraction that divides the leg into a discount half (below) and a premium half (above) — almost always 0.5. Longs are favoured at a discount, shorts at a premium.

equilibrium_pct

A small tolerance added around the zone edges so price that just grazes the boundary still registers as inside — it stops the in-zone flag from flickering on and off near 0.62 or 0.79.

deadband_pct

The A→B impulse as one leg bundle — A is the leg’s start, B its end. Used by the default leg_plus_point mode.

The first pivot (start of the impulse) as a zigzag bundle. Used by three_points mode.

point_a

The second pivot (end of the impulse) as a zigzag bundle. The A→B distance is what gets projected.

point_b

The launch pivot C — the end of the retracement against A→B; every target anchors on it. Used by leg_plus_point and three_points.

point_c

A raw price for point A in three_prices mode.

price_a

A raw price for point B in three_prices mode.

price_b

A raw price for point C in three_prices mode — the level the targets project from.

price_c

Trend-Based Fib Extension takes a three-point A-B-C move and projects extension targets beyond it — price levels like 0.618, 1.0 and 1.618 of the A→B swing measured from C. This is the tool TradingView calls “Trend-Based Fib Extension” and MetaTrader calls “Fibonacci Expansion”. Traders use these as profit targets and likely turning points.

Supplies the A→B impulse as one leg bundle plus the launch pivot C — the same 3-point geometry with one wire fewer.

Supplies A, B and C as zigzag pivot bundles; the node measures A→B, then projects the ratio targets forward from C.

Supplies A, B and C as raw price numbers instead of pivot bundles, then lays out the projection ladder from those values.

A bundle of projected target levels — each ratio paired with the price it projects to from C — ready to use as take-profit levels or as zones to watch for reversals.

How the A-B-C geometry is supplied: ‘leg_plus_point’ (one leg bundle for A→B plus the launch pivot C — the default), ‘three_points’ (pivots A, B and C), or ‘three_prices’ (raw prices A, B and C). The inspector greys out the inputs that don’t apply to the chosen mode.

How many projection levels to draw, from 1 up to 8. More levels give a fuller target ladder (e.g. 0.618, 1.0, 1.618, 2.618) while fewer keep just the key extensions. Only the first `ratio_count` of the `ratio_N` values are used.

ratio_count

The 1st projection multiple of the A→B move, measured from C. A common value is 0.382.

ratio_0

The 2nd projection multiple. A common value is 0.618.

ratio_1

The 3rd projection multiple. 1.0 means the move from C equals the A→B distance.

ratio_2

The 4th projection multiple. The 1.618 golden extension is the classic target.

ratio_3

The 5th projection multiple. A common value is 2.0.

ratio_4

The 6th projection multiple. A common value is 2.618.

ratio_5

The 7th projection multiple, a deeper extension such as 3.618.

ratio_6

The 8th projection multiple, a far extension such as 4.236.

On-Balance Volume

Inputs

Outputs

How it works

Connects to

Examples

Common mistakes

See also