Inizia

Fairvaluegap

NoLos FVG IndicatorOVERVIEW NoLo's FVG is a powerful and customizable Fair Value Gap indicator built for Smart Money Concepts (SMC) and Inner Circle Trader (ICT) traders. It detects bullish and bearish Fair Value Gaps, draws clean boxes on top of the candles, and gives you all the key information needed for high-probability trades: 50 percent midline entry zones, gap size with percentage, FVG age, retest signals, and automatic mitigation. KEY FEATURES Accurate FVG detection with optional minimum gap size filter (in ATR) to reduce noise. Clean visuals: boxes render clearly on top of candles with adjustable transparency and border width. 50 percent yellow dashed midline marks the ideal retest entry zone. Live labels show gap size (price and percent), age in bars, and highlight "RETEST" zones in orange. Flexible mitigation: choose Wick Touch, Close Inside, or Full Fill. Option to hide mitigated gaps or turn them gray. Multi-timeframe support: show FVGs from a higher timeframe on your current chart. Retest alerts: get notified when price returns to an active FVG for precise entries. Performance options: limit maximum active FVGs and extend boxes to the right. HOW TO USE Identify fresh Bullish FVG (green) or Bearish FVG (red) zones. Wait for price to retest the zone - the label will show "RETEST" and change color. Enter near the 50 percent yellow midline with good confluence (higher timeframe bias, order blocks, etc.). Place stop loss just beyond the FVG and target the next liquidity level or opposite FVG. SETTINGS HIGHLIGHTS Enable Multi-Timeframe FVGs and select the higher timeframe. Adjust box transparency and border width for perfect readability. Choose mitigation type and whether to hide filled gaps. Turn on retest alerts for real-time notifications. Best suited for ICT and SMC traders working with price action and order flow. Works on any market (Forex, Gold, Indices, Crypto, Futures) and all timeframes. NoLo's FVG keeps your chart clean and focused, giving you only the essential information for confident trading decisions.
Indicatore Pine Script®
di Cryptonologic
BAEMFX - Vortex FVG: Deep Mitigation EngineHere is a clear and professional description in English that you can use for the public release on TradingView. It explains the logic simply so that other traders understand the value of the BAEMFX system. Description The BAEMFX - Vortex FVG: Deep Mitigation Engine is a high-precision trading tool designed for Smart Money Concepts (SMC) and Price Action traders. It identifies Fair Value Gaps (FVG) on higher timeframes and projects them onto your current chart to find accurate entry zones. Unlike standard FVG indicators that disappear as soon as they are touched, this engine uses a Dual-Stage Mitigation Logic to provide better visual context for entries. Key Features Multi-Timeframe Analysis: Scan for gaps on H4, Daily, or any higher timeframe and trade them on lower timeframes like M1 or M5 with perfect time-alignment. Dual-Stage Visuals: Entry Trigger (50%): When price reaches the Mean Threshold (50%) of the FVG, the box changes color instantly to signal an active entry zone. Full Mitigation (100%): The box remains on your chart until the gap is completely filled, allowing you to see how price reacts to the zone multiple times. ATR Proximity Filter: Automatically hides gaps that are too far from the current price, keeping your chart clean and focused only on actionable setups. Dynamic Extension: Boxes automatically extend to the right in real-time until they are mitigated, ensuring you never miss a retest. How to Use Set Analysis TF: Choose your higher timeframe (e.g., Daily or 4H) in the settings. Monitor the Zone: Wait for the price to enter the box. The Signal: Once the price touches the dashed midline (50%), the box color deepens. This is your BAEMFX Entry Zone. Exit/Invalidation: The box will delete itself only once the price has traded completely through the FVG (100% fill). Settings Timeframe of Analysis: The HTF you want to scan. Proximity Filter: Multiplier based on ATR to filter out distant gaps. Max FVG Active: Limits the number of displayed boxes to prevent chart clutter.
Indicatore Pine Script®
di baemfx
Multi-Timeframe HTF FVG + MidpointsAn open-source multi-timeframe Fair Value Gap indicator with midpoints and mitigation logic. Detects and displays higher-timeframe FVGs (hourly to daily), draws stable fixed-width gap boxes, and plots midpoint levels with clean labels. Built specifically to solve common MTF rendering issues — FVGs remain persistent and properly aligned across timeframe changes. Features: - Bullish & bearish HTF FVG detection (1H, 2H, 3H, 4H, 1D) - Persistent boxes across timeframe intervals - Midpoint lines and labels - Multi-timeframe structure display - Mitigation tracking - Optional mitigated-zone visibility Notes: • For charting and study purposes only • Not financial advice • Open source by design — modify and adapt as needed
Indicatore Pine Script®
di maggiejohnson
FVG Touch Extension [TAG]FVG Touch Extension highlights Fair Value Gaps using a simple three-candle imbalance model and extends each zone to the right until price revisits it. This indicator is designed to help traders identify price areas where the market moved with enough speed and aggression to leave an imbalance behind. In practical terms, these are zones where one side of the market was clearly stronger than the other, causing price to move through levels quickly instead of trading efficiently through them. How the script defines an FVG This script uses a three-candle structure: Bullish FVG A bullish gap exists when the low of candle 3 is above the high of candle 1 The empty space between those two prices is the bullish FVG Bearish FVG A bearish gap exists when the high of candle 3 is below the low of candle 1 The empty space between those two prices is the bearish FVG To filter out weak or meaningless gaps, the script only plots an FVG when the gap size is at least a user-defined percentage of the size of candle 2. By default, that threshold is 40%. Why Fair Value Gaps matter At Alpha Group, we interpret an FVG as a sign of liquidity imbalance. When a bullish FVG appears, it suggests that buying pressure was aggressive enough to move through available liquidity quickly. In other words, buyers were willing to keep paying higher prices, and the market moved fast because there was not enough sell-side liquidity at those levels to absorb that flow in a balanced way. When a bearish FVG appears, the logic is the opposite. Selling pressure was aggressive enough to consume the available bids quickly, forcing price lower as sellers hit the market with more urgency than the available buy-side liquidity could absorb. That is why these zones matter. They often represent areas where the market moved too efficiently in one direction and may later return to reassess that imbalance. How to read the zones An FVG is not a stand-alone buy or sell signal. It is a market structure and order-flow clue. When price revisits an FVG, that zone can become a useful decision area for several reasons: It can act as a pullback zone in a trending market It can help frame a continuation trade It can help evaluate whether price is likely to reject or trade through the imbalance It can provide a cleaner location to judge whether buyers or sellers are still in control Our internal Alpha Group reading is straightforward: If price returns to a bullish imbalance and buyers defend it cleanly, that can support a bullish continuation view. If price returns to a bearish imbalance and sellers defend it cleanly, that can support a bearish continuation view. If price trades through the zone easily, the original imbalance may no longer be respected, and the market may be signaling weaker conviction from the side that created it. Extension logic Each FVG is drawn as a box and extends to the right until price touches the zone. This matters because the indicator is trying to preserve the practical usefulness of the imbalance: If price has not returned to that area yet, the zone remains active and continues extending Once price touches the zone, the extension stops, marking the first revisit This gives traders a cleaner view of which imbalances are still untouched and which ones have already been tested. Color logic This script colors FVGs based on their location relative to the current price: Green: FVG below the current price Red: FVG above the current price This is a visual context feature. It helps quickly distinguish whether the gap is currently under price or above price without forcing the trader to manually inspect each zone. Inputs Minimum Gap Size as % of Candle 2 Filters out small gaps. Default is 40%. Use Candle 2 Body Instead of Full Range Lets you compare the gap against either the full candle range or only the candle body. Maximum Active/Stored FVGs Controls how many zones remain stored and displayed. Best use cases This tool is best used as a context indicator, not as a complete trading system by itself. It can be useful for: Trend pullback analysis Intraday continuation setups Breakout retest planning Structure-based discretionary trading Confluence with market structure, support/resistance, order blocks, session levels, or volume Important note This script identifies a specific technical condition based on price gaps across a three-candle sequence. It does not predict direction by itself and should not be treated as financial advice or as a guaranteed edge. Use it as one part of a broader decision process.
Indicatore Pine Script®
di TheAlphaGroup
Fair Value Gap Detector | AlphaScriptFair Value Gap Detector | AlphaScript Fair Value Gap Detector is a systematic Smart Money Concepts (SMC) tool designed to identify and track Fair Value Gaps (FVGs) directly on your chart, helping traders visualize inefficiencies in price delivery. Built with a structured and quantitative approach, this tool highlights high-quality imbalances while filtering out low-probability noise using volatility-based conditions. 📊 What it does This indicator helps you: -Detect bullish and bearish Fair Value Gaps -Identify areas of market inefficiency -Track when gaps are mitigated (filled by price) -Filter out low-quality setups using ATR-based conditions -Visualize key levels with optional midpoint (50%) lines ⚙️ How it works The logic is based on a 3-candle imbalance model, where gaps are identified between price ranges that did not trade efficiently. To improve signal quality, the tool includes: -ATR-based filtering to remove insignificant gaps -Two mitigation modes: Touch: gap considered filled at the midpoint Close: gap filled only after full price closure through the zone -Dynamic tracking of active FVGs with automatic removal once mitigated -Configurable limit on displayed gaps to keep charts clean and readable 🎯 How to use it This tool can be used to: -Identify reaction zones where price may return -Anticipate retracements or continuation areas -Add confluence around liquidity and imbalance zones -Structure entries using inefficiency fills Typical approach: -Look for bullish FVGs in uptrends -Look for bearish FVGs in downtrends -Use the midpoint (50%) as a refined entry level -Combine with higher timeframe bias and market structure 🔔 Alerts Built-in alerts allow you to track: -New bullish or bearish FVGs -Mitigation events when price interacts with a gap -Any new imbalance detected on your chart 🧠 Ideal for -Traders using Smart Money Concepts (SMC) -Price action and structure-based traders -Swing traders and intraday traders -Anyone looking to add objective imbalance tracking to their system 📝 Notes This indicator is a decision-support tool, not a standalone strategy. Best results come from combining it with proper risk management, market context, and a structured trading approach. To explore our AI-powered trading system and indicator development platform, visit: alphascript.co
Indicatore Pine Script®
di AlphaScript
Fair Value Gap Profile + Rolling POC [BigBeluga]🔵 OVERVIEW FVG Profile builds a price-level profile based on detected Fair Value Gaps (FVGs) over a fixed lookback period. Instead of measuring traded volume alone, this tool aggregates bullish and bearish FVG occurrences into horizontal bins, allowing traders to see where price inefficiencies are most concentrated. Each profile level represents how many bullish and bearish FVGs formed near that price zone, along with their relative strength, imbalance, and delta volume. 🔵 CONCEPTS FVG Detection — • Bullish FVG: when the high two bars back is below the current low. • Bearish FVG: when the low two bars back is above the current high. Price Binning — The full price range of the lookback period is divided into fixed bins. FVG Aggregation — Each detected FVG is mapped to its nearest price bin and counted. Directional Separation — Bullish and bearish FVGs are stored separately inside each bin. 🔵 FEATURES Bull / Bear FVG Profile — • Green segments represent bullish FVG counts. • Orange segments represent bearish FVG counts. • Each bin visually shows how many FVGs occurred at that level. Strength Percentage — • Each bin displays a % value based on total FVG count. • The strongest bin is normalized to 100%. Delta Volume — • Calculates the difference between bullish and bearish FVG volume per bin. • Positive delta = bullish dominance. • Negative delta = bearish dominance. Heatmap Mode — • Colors profile levels by relative strength. • Color direction is driven by delta volume (bullish vs bearish). Live FVG Visualization — Optionally plots individual bullish and bearish FVG boxes on the chart. Profile Background — A background frame highlights the full analyzed price range. 🔵 Rolling POC Logic Unlike a static profile, the Rolling POC moves with price. It continuously calculates the "peak imbalance level" for the last X bars, providing a moving average of where the market's most significant gaps are forming. 🔵 Moving Average Integration The indicator features a customizable Moving Average (SMA, EMA, WMA, VWMA, etc.). This MA helps identify if the price is currently trending toward or away from high-density FVG zones. An "Auto" length feature is included that scales the MA based on the selected lookback period for optimal smoothing. 🔵 HOW TO USE Identify FVG Clusters — Strong profile levels highlight prices where inefficiencies repeatedly formed. Directional Bias — Compare bullish vs bearish segments to determine dominance at each level. Delta Confirmation — Use delta volume to confirm whether bullish or bearish FVGs control the zone. Reaction Zones — High-strength bins often act as areas of interest for price reactions. Heatmap Context — Enable heatmap to quickly spot dominant imbalance zones across the range. 🔵 CONCLUSION FVG Profile transforms Fair Value Gaps into a structured price-level profile, revealing where inefficiencies cluster and which side dominates those zones. By combining FVG count, directional balance, delta volume, and strength normalization, it provides a powerful way to analyze imbalance behavior beyond traditional volume profiles.
Indicatore Pine Script®
di BigBeluga
6
Volumetric Inverse Fair Value Gap (VIFVG) [UAlgo]Volumetric Inverse Fair Value Gap is an imbalance analysis tool that tracks the full lifecycle of a Fair Value Gap and then focuses on what happens after that gap fails. Instead of stopping at the initial gap detection, the script stores qualifying bullish and bearish FVGs, waits for price to invalidate them from the opposite side, and then converts those failed imbalances into active Inverse Fair Value Gaps. The main idea is rooted in role reversal. A bullish Fair Value Gap may initially represent an area of inefficiency below price, but if price later trades through that gap in the opposite direction, the same zone can flip into a bearish inverse area. The same logic applies in reverse for bearish gaps that later fail to the upside. This script automates that transition and keeps the resulting IFVG visible on the chart as long as it remains active. What makes this version more distinctive is the volumetric overlay inside the inverse zone. Once an IFVG is created, the script attaches three internal metrics to it. The first estimates bullish participation, the second estimates bearish participation, and the third measures relative volume strength using percentile rank. These values are then displayed inside the box as horizontal progress bars, turning the IFVG into both a structural level and a compact participation summary. The indicator also supports a ghost box that preserves the original FVG location from the moment it was created until the moment it became inverse. This gives the user a clearer narrative of how the imbalance formed and where the role reversal occurred. Combined with the active box, the result is a visually informative workflow for traders who want to study failed imbalances, structure flips, and how strong the inversion candle was when the role change happened. In practical use, the script can help identify zones where a former inefficiency has turned into a reaction area, while also showing whether the inversion event carried more bullish pressure, more bearish pressure, or unusually strong participation relative to recent volume history. 🔹 Features 🔸 Fair Value Gap Detection With ATR Filtering The script first detects classic three candle FVG structures, then filters them using a minimum gap size expressed in ATR units. This helps reduce noise and removes smaller gaps that may be less meaningful. 🔸 Strict and Non Strict Detection Modes Strict mode requires actual wick separation between the first and third candle. Non strict mode allows close based confirmation instead. This gives the user control over how precise the gap definition should be. 🔸 Pending FVG Lifecycle Tracking Detected FVGs are not immediately turned into inverse zones. They are first stored as pending gaps and monitored until price later crosses them in the opposite direction. 🔸 Automatic FVG to IFVG Conversion When price invalidates a pending gap from the opposite side, the script creates a new Inverse Fair Value Gap object and begins tracking it as an active zone. 🔸 Ghost Box Support The original FVG can be preserved visually as a dashed ghost box from the creation time of the imbalance to the inversion time. This makes it easier to see the original gap and the later role reversal event together. 🔸 Volumetric Breakdown Inside the IFVG Each active inverse gap includes three stacked internal bars: estimated bullish participation, estimated bearish participation, and relative strength. This gives the zone more context than a normal box alone. 🔸 Participation Estimation From Candle Anatomy Bullish and bearish participation are estimated from the inversion candle’s structure and volume. This creates a practical volume split model that helps describe how the inversion occurred. 🔸 Strength Metric From Volume Percentile Rank The script measures how strong the inversion candle’s volume is relative to the last one hundred bars. This is displayed as a separate strength bar inside the IFVG. 🔸 Live Box Expansion As long as an IFVG remains active, its container extends forward in time. The internal volumetric bars and text labels are updated continuously so the zone remains clear and readable. 🔸 Automatic Invalidation A bullish IFVG is removed if price closes below its bottom. A bearish IFVG is removed if price closes above its top. This keeps the display focused on still valid inverse zones. 🔸 Controlled History Size The script limits how many active IFVGs remain on the chart. Older ones are removed once the display exceeds the selected history count. 🔹 Calculations 1) Defining the Pending Gap and Active IFVG Objects type PendingFVG float top float btm bool is_bull_gap bool processed int created_time type IFVG int start_time int origin_time float top float btm bool is_bull_ifvg float pct_bull float pct_bear float pct_strength box container box ghost_box box bg_bull box bar_bull box bg_bear box bar_bear box bg_str box bar_str label lbl_bull label lbl_bear label lbl_str bool active This is the structural foundation of the script. A PendingFVG stores an imbalance that has been detected but has not yet inverted. It contains the gap boundaries, whether the original gap was bullish or bearish, whether it has already been processed into an inverse gap, and the time when it was created. An IFVG stores the full active inverse gap state. In addition to the price boundaries and direction, it also stores the three internal metrics, the container box, the optional ghost box, the internal background and progress bars, the labels, and the active state. So the script is not just drawing boxes. It is managing two linked object lifecycles: pending FVGs, and active inverse FVGs. 2) ATR Filter for Gap Significance float atr_val = ta.atr(14) The ATR value is used as the script’s minimum significance filter. Instead of accepting every visible gap, the script compares gap size against a fraction of ATR. This is useful because a fixed price threshold would behave very differently across markets and timeframes, while ATR gives a volatility aware reference. So ATR acts as the noise filter that decides whether a newly found gap deserves to be tracked. 3) Estimating Bullish and Bearish Participation calc_metrics(float o, float h, float l, float c, float v) => float rng = h - l float buy_v = 0.0 if rng == 0 buy_v := v * 0.5 else if c >= o buy_v := v * ((math.abs(c - o) + (math.min(o, c) - l)) / rng) else buy_v := v * ((h - math.max(o, c)) / rng) float sell_v = v - buy_v float total = buy_v + sell_v float p_bull = total > 0 ? buy_v / total : 0 float p_bear = total > 0 ? sell_v / total : 0 float p_str = ta.percentrank(v, 100) / 100.0 This function is one of the most important parts of the whole script. Its goal is to turn one candle into three interpretable metrics: bullish share, bearish share, and strength. First, the script measures the candle range. If the candle has zero range, volume is split evenly. If the candle has a real range, the script estimates buying pressure differently depending on candle direction. For bullish candles, buy volume is influenced by the candle body plus the lower section of the candle. For bearish candles, buy volume is approximated from the remaining upper section. The result is not true exchange level aggressor volume, but it is a practical candle anatomy based estimate of how much of the inversion bar behaved more like buying versus selling. Then the script converts those raw buy and sell estimates into proportions: p_bull and p_bear Finally, it calculates p_str using the percentile rank of current volume over the last one hundred bars. That means the strength value is not just raw volume. It describes how relatively strong the inversion candle was compared with recent history. 4) Reading the Current Candle Metrics = calc_metrics(open, high, low, close, volume) This line applies the volumetric function to the current bar. These three values are later attached to a new IFVG at the moment of inversion. So each active inverse gap inherits the participation and strength profile of the candle that caused the role reversal. That is important conceptually. The internal bars inside the IFVG are not random decorations. They represent the inversion event itself. 5) Detecting Bullish and Bearish FVGs bool bull_cond = strict_mode ? (low > high ) : (close > high ) bool bear_cond = strict_mode ? (high < low ) : (close < low ) This block defines the actual Fair Value Gap logic. In strict mode: a bullish gap exists only when the current low is above the high from two bars ago, and a bearish gap exists only when the current high is below the low from two bars ago. That means actual wick separation is required. In non strict mode: the script relaxes this and allows close based confirmation instead. So the user can choose whether the script should only accept clean wick gaps or allow a softer close based definition. 6) Measuring the Gap Size float gap_size = 0.0 if bull_cond and close > open gap_size := low - high if bear_cond and close < open gap_size := low - high bool is_significant = gap_size >= (atr_val * fvg_threshold_atr) Once a candidate FVG is found, the script measures how large the gap actually is. For bullish gaps, the size is the distance between the current low and the high from two bars ago. For bearish gaps, the size is the distance between the low from two bars ago and the current high. The script also adds a candle direction filter on the middle bar: bullish gaps require the middle candle to be bullish, and bearish gaps require the middle candle to be bearish. Finally, the measured gap must be at least as large as: ATR × threshold This removes smaller gaps that may simply be noise. 7) Storing a Pending FVG if is_significant PendingFVG p = PendingFVG.new() p.created_time := time p.processed := false if bull_cond p.is_bull_gap := true p.top := low p.btm := high else p.is_bull_gap := false p.top := low p.btm := high array.push(pending_fvgs, p) If the gap is significant, the script stores it as a pending FVG. The gap is not drawn yet as an inverse zone. Instead, it is placed into the pending list with: its direction, its boundaries, its creation time, and a flag showing it has not yet been processed. This is important because an FVG only becomes an IFVG after it fails. The pending list is the waiting room for that future role reversal. 8) Detecting the Inversion Event if array.size(pending_fvgs) > 0 for i = array.size(pending_fvgs) - 1 to 0 PendingFVG p = array.get(pending_fvgs, i) if not p.processed bool inverted = false bool to_bull = false if not p.is_bull_gap and close > p.top inverted := true to_bull := true if p.is_bull_gap and close < p.btm inverted := true to_bull := false This is the core IFVG transition logic. A pending bearish FVG becomes a bullish IFVG if price closes above its top. A pending bullish FVG becomes a bearish IFVG if price closes below its bottom. That is the actual role reversal event. Price has invalidated the original imbalance from the opposite side, so the gap flips into an inverse form. The to_bull flag determines the direction of the new inverse zone. 9) Creating the IFVG Object if inverted IFVG obj = IFVG.new() obj.start_time := time obj.origin_time := p.created_time obj.top := p.top obj.btm := p.btm obj.is_bull_ifvg := to_bull obj.pct_bull := curr_p_bull obj.pct_bear := curr_p_bear obj.pct_strength := curr_p_str obj.active := true obj.create_drawings() array.push(active_ifvgs, obj) p.processed := true Once inversion is confirmed, the script creates the active IFVG. The new object inherits: the original FVG boundaries, the original creation time, the inversion start time, and the new inverse direction. It also stores: the bullish participation percentage, the bearish participation percentage, and the strength percentage from the inversion candle. So the IFVG is a structural object with a built in event profile. It tells the user not only where the failed gap is located, but also what the inversion bar looked like in participation terms. 10) Creating the Ghost Box and Main Container if show_ghost this.ghost_box := box.new( left=this.origin_time, top=this.top, right=this.start_time, bottom=this.btm, border_color=color.new(c_border, 20), border_width=1, border_style=line.style_dashed, bgcolor=c_ghost, xloc=xloc.bar_time ) this.container := box.new( left=this.start_time, top=this.top, right=time, bottom=this.btm, border_color=c_border, border_width=1, bgcolor=color(na), xloc=xloc.bar_time ) This is the first part of the IFVG drawing engine. If ghost mode is enabled, the script draws a dashed box from the original FVG creation time to the inversion time. This visually represents the original gap before it failed. Then it creates the main IFVG container box starting from the inversion time and extending to the current bar. So the chart can show both: where the original gap existed, and where the inverse zone now lives. 11) Building the Internal Volumetric Bar Areas this.bg_bull := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_bull := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_bull_bar, xloc=xloc.bar_time) this.bg_bear := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_bear := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_bear_bar, xloc=xloc.bar_time) this.bg_str := box.new(this.start_time, this.top, time, this.top, border_width=0, bgcolor=c_bg_dark, xloc=xloc.bar_time) this.bar_str := box.new(this.start_time, this.top, this.start_time, this.top, border_width=0, bgcolor=c_str_bar, xloc=xloc.bar_time) Inside every IFVG, the script creates three horizontal rows. Each row has: a dark background box, and a colored progress bar box. The three rows represent: bullish participation, bearish participation, and strength. Initially these boxes are created with minimal size. Their real geometry is set later during updates. So the IFVG is designed as a mini information panel embedded directly inside the zone. 12) Slicing the IFVG Into Three Metric Rows float total_h = this.top - this.btm float h_slice = total_h / 3 float y1 = this.top float y2 = this.top - h_slice float y3 = this.top - 2 * h_slice float y4 = this.btm This block divides the IFVG vertically into three equal sections. The full height of the box is measured, then split into thirds: the first slice for bullish participation, the second slice for bearish participation, the third slice for strength. This makes the internal visualization clean and consistent regardless of zone height. 13) Converting Percentages Into Horizontal Width int now = time int dur = now - this.start_time if dur <= 0 dur := timeframe.in_seconds() * 1000 int w_bull = math.round(dur * this.pct_bull) int w_bear = math.round(dur * this.pct_bear) int w_str = math.round(dur * this.pct_strength) This is how the script turns percentages into visible progress bars. The available horizontal width is the elapsed time from the IFVG start to the current bar. That duration becomes the maximum usable width. Then each stored metric is multiplied by that duration: bullish percentage controls the bullish bar width, bearish percentage controls the bearish bar width, strength percentage controls the strength bar width. So the internal bars behave like proportion meters stretched across the live duration of the zone. 14) Updating the Bull, Bear, and Strength Bars this.bg_bull.set_left(this.start_time) this.bg_bull.set_right(now) this.bg_bull.set_top(y1) this.bg_bull.set_bottom(y2) this.bar_bull.set_left(this.start_time) this.bar_bull.set_right(this.start_time + w_bull) this.bar_bull.set_top(y1) this.bar_bull.set_bottom(y2) this.bg_bear.set_left(this.start_time) this.bg_bear.set_right(now) this.bg_bear.set_top(y2) this.bg_bear.set_bottom(y3) this.bar_bear.set_left(this.start_time) this.bar_bear.set_right(this.start_time + w_bear) this.bar_bear.set_top(y2) this.bar_bear.set_bottom(y3) this.bg_str.set_left(this.start_time) this.bg_str.set_right(now) this.bg_str.set_top(y3) this.bg_str.set_bottom(y4) this.bar_str.set_left(this.start_time) this.bar_str.set_right(this.start_time + w_str) this.bar_str.set_top(y3) this.bar_str.set_bottom(y4) These blocks physically place the three metric layers inside the IFVG. Each background row spans the full current width of the active zone. Each colored bar spans only the proportional amount determined by the stored metric. So if bullish participation is high, the bullish bar stretches farther across its row. If strength is low, the strength bar remains shorter. This gives the zone an at a glance internal profile. 15) Updating the Text Labels this.lbl_bull.set_xy(center_x, mid_bull) this.lbl_bull.set_text(str.format("Bull: {0}%", math.round(this.pct_bull * 100))) this.lbl_bear.set_xy(center_x, mid_bear) this.lbl_bear.set_text(str.format("Bear: {0}%", math.round(this.pct_bear * 100))) this.lbl_str.set_xy(center_x, mid_str) this.lbl_str.set_text(str.format("Str: {0}%", math.round(this.pct_strength * 100))) The script also prints the numerical values inside the three rows. Each label is placed at the center of its row and updated with the rounded percentage value. So the user sees both: the visual bar length, and the exact stored percentage. This makes the IFVG readable even when box width is large or when color alone is not enough. 16) IFVG Invalidation Logic bool broken = false if this.is_bull_ifvg and close < this.btm broken := true if not this.is_bull_ifvg and close > this.top broken := true if broken this.active := false this.remove() An active IFVG only remains valid while price stays on the correct side of its structure. For bullish IFVG: if close falls below the bottom, the zone is broken. For bearish IFVG: if close rises above the top, the zone is broken. When that happens, the IFVG is marked inactive and all associated objects are deleted. So the indicator is not just drawing inverse gaps indefinitely. It actively monitors whether they continue to behave as valid reaction zones. 17) Display Limit Management while array.size(active_ifvgs) > show_last_n IFVG d = array.shift(active_ifvgs) d.remove() This final block controls how many IFVGs remain visible. If the number of active inverse gaps exceeds the selected display limit, the oldest one is removed from the front of the array and all of its drawings are deleted. This keeps the chart focused on the most recent inverse gaps and prevents excessive visual clutter.
Indicatore Pine Script®
di UAlgo
2
Auto Fair Value Gap (FVG) Pro [identityKa]Overview The Auto Fair Value Gap (FVG) Pro is an essential Smart Money Concepts (SMC) tool engineered to detect and highlight institutional price imbalances. An FVG occurs when strong momentum creates a gap in price delivery, leaving an inefficiency between buyers and sellers. This script mathematically identifies these 3-bar structures in real-time, plotting them as dynamic zones. It goes a step further by offering automated chart mitigation (cleaning) and plotting the highly sought-after 50% Consequent Encroachment (CE) level. Core Detection & Mitigation Mechanics The algorithm evaluates price action strictly based on a 3-candle sequence: Bullish FVG (Demand Imbalance): Identified when the Low of the 3rd candle is strictly higher than the High of the 1st candle, and the 2nd candle is bullish. This creates an unmitigated gap of buy-side liquidity. Bearish FVG (Supply Imbalance): Identified when the High of the 3rd candle is strictly lower than the Low of the 1st candle, and the 2nd candle is bearish. This creates a sell-side imbalance. Smart Mitigation (Wick vs. Close): The script allows the user to define what constitutes a "filled" gap. In "Wick" mode, the gap is instantly deleted from the chart the moment a subsequent candle's wick sweeps through the zone. In "Close" mode, the gap remains active until a candle's body strictly closes inside or beyond the zone, ensuring the chart stays clean and only relevant institutional targets remain visible. The Consequent Encroachment (50% CE) Institutions frequently target the exact middle of an imbalance. By default, this script draws a dashed line at the exact 50% mathematical equilibrium of every active FVG box. This serves as a precise entry point or target for advanced SMC traders. HUD Dashboard & AI Logic The integrated panel provides an instant read on the imbalance bias and risk state: Dangerous: Displayed whenever the current live price action enters an active FVG zone. This signifies that the gap is actively being filled and high volatility is expected as orders are absorbed. LONG: Triggered when the last detected FVG was Bullish, indicating that recent institutional momentum was upward and unmitigated demand zones lie below as support. SHORT: Triggered when the last detected FVG was Bearish, indicating a dominance in sell-side momentum. How to Use It This tool is exceptionally powerful for Price Action trading, particularly on 15-minute and 1-hour timeframes where intraday institutional gaps frequently occur and are reliably filled. Traders should not blindly buy or sell when an FVG forms. Instead, use the FVG boxes as high-probability reversal zones. When the AI Suggestion reads "Dangerous" (price is inside the gap), monitor the price action on a lower timeframe. Wait for a rejection from the box—specifically near the 50% CE dashed line—before executing a trade in the direction of the macro trend.
Indicatore Pine Script®
di IdentityKa
Filtered Volume FVGsOverview Most Fair Value Gap (FVG) indicators clutter your chart with low-probability gaps. The Filtered Volume FVGs tool solves this by tracking institutional volume. It strictly filters out algorithmic noise, only drawing imbalances that are backed by massive displacement and heavy order flow. Trade the FVGs that institutions are actually defending. How to Read the Flow Bullish FVGs (Green): A bullish displacement gap backed by an extreme volume spike. Acts as a highly defended demand zone. Bearish FVGs (Red): A bearish displacement gap backed by an extreme volume spike. Acts as a highly defended supply zone. Consequent Encroachment (50% CE): Every valid imbalance automatically plots a precise, dashed 50% line—the highest-probability entry setup for ICT and SMC traders. Keep Your Charts Clean A messy chart destroys your trading psychology. This indicator comes built with Granular Chart Control: The Mitigation Engine: Choose exactly what happens when price fills an FVG. You can have the gap permanently delete itself instantly to keep your chart perfect, keep it as a muted historical shadow, or ignore the fill entirely. Dynamic Projections: Stop FVGs from shooting endlessly across your screen. Project them exactly to your current active candle, or set a precise forward offset (e.g., sticking exactly 10 bars into the future space). Scalper Friendly: An integrated timeframe filter ensures these micro-imbalances automatically hide when you zoom out to your macro hourly/daily charts.
Indicatore Pine Script®
di archiedurrant
Fair Value Gap Rejection AlertsOverview The Fair Value Gap (FVG) Finder is a versatile Pine Script™ v6 indicator designed to identify price inefficiencies in the market, commonly known as Fair Value Gaps. These gaps represent areas where price has moved rapidly, leaving behind unbalanced regions that often act as support or resistance levels. This script highlights bullish (upward) and bearish (downward) FVGs as colored boxes on your chart, making it easy to spot potential reversal or continuation zones. Building on standard FVG concepts, this indicator includes advanced features like automatic rejection detection. A rejection occurs when price wicks into the FVG but closes outside it, signaling a potential bounce without filling the gap. Bullish rejections (support bounces) are marked with green upward triangles below the bar, while bearish rejections (resistance bounces) use red downward triangles above the bar. Only the first rejection per FVG is tagged to avoid clutter. The script also supports alerts for these rejections, allowing you to set up notifications in TradingView for timely trading decisions. Gaps are drawn for a user-defined length but can detect rejections and fills beyond the visible box if needed. Key Features FVG Detection: Automatically identifies bullish FVGs (green boxes) when there's an upward price gap exceeding the minimum size, and bearish FVGs (red boxes) for downward gaps. Rejection Logic: Detects wick-based rejections without gap filling. Bullish: Low enters the FVG but close is above. Bearish: High enters but close is below. Alerts: Separate alerts for bullish and bearish rejections, configurable via TradingView's alert system (use "alert() function calls only"). Visual Tags: Triangles mark rejection candles for quick visual confirmation. Customization: Inputs include gap length, minimum gap size (manual or ATR-based), option to show only the latest gap, and delete filled gaps. Style options for colors, label sizes, and more. Filling Mechanism: Optionally deletes boxes once price fully closes into the gap, indicating it's been mitigated. How to Use Add the indicator to your chart via TradingView's Pine Editor. Adjust inputs in the settings panel: Gap Length: Controls how far the box extends (default: 60 bars). Minimum Gap Size: Set manually or auto-adjust with ATR(14) for adaptive filtering. Only Show Latest Gap: Limits display to the most recent FVG. Delete Filled Gaps: Removes boxes after price fills them. Styles: Customize colors and label sizes for better visibility. Monitor the chart for FVG boxes. Watch for triangle shapes indicating rejections—these often signal entry points (e.g., buy on bullish rejection). Set up alerts: In TradingView, create alerts based on the indicator's "Bullish FVG Rejection" or "Bearish FVG Rejection" conditions. Best used on timeframes like 5M-1H for intraday trading, or higher for swing setups. Combine with other tools like volume or trend lines for confirmation. This indicator is inspired by Inner Circle Trader (ICT) and Smart Money Concepts (SMC) but includes original enhancements like per-gap rejection tracking to prevent multiple signals on the same zone. It does not guarantee profits and should be used as part of a broader strategy with proper risk management. No external dependencies or subscriptions required—fully self-contained in Pine Script™ v6.
Indicatore Pine Script®
di Resonant_Trader
Gold Master Hybrid V1 UltraGold Master Hybrid V1 Ultra - The Ultimate Multi-Confluence Trading System Welcome to the Gold Master Hybrid V1 Ultra, a state-of-the-art, all-in-one trading indicator engineered strictly for serious traders. Built upon a robust 8-Point Multi-Confluence Engine, this indicator bridges the gap between traditional momentum oscillators and modern institutional Smart Money Concepts (SMC). Whether you are a day trader looking for precise intraday entries or a swing trader aiming to ride massive trend waves, the Gold Master Hybrid acts as your personal, noise-filtering trading assistant. It doesn't just give you raw buy and sell arrows; it evaluates the entire market spectrum—from volatility and volume to deeply embedded institutional price action—before calculating dynamic, mathematically sound targets. The Core Philosophy The financial markets are filled with noise. Most standard indicators fail because they evaluate only one dimension of the market (like momentum or trend) and end up printing false signals during ranging or choppy environments. The Gold Master V1 Ultra solves this by requiring actual "Confluence". Before any signal is generated, our proprietary engine interrogates the market using eight distinct parameters. Only when the absolute majority of these stars align does the indicator grant a "Confirmed Signal." The Engine - 8 Point Multi-Confluence The core of the indicator assigns a Score (out of 8) to every single candle based on the following criteria. It asks 8 strict questions: 1. Price vs EMA: Is the current Close Price trading above the fast EMA 9? This ensures short term momentum is heavily in our favor. 2. Moving Average Trend Validation: Has the EMA 9 crossed above the EMA 21 (Bullish Cross)? This validates a structural shift in momentum. 3. Macro Trend Filter: Is the current asset trending above the 50-period Simple Moving Average? We never want to trade against the medium-term trend. 4. RSI Strength: Is the Relative Strength Index (RSI 14) residing in the "Healthy Bullish" zone (between 50 and 70)? If it is below 50, it is weak. If it is above 70, it is overbought. The sweet spot is 50 to 70. 5. MACD Confirmation: Is the MACD line actively leading above its Signal line? 6. Stochastic Filter: Is the Stochastic %K line crossing above the %D line while explicitly avoiding the "Overbought" (>80) extreme? 7. Institutional Volume Surge: Is the current volume surging to at least 1.5x the 20-period moving average volume? This detects big institutional involvement that is required to move the market. 8. SMC Trend Matrix: Is the broader Market Structure currently Bullish? Has it printed an upward Break of Structure recently? Signal Grading: - Strong Signal (Score >= 6): An incredibly high-probability setup where the trend, momentum, volume, and structure are perfectly synchronized. Printed as a prominent Triangle marker (Lime for BUY, Red for SELL). - Weak Signal (Score 4 or 5): A moderate continuation or early-warning setup. Printed as smaller triangles (Teal for Buy, Orange for Sell). Advanced Signal Noise Reduction We hate chart clutter. To keep your charts clean and your mind focused, the Gold Master V1 Ultra includes two built-in noise-canceling filters: Filter 1: Consecutive Confirmation Lock A signal condition must physically hold and mathematically close for two consecutive candles. This completely annihilates 1-candle fakeout spikes that ruin most strategies. Filter 2: Strict Cooldown Buffer Once a signal is printed, the indicator enters a strict 5-candle cooldown phase. During this time, it will completely ignore minor fluctuations and will not print duplicate signals of the same type. This ensures massive readability on any timeframe, avoiding the common issue of printing 5 arrows in a row during a ranging period. Integrated Smart Money Concepts (SMC) You no longer need five different indicators on your chart to find institutional levels. The Gold Master handles advanced institutional mapping automatically in the background: - Market Structure Pivot Labels: Automatically draws Higher Highs (HH), Higher Lows (HL), Lower Highs (LH), and Lower Lows (LL) so you never lose track of structure. - BOS & CHoCH: Dynamically plots Break of Structure and Change of Character lines to help you anticipate trend exhaustion or continuation without having to draw trendlines yourself. - Order Blocks (OB): Scans historical price action to plot highly accurate Bullish (Teal) and Bearish (Red) Order Block zones where banks left pending limit orders. - Fair Value Gaps (FVG): Instantly highlights market imbalances (FVG+ and FVG-) so you know exactly where price is likely to be magnetized next to fill liquidity voids. Dynamic Risk Management System (TP & SL) Stop guessing where to take profit or place your stop. The Gold Master Hybrid V1 Ultra utilizes a custom Average True Range (ATR) algorithm to auto-calculate your trade parameters the instant a Strong Signal appears. - Dynamic Stop Loss (SL): Placed at exactly 1.5x ATR away from the wick of the signal candle. It adapts to current market volatility to protect you from getting wicked out during high-impact news. - Take Profit 1 (TP1): Set at 2.0x ATR from your entry. Optimized for safe, high-win-rate scalps. - Take Profit 2 (TP2): Set at 3.5x ATR from your entry. Optimized for capturing the true meat of the trend. The Golden R:R Safety Protocol: Before drawing the SL/TP lines on your chart, the indicator internally calculates the Risk-to-Reward ratio. If the setup doesn't offer at least a 1:1.5 reward-to-risk ratio (based on historical volatility), the indicator completely hides the targets. It is effectively telling you: "This trade is too mathematically risky, skip it." This forces you to be a disciplined trader. The Command Center Dashboard At the corner of your chart (Top-Right by default, completely movable in the settings), sits your real-time Command Center. It aggregates all critical data from the indicator into one beautiful UI panel so you never have to look at subcharts: - Real-time Value Tracking: See the exact status of your EMA, RSI, MACD, and Volume. - Current Signal Score: Instantly know if the current candle is scoring a 3/8, 5/8, or a perfect 8/8 before the signal even fires. - Exact Pricing: Displays the precise price coordinates for TP1, TP2, and your SL so you can immediately copy them into your broker. - R:R tracking: See the exact live Risk-to-Reward ratio of the current setup. - Time Session Matrix: Know instantly if you are trading in the high-volume London, New York, or Asian session, or if you are in the dead hours. User Guide - How to Execute Trades 1. Reading the Macro Trend Background Look closely at the entire background color of your chart. The Gold Master will tint the background Teal if the absolute macro trend is Bullish, and Red if it's Bearish. Rule #1: Only take Strong BUY signals when the background is Teal. Never trade against the macro trend. 2. The Golden Setup (Finding Institutional Confluence) A Strong Signal alone is great. But a Strong Signal that prints exactly inside an auto-drawn Bullish Order Block or inside a Fair Value Gap (FVG+) is a "God-Tier" setup. You want to layer the confluences. If your Buy signal happens right as price touches the demand zone, that is your highest probability entry. 3. Wait for the Candle to Close Because the engine relies on a 2-candle confirmation filter, you must wait for the current candle to mathematically close before considering the signal valid. Do not enter a trade while the candle is still moving. Pro-Tip: Use TradingView's alert system and set the condition to "Once Per Bar Close" to let the indicator notify your phone automatically when a valid, locked-in signal has occurred. 4. Execution and SL/TP Placement When a Buy signal flashes and you take the trade, immediately look at the dashboard (or the lines drawn on the chart) and place your Stop Loss exactly where the red line tells you to. Place your Take Profit at the green TP1 or TP2 line depending on your risk appetite. Do not move your Stop Loss arbitrarily—the ATR calculation placed it there for a mathematical reason. 5. Customizing to Your Specific Asset Every asset breathes differently. Gold (XAUUSD) moves differently than EURUSD, which moves differently than Bitcoin. If you are trading extremely volatile Crypto, go into the indicator settings (click the gear icon next to the indicator name) and increase the "ATR Multiplier (SL)" from 1.5 to 2.0 to give your trades more breathing room. If you are scalping the 1-minute chart, you might want to reduce the TP1 multiplier to 1.5. You can customize every aspect visually from the settings menu without touching the code. 6. Dashboard Movement If the dashboard is blocking your view of current price action, click the gear icon settings for the indicator, go to the "Dashboard" section, and switch the "Dashboard Position" from Top Right to Top Left, Bottom Right, or Bottom Left. Conclusion The Gold Master Hybrid V1 Ultra is not a magic wand, but it is one of the strictest, most logical institutional trading systems available today. By forcing you to wait for 8 points of confluence, keeping your charts clean, calculating ATR-based risk management, and preventing you from taking terrible R:R trades, it physically forces you to trade like an institution rather than an emotional retail trader. (Disclaimer: Trading financial markets involves significant risk. The Gold Master Hybrid V1 Ultra is a highly advanced analytical tool designed to assist your decision-making, but it does not constitute financial advice. Always test strategies on a demo account before risking real capital.)
Indicatore Pine Script®
di Gold_Trading_Expert
14
Prism Orderflow Detector [JOAT]Prism Orderflow Detector Introduction The Prism Orderflow Detector is an open-source institutional liquidity and order flow system that combines Smart Money Concepts (SMC), liquidity pool detection, Fair Value Gap analysis, Order Block identification, and advanced orderflow strength measurement into a unified overlay indicator. This comprehensive system integrates multiple proven institutional trading methodologies to identify high-probability zones where smart money positioning and retail liquidity intersect. The indicator is designed for traders who understand that institutional players move markets by targeting liquidity pools, creating imbalances, and establishing positions through Order Blocks. By synthesizing liquidity detection, Fair Value Gaps, Order Blocks, Breaker Blocks, market structure analysis, and real-time orderflow strength measurement, this tool helps identify structural market inflection points with institutional-grade precision. Why This Integration Exists This indicator combines eight distinct institutional analysis frameworks that complement each other: Liquidity Pool Detection: Identifies equal highs/lows and swing points where retail stops cluster Order Block Analysis: Tracks institutional accumulation and distribution zones Fair Value Gap Identification: Detects price inefficiencies created by rapid institutional moves Breaker Block Recognition: Identifies failed Order Blocks that become new support/resistance Market Structure Mapping: Tracks Break of Structure (BOS) and Change of Character (CHoCH) Liquidity Heatmap Analysis: Visualizes liquidity concentration across price levels Volume Delta Tracking: Measures real-time buying versus selling pressure Orderflow Strength Measurement: Quantifies institutional pressure across multiple factors Each component addresses different aspects of institutional order flow. Liquidity detection reveals where stops are hunted, Order Blocks show where institutions positioned, Fair Value Gaps indicate rapid institutional moves, market structure provides trend context, and orderflow strength quantifies current institutional pressure. Together, they create a comprehensive view of smart money activity and retail liquidity targeting. Core Components Explained 1. Advanced Liquidity Detection System The system identifies multiple types of liquidity pools: Equal Highs (Buy-Side Liquidity): Equal High Threshold = high * (threshold_percentage / 100) Equal High Condition = (high == high ) OR (abs(high - high ) <= threshold AND high > high ) Valid Equal High = Equal High Condition AND high == highest(high, lookback_period) Equal Lows (Sell-Side Liquidity): Equal Low Threshold = low * (threshold_percentage / 100) Equal Low Condition = (low == low ) OR (abs(low - low ) <= threshold AND low < low ) Valid Equal Low = Equal Low Condition AND low == lowest(low, lookback_period) Liquidity Sweeps: - Bullish Sweep: Price breaks below recent lows but closes back above - Bearish Sweep: Price breaks above recent highs but closes back below These sweeps often precede significant moves as institutions trigger retail stops before establishing positions. 2. Order Block Detection Engine Order Blocks represent the last opposite-direction move before a strong impulse: Bullish Order Block: Bullish OB = close < open AND close > open AND close > high AND (high - low ) > (ATR * strength_multiplier) Bearish Order Block: Bearish OB = close > open AND close < open AND close < low AND (high - low ) > (ATR * strength_multiplier) Order Blocks are displayed as gradient boxes with diagonal lines and extend forward to show ongoing relevance. 3. Fair Value Gap Analysis Fair Value Gaps represent price inefficiencies where institutions moved price rapidly: Bullish FVG: Bullish FVG = low > high AND close > open FVG Size = ((low - high ) / close) * 100 Valid Bullish FVG = Bullish FVG AND FVG Size >= minimum_size_percentage Bearish FVG: Bearish FVG = high < low AND close < open FVG Size = ((low - high ) / close) * 100 Valid Bearish FVG = Bearish FVG AND FVG Size >= minimum_size_percentage FVGs are displayed as horizontal lines with gradient fills and often get filled (retested) later. 4. Breaker Block System Breaker Blocks are failed Order Blocks that become new support/resistance: Bullish Breaker: Failed bearish Order Block that price breaks above Bearish Breaker: Failed bullish Order Block that price breaks below These represent significant shifts in market structure and often provide strong reversal zones. 5. Market Structure Analysis Tracks institutional trend changes through structure breaks: Break of Structure (BOS): - Bullish BOS: New higher high with strong momentum - Bearish BOS: New lower low with strong momentum Change of Character (CHoCH): - Bullish CHoCH: Lower low followed by higher high (trend change) - Bearish CHoCH: Higher high followed by lower low (trend change) 6. Advanced Orderflow Features Liquidity Heatmap: Tracks liquidity concentration by counting touches at key levels over specified periods. High-intensity areas (>80% touch count) are highlighted as significant liquidity zones. Volume Delta Analysis: Buy Volume = close > open ? volume : 0 Sell Volume = close < open ? volume : 0 Volume Delta = sma(Buy Volume - Sell Volume, 14) Volume Delta Normalized = (Volume Delta / sma(volume, 14)) * 100 Strong delta (>50) indicates institutional accumulation or distribution. Imbalance Zone Detection: Enhanced Fair Value Gap detection for larger inefficiencies: Bullish Imbalance = low > high AND (low - high ) > (ATR * 0.5) Bearish Imbalance = high < low AND (low - high) > (ATR * 0.5) Premium/Discount Zones: Price Range = highest(high, 50) - lowest(low, 50) Equilibrium = lowest(low, 50) + (Price Range / 2) Premium Zone = close > equilibrium + (Price Range * 0.25) Discount Zone = close < equilibrium - (Price Range * 0.25) 7. Orderflow Strength Meter Real-time quantification of institutional pressure: Orderflow Strength = Order Block Factor + FVG Factor + Sweep Factor + Volume Delta Factor + Structure Factor Components: - Order Block: ±20 points for new OBs - FVG: ±15 points for valid FVGs - Sweeps: ±25 points for liquidity sweeps - Volume Delta: ±30 points (normalized) - Structure: ±20 points for BOS/CHoCH Strength classifications: - Extreme Bull/Bear Pressure: >±60 - Strong Bull/Bear Pressure: >±30 Visual Elements Liquidity Arrows: Directional arrows for equal highs/lows with clean labels Liquidity Sweeps: Arrow lines showing sweep direction with "SWEEP" labels Order Block Boxes: Gradient boxes with diagonal lines and "OB" labels Fair Value Gap Lines: Horizontal lines with gradient fills and "FVG" labels Breaker Diamonds: Diamond markers for failed Order Blocks with "BRK" labels Structure Arrows: CHoCH arrows with directional labels Imbalance Zones: Boxes with crossing diagonal lines and "IMB" labels Liquidity Heatmap: Significant liquidity levels with "LIQ" labels Volume Delta Markers: "Δ+" and "Δ-" labels for extreme volume pressure Orderflow Background: Subtle background coloring for extreme pressure states Dashboard: Comprehensive real-time status of all orderflow components How Components Work Together The integration creates a layered institutional analysis approach: Layer 1 - Liquidity Mapping: Equal highs/lows and swing points reveal where retail stops cluster Layer 2 - Institutional Positioning: Order Blocks show where smart money accumulated/distributed Layer 3 - Price Inefficiencies: Fair Value Gaps indicate rapid institutional moves Layer 4 - Structure Context: BOS/CHoCH provide trend and reversal context Layer 5 - Failed Levels: Breaker Blocks show where previous levels failed Layer 6 - Flow Analysis: Volume delta and heatmaps reveal current institutional pressure Layer 7 - Strength Synthesis: Orderflow strength meter quantifies overall institutional activity Example scenario: Price approaches equal lows (Layer 1) where a bullish Order Block exists (Layer 2), creating a Fair Value Gap on the move up (Layer 3), with bullish CHoCH confirming trend change (Layer 4), strong positive volume delta (Layer 6), and extreme bullish orderflow strength (Layer 7). This confluence suggests high-probability long opportunity. Input Parameters Liquidity Settings: Show Equal Highs/Lows: Toggle liquidity pool display Equal Price Threshold: Percentage tolerance for equal levels (default: 0.1%) Liquidity Lookback: Period for liquidity level detection (default: 50) Order Block Settings: Show Order Blocks: Toggle Order Block display Order Block Strength: ATR multiplier for OB validation (default: 3) Extend Order Blocks: Forward extension bars (default: 20) Fair Value Gap Settings: Show Fair Value Gaps: Toggle FVG display Min FVG Size: Minimum gap size percentage (default: 0.1%) Breaker Block Settings: Show Breaker Blocks: Toggle Breaker display Breaker Lookback: Period for Breaker detection (default: 20) Advanced Features: Show Liquidity Heatmap: Toggle heatmap visualization Show Volume Delta: Toggle volume pressure display Show Imbalance Zones: Toggle imbalance detection Show Premium/Discount Zones: Toggle equilibrium analysis Show Orderflow Strength: Toggle strength background Heatmap Period: Lookback for liquidity concentration (default: 100) How to Use This Indicator Step 1: Identify Market Structure Check for recent BOS or CHoCH to understand current trend context and potential reversal zones. Step 2: Map Liquidity Pools Locate equal highs/lows and swing points where retail stops are likely clustered. Step 3: Find Order Blocks Identify recent Order Blocks where institutions likely positioned for the next move. Step 4: Check for Fair Value Gaps Look for unfilled FVGs that price may return to test, especially near Order Blocks. Step 5: Monitor Liquidity Sweeps Watch for sweep arrows indicating stop hunting - these often precede strong moves in the opposite direction. Step 6: Analyze Volume Delta Confirm institutional flow direction through volume delta analysis - strong delta supports directional bias. Step 7: Review Orderflow Strength Check dashboard for current orderflow strength - extreme readings indicate high institutional activity. Step 8: Wait for Confluence Best setups occur when multiple factors align: liquidity pools + Order Blocks + structure + volume confirmation. Best Practices Use on 15-minute to 4-hour timeframes for optimal institutional detection Focus on confluence zones where multiple SMC concepts align Liquidity sweeps provide excellent risk:reward when they fail to sustain Order Block retests often provide precise entry levels with tight stops Fair Value Gaps act as magnets - price often returns to fill them CHoCH signals are more significant than BOS for trend changes Volume delta confirmation adds conviction to SMC setups Premium/discount zones help time entries - buy discount, sell premium Indicator Limitations Not all liquidity pools get targeted - institutional timing varies Order Blocks can fail if market structure changes significantly Fair Value Gaps may never get filled during strong trending moves Breaker Blocks don't always provide reliable support/resistance Volume delta can be misleading in low-liquidity conditions Orderflow strength is reactive, not predictive of future moves SMC concepts require understanding of institutional behavior Visual elements can clutter chart - adjust display settings as needed Technical Implementation Built with Pine Script v6 using: Advanced liquidity detection with percentage-based thresholds Real-time Order Block calculation with ATR-based validation Dynamic Fair Value Gap identification with size filtering Breaker Block tracking with lookback period management Market structure analysis with BOS/CHoCH detection Volume delta calculation with institutional bias measurement Orderflow strength meter with multi-factor scoring Anti-overlap filtering to prevent visual clutter Comprehensive dashboard with real-time status updates The code is fully open-source and can be modified to suit individual trading styles and preferences. Originality Statement This indicator is original in its comprehensive SMC integration approach. While individual components (Order Blocks, Fair Value Gaps, liquidity detection, volume analysis) are established Smart Money Concepts, this integration is justified because: It synthesizes eight distinct SMC methodologies into a unified system The orderflow strength meter quantifies institutional pressure across multiple factors Advanced liquidity heatmap visualization shows concentration levels not available elsewhere Integrated volume delta analysis provides real-time institutional flow confirmation Premium/discount zone analysis adds equilibrium context to SMC setups Anti-overlap filtering and clean visual design reduce chart clutter while maintaining functionality Each component contributes unique institutional information: liquidity detection reveals stop hunting targets, Order Blocks show positioning zones, Fair Value Gaps indicate rapid moves, market structure provides context, and volume analysis confirms flow. The integration's value lies in presenting these complementary SMC perspectives simultaneously with quantified orderflow strength measurement. Disclaimer This indicator is provided for educational and informational purposes only. It is not financial advice or a recommendation to buy or sell any financial instrument. Trading involves substantial risk of loss and is not suitable for all investors. Smart Money Concepts and institutional analysis are educational frameworks that do not guarantee future price movement. Past performance and backtested results do not guarantee future results. Market conditions change, and SMC patterns that worked historically may not work in the future. Always use proper risk management, including stop losses and position sizing appropriate for your account size and risk tolerance. Never risk more than you can afford to lose. Consider consulting with a qualified financial advisor before making investment decisions. The author is not responsible for any losses incurred from using this indicator. Users assume full responsibility for all trading decisions made using this tool. -Made with passion by officialjackofalltrades
Indicatore Pine Script®
di officialjackofalltrades
Fair Value Gap Signals [UAlgo]Fair Value Gap Signals is a price action indicator that detects bullish and bearish Fair Value Gaps and then tracks how price behaves inside those gaps over time. Instead of only drawing static imbalance boxes, the script treats each FVG as a stateful object with live metrics, lifecycle states, mitigation logic, and optional rejection signals. This makes it useful for traders who want both structural FVG mapping and real time interaction analysis after the gap is created. The indicator runs on price ( overlay=true ) and automatically identifies classic 3 candle FVG formations. Each detected gap is stored in an internal object with its own box, CE midline, metric bars, status, and signal label handling. As price revisits a gap, the script measures how deeply price penetrates the zone, how much volume is accumulated during tests, and how strong the test candles are in terms of directional body expansion (velocity style scoring). A key design goal of this script is practical decision support. It can show: Fresh gaps Testing behavior Filled or invalidated gaps Rejection events (potential reversal signals) Live VVD style metrics (Velocity, Volume, Depth / Safety) inside the FVG It also includes an ATR filter to ignore small gaps, visibility limits to keep charts clean, optional CE midline plotting, and alert conditions for major gap events. 🔹 Features 🔸 1) Automatic Bullish and Bearish FVG Detection The script detects standard 3 candle Fair Value Gaps using simple price displacement logic: Bullish FVG when current low is above high from two bars ago Bearish FVG when current high is below low from two bars ago When a gap is confirmed, it is stored as a custom Gap object and immediately drawn on the chart with its own box, CE midline, and metric containers. 🔸 2) Stateful FVG Lifecycle Tracking Each gap is tracked through multiple statuses instead of being treated as a static box: Fresh Testing Tested Rejected Filled This allows the indicator to model how price interacts with a gap over time and not just where the gap originally formed. 🔸 3) Configurable Mitigation Method (Close or Wick) Users can choose how FVG mitigation is confirmed: Close means invalidation requires a close through the far boundary Wick means a wick touch through the far boundary is enough This is a very useful option because traders often use different mitigation definitions depending on instrument and timeframe. 🔸 4) ATR Based Gap Size Filter An optional ATR filter removes smaller gaps that may be insignificant in volatile conditions. When enabled, the script ignores bullish or bearish FVGs whose size is smaller than the current ATR value (using the chosen ATR length). This helps reduce noise and keeps the display focused on stronger imbalances. 🔸 5) CE Midline (Consequent Encroachment) Support Each FVG can display a dotted midline representing the center of the gap (Consequent Encroachment). This gives traders an additional reference inside the imbalance and is commonly used as a reaction level in ICT style workflows. The CE line can be turned on or off with a dedicated input. 🔸 6) VVD Metrics Inside Each Gap (Velocity, Volume, Depth) One of the strongest features of this script is the live metric visualization inside every active gap. The indicator tracks and displays three bar style metric boxes: Velocity Volume Depth (rendered as a safety style score from penetration depth) These metrics update as price tests the gap and provide a quick visual estimate of test quality, participation, and penetration risk. 🔸 7) Rejection Signal Detection with Context When price enters a gap and then rejects from it with sufficient test volume, the script can print a directional signal label. Bullish gaps can generate Buy or Strong Buy labels and bearish gaps can generate Sell or Strong Sell labels. Signal strength is influenced by the velocity metric, and the tooltip includes extra details such as velocity score, volume score, safety score, and test count. 🔸 8) Test Counting and Multi Test Awareness The indicator keeps track of how many times a gap has been tested. This can help traders distinguish first touch behavior from repeated interactions that may weaken the setup. The test count can also be displayed as text inside the main FVG box when metrics are enabled. 🔸 9) Visibility Control for Cleaner Charts To avoid clutter, the script limits how many active bullish and bearish gaps are visually displayed at once using Max Visible FVGs . It scans from newest to oldest and only shows the most recent valid gaps per side. Older or non visible gaps still exist in logic and continue updating internally, but their visuals are hidden. 🔸 10) Smart Object Cleanup and Retained Signal Labels The script enforces an internal gap limit and removes older gap objects when needed. Gap boxes, CE lines, and metric boxes are deleted during cleanup, while rejection labels are intentionally allowed to remain on the chart for historical context. This gives users a cleaner display while preserving past signal markers. 🔸 11) Alert Conditions for Key FVG Events Built in alert conditions are provided for: New FVG formed FVG testing (price enters a gap) FVG filled (mitigated / invalidated) FVG rejection signal (potential reversal) This makes the script suitable for active monitoring across multiple charts or watchlists. 🔹 Calculations 1) Bullish and Bearish FVG Detection Logic The script uses classic 3 candle gap conditions: bool fvgBull = low > high bool fvgBear = high < low Interpretation: A bullish FVG exists when the current candle low leaves a gap above the high from two bars ago. A bearish FVG exists when the current candle high leaves a gap below the low from two bars ago. When detected, the script creates a Gap object and stores: Top boundary Bottom boundary Direction Origin index Status and metrics Visual objects (main box, metric boxes, midline, label handle) 2) ATR Filter for Minimum Gap Size If the ATR filter is enabled, the script compares gap size with ATR and rejects undersized gaps: float atrVal = ta.atr(atrLength) float gapSizeBull = low - high float gapSizeBear = low - high if fvgBull and gapSizeBull < atrVal fvgBull := false if fvgBear and gapSizeBear < atrVal fvgBear := false This creates a volatility adjusted threshold for FVG relevance. 3) Gap Object Initialization and Visual Construction When a new gap is created, the setup method initializes both state and visuals: Main FVG box CE midline Three metric boxes (Vel, Vol, Dpt) The main box is drawn from the origin index to a small forward projection: g.paramBox := box.new(left = idx, top = top, right = bar_index + 5, bottom = bottom, ...) The CE line is placed at the midpoint: float midY = (top + bottom) / 2 The metric area is split into three horizontal segments inside the gap height so each metric can expand in width over time. 4) Gap Status Model and State Transitions Each gap starts as Fresh . As price interacts with the gap, the script can move it through: Testing when price enters the zone Tested when price leaves after a test Rejected when rejection conditions are met Filled when mitigation occurs This logic is implemented inside the update() method, which runs every bar for each stored gap. 5) Test Detection and First Touch Handling The script avoids counting the forming bar as a test: bool canTest = bar_index > g.index + 1 A gap is considered under test when the current candle range overlaps the gap: bool isInside = canTest and (h >= g.bottom and l <= g.top) When price first enters a fresh gap: if g.status == "Fresh" g.status := "Testing" g.testCount := 1 g.testStartVolume := volume eventCode := 1 This event code is later used for the FVG Testing alert condition. 6) Velocity Metric Calculation Velocity is a bar quality style score calculated during gap tests. It combines body dominance and a directional bonus: float bodyRatio = math.abs(close - open) / barRange Directional bonus: Bullish gap gets bonus if the test candle closes bullish Bearish gap gets bonus if the test candle closes bearish float currentVelocity = math.min(bodyRatio + directionBonus, 1.0) The gap stores the maximum velocity observed across all tests: if currentVelocity > g.maxVelocity g.maxVelocity := currentVelocity Interpretation: Higher velocity suggests stronger directional response while testing the gap. 7) Volume Metric Calculation During tests, the script accumulates test volume: if isInside g.testVolume += volume Later, it compares the accumulated test volume to an expected volume estimate: float expectedVol = volAvg * math.max(1, (bar_index - g.index) / 2) float volScore = math.min(g.testVolume / expectedVol, 1.0) This creates a normalized volume score used in both the metric bar length and the rejection label tooltip. 8) Depth Metric and Safety Score Calculation Depth tracks how far price penetrates into the gap during tests. For bullish gaps: Depth is measured from gap top downward when price dips below the top boundary. For bearish gaps: Depth is measured from gap bottom upward when price rises above the bottom boundary. Examples: if g.isBullish if l < g.top currentDepth := g.top - l else if h > g.bottom currentDepth := h - g.bottom The maximum penetration depth is stored: if currentDepth > g.maxDepth g.maxDepth := currentDepth The displayed metric is a safety style score: float depthRatio = g.maxDepth / gapSize float safetyScore = math.max(0.0, 1.0 - depthRatio) Interpretation: Deeper penetration reduces safety score and may imply weaker rejection quality. 9) Fill / Mitigation Logic (Close or Wick) A gap is marked Filled when price crosses the far boundary in the inverse direction, according to the selected mitigation method: if mitType == "Close" filledInverse := g.isBullish ? (close < g.bottom) : (close > g.top) else filledInverse := g.isBullish ? (l < g.bottom) : (h > g.top) When filled: Status becomes Filled Gap is deactivated Event code becomes 2 Gap visuals are deleted This event code feeds the FVG Filled alert condition. 10) Rejection Signal Logic Rejection is checked only while the gap is active and price is inside the gap. The script also requires enough accumulated test volume: if isInside and g.testVolume > volAvg * 0.5 Rejection condition: Bullish gap rejection if price probes below the gap top and closes back above the gap top Bearish gap rejection if price probes above the gap bottom and closes back below the gap bottom bool rejected = g.isBullish ? (l < g.top and close > g.top) : (h > g.bottom and close < g.bottom) When rejection is confirmed: Gap status becomes Rejected Optional signal label is drawn (Buy, Strong Buy, Sell, Strong Sell) Event code becomes 3 This event code feeds the FVG Rejection Signal alert condition. 11) Signal Strength and Tooltip Metrics When a rejection signal is printed, the script builds a tooltip with normalized scores: Velocity score from maxVelocity Volume score from testVolume versus expectedVol Safety score from gap penetration depth Test count It also upgrades the signal text to Strong Buy or Strong Sell when max velocity exceeds 0.6: if g.maxVelocity > 0.6 icon := g.isBullish ? "Strong Buy" : "Strong Sell" This provides a compact label with deeper context available on hover. 12) Visibility Limiting and Render Hiding The script iterates through gaps from newest to oldest and shows only the most recent active bullish and bearish gaps up to maxVisible per side. Non visible gaps are not deleted, but their visuals are hidden by setting colors and text to na . This is useful for traders who want a focused view of current opportunities without losing older gap state tracking in the background. 13) Metric Bar Rendering Logic Each metric box grows horizontally from the gap origin according to a normalized score: Velocity length from maxVelocity Volume length from volScore Depth / Safety length from safetyScore Example: int len1 = int(math.max(1, maxWidth * velScore)) g.rankBox1.set_right(g.index + len1) If metric display is disabled, the script hides the metric boxes and text while keeping the gap logic active. 14) Array Cleanup and Object Management The script enforces a strict gap storage limit with GAP_LIMIT . When exceeded, the oldest gap is removed and its visuals are deleted: if gaps.size() > GAP_LIMIT gaps.cleanup() The cleanup method deletes: Main gap box CE midline Velocity metric box Volume metric box Depth metric box Rejection info labels are intentionally preserved for historical review. 15) Alert Conditions The script exposes four alert conditions: alertcondition(fvgBull or fvgBear, "New FVG Formed", ...) alertcondition(anyTesting, "FVG Testing", ...) alertcondition(anyFilled, "FVG Filled", ...) alertcondition(anySignal, "FVG Rejection Signal", ...) These alerts are driven by the live event codes returned from each gap's update() call and make the indicator suitable for workflow automation.
Indicatore Pine Script®
di UAlgo
ICT Unicorn Model [UAlgo]ICT Unicorn Model is a chart overlay indicator that automates a practical interpretation of the ICT “Unicorn” concept by combining two core components: a Market Structure Shift style Breaker Block (BB) and a Fair Value Gap (FVG). The script first builds a rolling pivot map using configurable left and right pivot bars, then monitors those pivots for structure breaks that qualify as bullish or bearish breaker blocks. Separately, it detects 3 candle FVG imbalances with a minimum size filter. A Unicorn is confirmed when a newly printed FVG overlaps an active breaker block of the same direction. The output is built for real trading workflows and chart readability. Breaker blocks and FVGs can exist independently, but when they align, the script highlights the overlap region as a Unicorn zone and labels it. All zones extend forward in time and are automatically removed when mitigation or invalidation conditions are met. Optional session filtering is included to restrict detection to a specific trading window for killzone style usage. Educational tool only. Not financial advice. 🔹 Features 🔸 1) Pivot Based Structure Mapping The indicator uses built-in pivot detection to create a reliable swing framework. Both pivot highs and pivot lows are stored as structured objects that keep track of pivot time, bar index, pivot price, pivot direction, and whether that pivot has already been “broken” to prevent repeated processing. This pivot map becomes the backbone of the breaker block engine, allowing the script to reference meaningful swing points instead of reacting to minor noise. 🔸 2) Breaker Block Detection via Market Structure Shift Logic Breaker blocks are created when price breaks through an unbroken pivot in a way that signals a directional shift in structure. Bullish Breaker Block: price closes above an unbroken pivot high, then the script validates the context by locating two pivot lows around that pivot high and requiring a lower low relationship between them (LL style confirmation in this implementation). Once confirmed, a bullish breaker block zone is stored using the pivot candle’s full range. Bearish Breaker Block: price closes below an unbroken pivot low, then the script validates the context by locating two pivot highs around that pivot low and requiring a higher high relationship between them (HH style confirmation in this implementation). Once confirmed, a bearish breaker block zone is stored using the pivot candle’s full range. 🔸 3) Fair Value Gap Detection with Minimum Size Filter The FVG engine detects classic 3 candle price imbalances: Bullish FVG: current low is above high from two bars ago. Bearish FVG: current high is below low from two bars ago. A minimum FVG size filter is applied using raw price points so you can ignore tiny gaps that are usually filled immediately. This makes the script easier to adapt across different markets and timeframes. 🔸 4) Unicorn Confirmation via Directional Overlap A Unicorn is confirmed only when a newly printed FVG overlaps an active breaker block and both are in the same direction. The overlap test is a standard price interval intersection check, and the direction match ensures bullish FVGs only confirm bullish unicorns and bearish FVGs only confirm bearish unicorns. When a Unicorn is confirmed, the script draws a dedicated Unicorn zone covering the combined overlap footprint and prints a simple Bull or Bear label directly on the chart. 🔸 5) Optional Session Filter for Killzone Style Workflows A session filter can restrict detection to a specific time window. If enabled, the script only runs breaker block detection, FVG detection, and Unicorn confirmation while the current bar is inside the selected session. This is useful when you only want signals during higher participation windows. 🔸 6) Automatic Forward Extension, Mitigation, and Cleanup All zones behave as live objects: Breaker block boxes extend forward until invalidation. FVG boxes extend forward until mitigation. Unicorn boxes extend forward until the associated FVG mitigation condition is met. When a zone is mitigated or invalidated, its box and label objects are deleted and removed from internal arrays. This keeps the chart clean and prevents stale zones from accumulating. 🔸 7) Object and Memory Management for Chart Stability The script uses arrays of custom types (Pivot, BreakerBlock, FVG, Unicorn) and enforces internal history limits to reduce clutter and object growth. Older items are shifted out when limits are exceeded, and graphical objects are deleted when no longer valid to maintain stable chart performance. 🔹 Calculations 1) Time Filter (Session Gate) If the time filter is disabled, detection runs on every bar. If enabled, detection only runs when the chart time is inside the selected session. in_session = not use_time_filter or time(timeframe.period, time_session) != 0 Interpretation: If use_time_filter is false, in_session is always true. If use_time_filter is true, time() returns non-zero only while the bar is inside the session. 2) Pivot Detection and Pivot Object Storage Pivot highs and lows are detected using TradingView pivot functions with user-defined left and right bars. Pivots are confirmed after right_bars bars, so the stored pivot time and bar index are offset by right_bars to align the pivot to the originating candle. ph = ta.pivothigh(high, left_bars, right_bars) pl = ta.pivotlow(low, left_bars, right_bars) When a pivot is found: array.unshift(pivots, Pivot.new(time , bar_index , ph, true, false, high , low )) The pivot list is capped to keep the script lightweight: if array.size(pivots) > 20 array.pop(pivots) 3) Bullish Breaker Block Detection A bullish breaker is triggered when price closes above an unbroken pivot high. The script then searches for pivot lows around that pivot high and requires a lower low relationship between them. If this context check passes, the pivot is marked as broken and a bullish breaker block is stored. if p.isHigh and not p.isBroken and close > p.price ... if foundLL p.isBroken := true array.push(active_bbs, BreakerBlock.new(p.time, p.index, p.highPrice, p.lowPrice, true, true, na)) Breaker block zone definition is derived from the pivot candle: Top = pivot candle high Bottom = pivot candle low 4) Bearish Breaker Block Detection A bearish breaker is triggered when price closes below an unbroken pivot low. The script then searches for pivot highs around that pivot low and requires a higher high relationship between them. If this context check passes, the pivot is marked as broken and a bearish breaker block is stored. if not p.isHigh and not p.isBroken and close < p.price ... if foundHH p.isBroken := true array.push(active_bbs, BreakerBlock.new(p.time, p.index, p.highPrice, p.lowPrice, false, true, na)) 5) Fair Value Gap Detection and Sizing Bullish FVG requires current low to be above high . Bearish FVG requires current high to be below low . A minimum size filter is applied in points: bool isBullishFVG = low > high and (low - high ) >= fvg_min_volume bool isBearishFVG = high < low and (low - high) >= fvg_min_volume FVGs are stored with their start anchored to bar_index and time , matching the gap’s originating structure: if isBullishFVG array.push(active_fvgs, FVG.new(time , bar_index , low, high , true, false, na)) if isBearishFVG array.push(active_fvgs, FVG.new(time , bar_index , low , high, false, false, na)) 6) Overlap Rule for Unicorn Confirmation A Unicorn requires overlap plus direction agreement. The overlap is calculated as an interval intersection: method overlaps(BreakerBlock this, FVG fvg) => bool isOverlapping = (fvg.bottom <= this.top) and (fvg.top >= this.bottom) isOverlapping and (this.isBullish == fvg.isBullish) Interpretation: The FVG range must intersect the breaker block range, and both must be bullish or both bearish. 7) Unicorn Zone Construction When a new FVG prints, the script compares it against all active breaker blocks. If an overlap is found, it creates a Unicorn zone and a Bull or Bear label. The Unicorn box boundaries are computed using min and max edges between the BB and FVG: float topEdge = math.min(bb.top, latestFVG.top) float bottomEdge = math.max(bb.bottom, latestFVG.bottom) The Unicorn zone is then drawn and extended forward. 8) Mitigation and Invalidation Logic Breaker Block invalidation Bullish BB invalidates if close goes below BB bottom. Bearish BB invalidates if close goes above BB top. if (bb.isBullish and close < bb.bottom) or (not bb.isBullish and close > bb.top) bb.isActive := false if not na(bb.bbBox) box.delete(bb.bbBox) array.remove(active_bbs, i) FVG mitigation Bullish FVG mitigates if close goes below FVG bottom. Bearish FVG mitigates if close goes above FVG top. if (fvg.isBullish and close < fvg.bottom) or (not fvg.isBullish and close > fvg.top) fvg.isMitigated := true if not na(fvg.fvgBox) box.delete(fvg.fvgBox) array.remove(active_fvgs, i) Unicorn mitigation Unicorn zones are removed when the associated FVG mitigation condition is met: bool isMitigated = (uni.isBullish and close < uni.fvg.bottom) or (not uni.isBullish and close > uni.fvg.top) if isMitigated box.delete(uni.uniBox) label.delete(uni.uniLabel) array.remove(unicorns, i) 9) Forward Extension and Internal Limits Boxes are extended on each bar by updating right = bar_index + 5 to keep them projected slightly forward. Arrays are capped to control history size and object usage: if array.size(active_bbs) > 50 array.shift(active_bbs) if array.size(active_fvgs) > 50 array.shift(active_fvgs) if array.size(unicorns) > 50 array.shift(unicorns)
Indicatore Pine Script®
di UAlgo
1
Fair Value Range Breakout [by Oberlunar]Fair Value Range Breakout by Oberlunar is a community tool built around higher-timeframe structure and HTF imbalance zones. It reconstructs and draws up to three recent candles from a user-selected HTF and optionally displays their High, Low, Open, and Close levels with configurable styles and colours, keeping HTF candles and FVG ranges readable while working on lower timeframes. On each confirmed HTF candle close, the script scans the last three closed HTF candles to detect bullish and bearish Fair Value Gaps using either wicks or candle bodies as the reference. You can filter gaps by a minimum size in ticks, keep only the most recent zones, and extend zones to the right for ongoing interaction tracking. Set the HTF timeframe according to your horizon, such as Daily for swing context or H4-H2 for intraday structure, then enable the HTF candle overlay and choose which OHLC levels to show for each candle. In the HTF FVG settings, pick Wicks for zones that reflect extremes or Bodies for tighter zones, and increase the minimum gap in ticks if you want fewer, cleaner zones. If you use signals, choose “Close inside” for stricter interaction requirements or “Wick touch” for earlier detection, and apply a small exit buffer in ticks when noise is high. A practical workflow is using HTF=2H on a 5m or 15m chart, monitoring price interaction with an HTF FVG zone, and treating the plotted signal as confirmation of a zone exit rather than a standalone entry system. Attribution and derivative work notice is explicit and intentional. The HTF candle architecture component is a derivative work based on HTF Candle Architecture by BigBeluga, and the HTF FVG engine is a derivative work based on “Fair Value Gap MTF” by Oberlunar. The original references are provided above exactly and in the code as required. Enjoy Oberlunar 👁️★
Indicatore Pine Script®
di oberlunar_tr
Dynamic Delta FVG [LuxAlgo]The Dynamic Delta FVG indicator provides a comprehensive analysis of Fair Value Gaps (FVGs) by integrating intra-bar volume delta to visualize the internal buying and selling pressure within price imbalances. 🔶 USAGE The script identifies standard Fair Value Gaps and enhances them by splitting the visual representation into two distinct segments based on volume delta. This allows traders to see exactly where institutional aggressive orders were concentrated during the formation of the gap. Users can utilize this tool to: Identify high-probability FVGs where the volume delta aligns with the gap direction. Determine specific price levels within a gap that acted as the primary "point of control" for buyers or sellers. Monitor real-time sentiment through a dynamic dashboard that aggregates the delta of all active imbalances. Filter out insignificant market noise using ATR and volume-based threshold settings. 🔹 Detailed Buyer/Seller Tags Each active FVG features a dynamic tag on the right edge displaying the specific percentage of buying (B) and selling (S) volume that occurred within that price range. The tag background color shifts based on the dominant force, providing an immediate visual cue of the gap's internal strength. These tags move dynamically as the boxes expand, ensuring they always remain at the current price action edge. 🔹 Filter Overlapping When enabled, the script will automatically remove existing active FVGs that overlap with a new discovery. This ensures only the most recent "current" imbalance is displayed in a specific price zone, preventing visual clutter and focusing on the most relevant institutional levels. 🔹 Mitigation Modes The script supports two mitigation modes to suit different trading styles: **Touch:** A gap is considered mitigated as soon as price enters the range. **Full Fill:** A gap remains active until price has completely traversed the entire range of the imbalance. 🔶 DETAILS The indicator utilizes request.security_lower_tf() to fetch granular volume data from lower timeframes (e.g., 1-second data). This allows for a precise calculation of "Buy Volume" versus "Sell Volume". The split in the FVG box represents the ratio of these volumes. For example, if an FVG has 70% buying volume, the green segment will occupy 70% of the vertical height of the box, while the red segment occupies the remaining 30%. 🔹 Aggregate Sentiment Dashboard The dashboard calculates market strength across all active imbalances rather than just categorizing by gap direction. This means if multiple bullish FVGs contain significant "absorbed" selling volume, the "Seller Strength" metric will accurately reflect this bearish pressure. The Net Sentiment is derived from the net difference between aggregate buyer and seller percentages across all active gaps. 🔶 SETTINGS 🔹 Detection Filters **Min Volume Threshold:** Multiplier for the 20-period average volume. Gaps forming on volume lower than this threshold are ignored. **Min ATR Magnitude:** Sets the minimum required size of the FVG relative to the current ATR. **Mitigation Mode:** Determines whether a touch or a full fill "closes" the gap. **Filter Overlapping:** When enabled, the script deletes older active gaps that overlap with new ones. 🔹 Volume Delta Analysis **Delta Timeframe:** The lower timeframe used for volume calculations. Required for higher precision on 1m charts. 🔹 Visuals **Max Active Gaps:** Limits the number of boxes displayed on the chart (Default: 10). **Buyer/Seller Color:** Customizable colors for the split segments within the FVG. **Show Mitigated Gaps:** When enabled, mitigated gaps remain on the chart with a faded appearance. 🔹 Dashboard **Show Dashboard:** Toggles the real-time sentiment and imbalance summary table. **Position/Size:** Controls the UI placement and scale of the dashboard.
Indicatore Pine Script®
di LuxAlgo
1
First presented ineficiency indicator - 10 sessions📊 Enhanced FVG Indicator with Multi-Session Support Overview The Enhanced FVG (Fair Value Gap) Indicator is a professional-grade tool designed for traders who want to identify and track Fair Value Gaps across multiple trading sessions. This indicator combines advanced FVG detection with smart extension modes, customizable alerts, and automatic instrument calibration. 🎯 What is a Fair Value Gap (FVG)? A Fair Value Gap occurs when there's a price imbalance in the market, creating a "gap" that the price often revisits. This happens when: Bullish FVG: The high of candle 2 bars ago is below the low of the current candle Bearish FVG: The low of candle 2 bars ago is above the high of the current candle FVGs are powerful supply and demand zones that smart money traders use to identify potential reversal or continuation points. ✨ Key Features 🔟 Multiple Session Support 10 Configurable Sessions: Track FVGs across different time windows throughout the day Independent Control: Enable/disable each session individually Custom Session Times: Define your own session hours in any timezone Unique Colors: Each session has its own customizable color scheme Session Labels: Clear identification with customizable labels (S1-S10) 🎨 Modern Label System Text-Only Labels: Clean, modern design without background boxes 9 Position Options: Place labels anywhere on the FVG (Top/Middle/Bottom × Left/Center/Right) Dynamic Information: Shows session name, direction (↑/↓), and size in points Adjustable Size: Choose from Tiny, Small, Normal, Large, or Huge text Custom Colors: Full control over label text color 📏 Smart Extension Modes 1. Follow Current Bar FVGs dynamically extend to follow the current price action Configurable bar offset (-50 to +50) to project ahead or stop before current bar Perfect for real-time trading and keeping your chart clean 2. Until Time Extend FVGs until a specific time of day (HHMM format) Ideal for intraday traders with specific market closure times Example: Stop all FVGs at 1600 (4:00 PM) 3. Until Retest Automatically stop extending when price retests the FVG Three sensitivity levels: Touch: Wick touches the FVG zone Close Inside: Close price enters the FVG Full Body Inside: Entire candle body within the FVG Great for validating FVG fills and trading opportunities 🔔 Advanced Alert System Creation Alerts: Get notified when a new FVG forms Format: "FVG Created: S1 ↑ 79pts @ 70339.00-70418.30" Retest Alerts: One-time alert when price revisits a FVG Format: "FVG Retested: S1 @ 70380.00" Configurable: Enable/disable alerts independently No Spam: Each FVG only triggers one retest alert 🧮 Automatic Point Calculation The indicator automatically detects your instrument type and calculates FVG size correctly: Crypto: Bitcoin, Ethereum, Altcoins (÷10 or ÷100) Forex: All major pairs with correct pip calculation Futures: ES, NQ, YM, CL, GC with proper point values Indices: S&P500, NASDAQ, etc. (1 point = 1 point) Stocks: Penny and dollar stocks (cents calculation) Manual Override: Option to set custom divisor if needed 🎯 Consequent Encroachment (CE) Middle Line: Shows the 50% level of each FVG Customizable Style: Solid, Dashed, or Dotted Adjustable Thickness: 1-5 pixel width Custom Color: Match your chart theme Toggle On/Off: Show or hide as needed 🌍 Timezone Support 4 Major Timezones: America/New_York, UTC, Europe/London, Asia/Tokyo Session-Based: Define sessions in your preferred timezone Global Trading: Works for traders anywhere in the world 📋 Default Configuration Active Sessions (1-5): Session 1: 09:31-09:49 (Market Open) Session 2: 09:50-10:30 (Morning Momentum) Session 3: 10:50-11:10 (Mid-Morning) Session 4: 11:50-12:10 (Pre-Lunch) Session 5: 13:30-14:10 (Post-Lunch) Additional Sessions (6-10): Disabled by default, customize as needed Colors: S1: Blue | S2: Purple | S3: Orange | S4: Yellow | S5: Aqua S6: Green | S7: Red | S8: Fuchsia | S9: Lime | S10: Teal 🚀 How to Use Basic Setup Add the indicator to your chart Select your timezone Enable desired sessions (1-5 active by default) Choose your extension mode Configure alerts if needed Trading Strategies Intraday Scalping: Use "Until Retest" mode with "Touch" sensitivity Enable alerts for quick entries Focus on Sessions 1-2 for high volatility Swing Trading: Use "Until Time" mode to extend FVGs to market close Set retest sensitivity to "Close Inside" for confirmation Track multiple sessions for confluence zones Smart Money Concepts: Combine FVGs with order blocks and liquidity zones Use CE line for partial profit targets Watch for FVG retests at key support/resistance levels ⚙️ Performance Optimizations Efficient Rendering: Max 500 boxes, labels, and lines Historical Limit: Display up to 30 days of FVGs Memory Management: Inactive FVGs automatically marked Real-Time Updates: Dynamic extension without lag 📊 Compatible Instruments ✅ Cryptocurrencies (Bitcoin, Ethereum, Altcoins) ✅ Forex Pairs (All majors and crosses) ✅ Futures Contracts (Indices, Commodities, Metals) ✅ Stock Indices (S&P500, NASDAQ, DOW) ✅ Individual Stocks ✅ Any instrument on TradingView 🎓 Understanding FVG Trading Why FVGs Matter: Represent inefficient price action Act as magnets for price retracement Often mark institutional order flow High probability reversal zones Best Practices: Combine with volume analysis Use higher timeframe FVGs for stronger zones Wait for confirmation before entry Place stops beyond the FVG boundaries 🔧 Customization Options Visual Settings: 10 session colors Border color (transparent by default) CE line color, style, and thickness Label size, color, and position Functional Settings: Extension mode (Follow/Time/Retest) Bar offset (-50 to +50) Retest sensitivity (3 levels) Alert preferences Calculation Settings: Auto-detect point divisor Manual divisor override Maximum days to display 💡 Tips & Tricks Reduce Chart Clutter: Disable sessions you don't trade Session Optimization: Adjust session times to match your market's volatility Confluence Trading: Enable multiple sessions to find overlapping FVGs Mobile Trading: Use alerts to trade on-the-go Backtesting: Increase max days to analyze historical FVG behavior 📝 Version History v1.0 - Initial Release 10 configurable sessions 3 extension modes Automatic point calculation Alert system Modern label design Consequent encroachment support 🤝 Support & Feedback If you find this indicator helpful, please leave a review and share your experience! For questions or feature requests, feel free to comment below. Happy Trading! 🎯📈
Indicatore Pine Script®
di Frenchy_Trades
[CT] Displacement FVG Toolkit Displacement FVG Toolkit is a complete ICT market-structure and execution toolkit designed to help you identify when price is truly repricing, where that repricing left inefficiencies, and how to frame trades with clear context, confirmation, and invalidation. The indicator brings together six institutional-grade concepts into one workflow, Displacement, Fair Value Gaps, Reload Zones, Dealing Range premium and discount, CISD, and Market Structure breaks, so you can stop reacting to random candles and start trading the sequence that professional order flow tends to follow, impulse, imbalance, retrace, and continuation or reversal. The Displacement tool is the engine that decides whether a candle represents meaningful participation or ordinary noise. Displacement is measured by comparing the current candle’s size to the average candle size over a user-defined lookback. You can choose whether the script uses the candle body size or the full high-to-low range for this calculation. When the candle exceeds the average by your selected displacement factor, it is flagged as displacement. Displacement is important because it is the clearest visible clue that the market has moved from balanced auction to aggressive repricing, which is the environment where inefficiencies form and where your best retest trades are born. In the photo, the yellow bars represent the displacement bars, and the indicator prints Buy and Sell markers on those displacement events. The user also has full control to color displacement bars to a color of their choice, so whether you prefer bright yellow, muted gray, or any custom brand color, you can set the exact bullish and bearish displacement bar colors in the inputs. If you do not want bar coloring at all, you can simply turn off displacement bar coloring and use only the markers. The Structure Filter is a powerful addition that prevents displacement from becoming “any big candle.” When enabled, the indicator requires the displacement candle to also break recent structure, meaning price must break above a recent high for bullish displacement or below a recent low for bearish displacement. You can decide whether the structure break is judged by a candle close beyond the prior structure level or by a wick that pierces it. Close-based structure breaks are cleaner and generally reduce false positives, while wick-based breaks are more sensitive and can trigger earlier at the cost of more noise. This filter matters because a large candle in the middle of chop is not the same as a large candle that actually breaks a meaningful swing point, and the indicator gives you a way to enforce that distinction mechanically. The Fair Value Gap tool identifies the most valuable type of imbalance, the three-candle FVG, but it only plots those gaps when they are created by validated displacement. A bullish FVG forms when the current candle’s low is above the high from two candles ago, showing that price skipped a region without fully transacting through it. A bearish FVG forms when the current candle’s high is below the low from two candles ago. These gaps represent unfinished auction, a fast repricing that often leaves behind an inefficiency the market may later revisit to rebalance. You can choose to extend FVGs to the right for a set number of bars so you can see the levels well into the future, or you can keep them confined to the period when they formed. You can also choose whether mitigated FVGs remain visible or are hidden. Mitigation in this script means price has traded back into the gap far enough to invalidate it as an active inefficiency, and when that happens you can either keep it on the chart as historical context or remove it to keep your chart clean. The script also manages object limits by keeping only a user-defined maximum number of FVGs, trimming older ones as needed so the indicator remains stable. Reload Zones are derived directly from the FVGs and are built for execution. Instead of treating the entire gap as the same, the indicator highlights the portion of the imbalance that most often functions as the highest-quality retest area for continuation entries. For bullish FVGs, the Reload Zone is drawn as the upper portion of the gap, and for bearish FVGs it is drawn as the lower portion, which keeps your focus on the retest region that is closest to the direction of repricing and typically provides tighter invalidation. The indicator also includes an optional Invalidation line that marks the far edge of the full FVG, giving you a clean and consistent “line in the sand” for risk management. The intended use is straightforward, you wait for displacement to print and create an FVG, you allow price to retrace into the Reload Zone, and you look for rejection behavior that confirms responsive participation, such as wicks into the zone that close back out, sharp reaction candles, or structure holding in the direction of the displacement. When price accepts inside the zone with multiple closes and slow grind, that’s often a sign the inefficiency is being repaired rather than defended, and the reload entry loses quality. Because reload zones are tied to displacement-generated FVGs, they naturally filter out weaker imbalances and focus you on the kind created during true repricing. The Dealing Range tool provides context by defining a rolling high-to-low range over a user-defined lookback, then splitting that range into premium and discount. The indicator plots DR High, DR Low, and a DR Mid 50% line, and can optionally show PD 62% and PD 38% reference levels inside the range. The fill visually highlights premium above the midpoint and discount below it, which helps you avoid the most common retail mistake, buying in premium and selling in discount without a strong reason. The dealing range is not meant to be a rigid “support and resistance box.” It is meant to help you frame location. In general, long ideas have better location when price is in discount or reclaiming the midpoint with momentum, and short ideas have better location when price is in premium or rejecting the midpoint from below. This becomes especially powerful when combined with your other tools, because a bullish displacement and FVG that forms in discount and then holds the reload zone tends to have much better continuation odds than the same pattern forming at the very top of premium into overhead liquidity. CISD in this indicator is your liquidity-sweep and directional-shift engine, designed to answer a very specific question, did price just take liquidity and then flip orderflow enough to justify a new directional bias. The script first maps swing liquidity using pivot highs and pivot lows over your selected swing period, then tracks when those levels are wicked or mitigated within an expiry window. When a swing high or swing low is taken, the CISD logic watches for the characteristic shift pattern that follows, and when it qualifies it prints a CISD level and establishes a trend state. The “Noise Filter” setting controls how strict the CISD trigger is, higher values reduce noise and produce fewer but more meaningful CISDs, while lower values produce more signals but may include weaker shifts. The indicator also distinguishes between a normal CISD and a stronger CISD that occurs after opposing liquidity was recently wicked within your liquidity lookback, and those stronger events are marked with the directional ▲/▼ symbols so you can immediately recognize when a sweep-and-shift sequence likely occurred instead of a random flip. A key feature you asked for, and that this indicator includes, is that CISD levels can extend in a very controlled way so you can keep trading them without guessing where the level “ends.” The current timeframe CISD lines are drawn at the origin level and then the script can extend only the most recent X CISD lines out past the current bar by a user-defined number of bars, without creating gaps or redrawing incorrectly. This means your newest CISD levels remain visually “live” and tradable into the immediate future, while older CISDs automatically restore to their original endpoints and behave normally. This is important for execution because it keeps the focus on the levels that are most likely to matter now, while still preserving history without clutter. The MTF CISD add-on is what gives you institutional alignment, because it allows a higher timeframe CISD to print onto your execution timeframe. The script computes CISD on the selected HTF using request.security and then draws HTF CISD lines on your chart in real time. You can choose “Confirmed HTF only,” which means the HTF CISD only prints when the higher timeframe candle closes, or you can turn confirmation off to see developing HTF CISDs while the HTF candle is still building. The HTF line style is configurable, and the HTF lines can extend to the right so they behave like real mapped levels. The HTF label is also supported and can be pinned to the right edge with an x-offset, so you always know which timeframe the CISD came from without having to guess. Optional HTF markers can print ▲/▼ on the bar where a new HTF CISD event is detected, which gives you a fast “regime shift” alert that pairs extremely well with your displacement and FVG tools. CISD also includes a candle coloring option so you can visually trade the bias without constantly reading every label. You can keep candle coloring off, turn on an overlay candle layer using plot candle, or use bar color to recolor the native chart candles. The trend that drives candle color can be the current timeframe CISD trend or, if enabled, the HTF CISD trend so your execution timeframe candles reflect the higher timeframe shift. In the combined script, displacement bar coloring still has priority if you leave it enabled, meaning displacement bars will show your displacement color choice first, and the CISD candle coloring will apply where displacement is not overriding. That’s intentional, because displacement bars are “event bars,” while CISD coloring is “state,” and you want to see both without confusion. In terms of how to use CISD with the rest of this indicator, the cleanest institutional workflow is to treat CISD as the directional context and trigger, and use displacement, FVG, and Reload Zones as the execution framework. A fresh HTF CISD is your “macro shift” that tells you which side is likely building control, then you wait for displacement on your execution timeframe that agrees with that bias and produces an FVG. The Reload Zone becomes your location for entry on the retrace, BOS/CHOCH tells you if structure is truly transitioning or continuing, and your invalidation stays anchored to the far edge of the FVG or the CISD level depending on which is tighter and more structurally meaningful. When CISD and displacement disagree, that’s usually a “stand down or reduce size” condition unless you’re explicitly trading a reversal, because it often means the market is still in rotation or repairing imbalance rather than trending cleanly. The BOS and CHOCH tool is the structure confirmation layer. The indicator finds swing highs and swing lows using a pivot-based swing length and then plots structure lines at those pivots. Breaks are detected either by close or by wick, based on your setting. BOS, Break of Structure, signals continuation in the current structural regime, while CHOCH, Change of Character, signals a likely regime change. The indicator uses a simple internal state to differentiate BOS from CHOCH, so you can read structure shifts in real time rather than labeling everything as a generic “break.” You can display structure as lines, labels, or both. The lines extend until price breaks them, then they stop at the break so you can visually see exactly where the market transitioned. This module is especially useful for keeping you out of the trap of assuming a pullback is a reversal. If you see displacement and FVGs but no structural confirmation, you can reduce size or wait. If you see a CHOCH that aligns with a displacement shift and then price returns to a reload zone, you have a much higher quality reversal framework. When you put these tools together, the intended trading workflow becomes a complete narrative. First you identify meaningful movement through displacement, and if you use the structure filter you ensure it is not just a large candle but a break in the auction. That displacement then creates an FVG, the inefficiency left behind by repricing. The Reload Zone marks the most tradable retest area of that inefficiency, and the invalidation line gives you a clear risk boundary. The Dealing Range tells you whether you are taking that setup from a favorable location, discount for longs or premium for shorts. BOS and CHOCH provide the final confirmation layer that tells you whether you are trading continuation or a genuine structural shift. This structure keeps you from chasing breakouts, because it naturally trains you to wait for the pullback into the reload zone and to only participate when price proves acceptance and rejection behavior at the level. This indicator is built to be flexible. You can run it as a clean displacement plus imbalance tool by focusing on displacement, FVGs, and reload zones, or you can turn it into a full context-and-confirmation system by adding dealing range and BOS/CHOCH. If you want a high-signal, low-noise chart, keep the structure break requirement on, use close-based breaks, limit the number of active gaps, and hide mitigated gaps. If you want more sensitivity and earlier signals, use wick-based breaks and allow more gaps to remain visible. The goal is always the same, to help you see when the market is actually repricing, to mark the price areas where that repricing left unfinished business, and to give you a consistent way to execute retests with defined risk and clear structural context.
Indicatore Pine Script®
di ChaosTrader63
2
Institutional Confluence Nexus [Pro]The Problem: Noise vs. Signal In the world of Smart Money Concepts (SMC), traders are often overwhelmed by "chart clutter." Standard indicators blindly highlight every Fair Value Gap (FVG) and Order Block (OB), regardless of whether the market is trending, ranging, or dead. This leads to analysis paralysis and low-probability entries. The Institutional Confluence Nexus was built to solve this. It is not just a structure detector; it is a filtering engine. It uses a multi-factor model to hide low-probability zones and only highlight setups where Structure, Volume, and Momentum align. The "Quantum" Integration This script includes a built-in Quantum Regression Oscillator (QRO) engine running in the background. Unlike standard RSI or MACD which are reactive (lagging), the QRO uses Linear Regression mathematics to project momentum trajectory. By combining institutional structure (Price Action) with quantum momentum (Math), this tool generates specific high-probability signals that only appear when price action and momentum are in perfect agreement. How It Works & Visual Guide This indicator is a complete trading suite. Here is what every symbol and color on your chart represents: 1. The "Nexus" Reversal Signals (Triangles) Symbol : Green Triangle (Up) / Red Triangle (Down) labeled NEXUS. Logic : These appear when price taps a valid Order Block that aligns with the macro trend (200 EMA). Meaning : These are your primary "Trend Join" setups. They indicate that the institutional trend is resuming after a retracement. 2. High-Volume Breakouts (Bar Colors) Symbol : Yellow Candles (Bullish) / Orange Candles (Bearish). Logic : The script detects when a Break of Structure (BOS) occurs with Above-Average Volume. Meaning : A breakout without volume is often a fakeout. These colored bars confirm that institutions are fueling the move. If you see a Yellow bar, it means "Smart Money" is buying the breakout. 3. QRO Confluence Signals (Labels) These are the most advanced signals in the suite, combining Price Action with the internal Oscillator: SNIPER (Blue/Purple) : The strongest reversal signal. Condition : Price taps a Fair Value Gap + The internal QRO is at extreme volatility bands (Oversold/Overbought). PB BUY / PB SELL (Aqua/Orange) : A trend continuation signal. Condition : Price pulls back into a Fair Value Gap + The internal QRO confirms momentum is still healthy (above/below midline). Note : These signals automatically draw a Red Line at the invalidation point (Stop Loss) to help you manage risk immediately. 4. The Confluence Dashboard A non-intrusive Heads-Up Display (HUD) in the corner gives you a snapshot of the market state: Trend : Is price above/below the 200 EMA? Volume : Is current volume anomalous (High) or normal? Structure : Are we breaking up, down, or ranging? Settings & Customization Smart Money Structure: Toggle FVGs and Order Blocks on/off. FVG Extend: Control how far the gap "zones" extend to the right to see them as support/resistance zones. Volume Filter: Enable/Disable the volume requirement (Keep enabled for higher strike rate). Risk Management: Adjust the "Lookback" period for the automatic Stop Loss lines. For Developers (Open Source) I have kept the code open-source to foster learning in the Pine Script community. You can study how: ta.linreg is used to smooth RSI data for the internal QRO engine. box.new and line.new are used for dynamic drawing and extending zones. var variables are used to store historical FVG levels to detect precise crossovers. Disclaimer: This tool is designed to assist with technical analysis and educational purposes. It does not guarantee profits. Always manage your risk and use this in conjunction with your own analysis.
Indicatore Pine Script®
di abgthecoder
Liquidity OS [PyraTime]Trading the lower timeframes (1m-15m) often feels like navigating a minefield. Charts become cluttered with noise, making it nearly impossible to distinguish random price action from genuine institutional intent. Traders frequently suffer from "Analysis Paralysis," struggling to spot clean setups or reacting too slowly to calculate risk accurately in fast-moving markets. The Solution: A Clean Operating SystemPyraTime: Liquidity OS was engineered to solve this specific problem. It is not just a signal tool; it is a complete visual operating system designed to declutter your workspace and enforce discipline. By filtering price action through a strict confluence of Structure, Time, and Momentum, it highlights only high-probability liquidity sweeps while automating the complex mental math of risk management. How to Use This Indicator This tool is designed for Scalpers and Day Traders utilizing liquidity concepts (ICT/SMC). Wait for the Signal: The indicator automatically identifies valid "Unicorn" setups—a confluence of a Liquidity Sweep followed by a displacement (Breaker) and a Fair Value Gap. Verify the Context: Look for the "Elite Glass" Capsule. Cyan Glass: Bullish Setup (Long Opportunity). Pink Glass: Bearish Setup (Short Opportunity). Note: The capsule physically covers messy wicks, forcing your eye to focus solely on the clear path to profit or invalidation. Consult the Dashboard: Glance at the "Monitor" panel (bottom right). It instantly displays the Position Size required to trade the setup based on your pre-defined account risk (e.g., 1%). Execute & Focus: Use the visual TP (Take Profit) and SL (Stop Loss) lines provided by the capsule to set your orders. The system automatically dims old trades ("Smart Spotlight") so only the current opportunity competes for your attention. Key Features 🦁 "Elite Glass" Visual Engine: A proprietary rendering system that displays trade setups as high-transparency, polished capsules. This creates a "Focus-First" environment, reducing chart noise and visual fatigue. 🧠 Smart Spotlight: Automatically manages visual history. The two most recent active zones remain bright, while older setups automatically dim to reduce clutter. Mitigated zones can be set to turn into "Ghosts" or disappear entirely. 🛡️ Risk OS Dashboard: A real-time, persistent monitor that calculates: Dynamic Position Sizing: Tells you exactly how many units/contracts to trade. Session Metrics: Tracks Win Rate, Total R, and Expectancy live. Safety Warnings: Highlights "High Risk" inputs in red if you exceed safety thresholds. ⚡ Logic Filters: Killzones: Restrict signals to specific sessions (e.g., London/NY) with a custom timezone selector. Trend Flow: Filters signals to align with the 4H Trend (EMA 50). Deep Value: Ensures buys occur in Discount and sells in Premium zones. Specifications & Settings Risk OS: Customizable Target R:R, Stop Loss Padding (ATR Multiplier), and Risk Per Trade %. Liquidity Filters: "1m Scalp Mode" (increased sensitivity), Killzone Time/Timezone selector, and Force Reset button. Visual Interface: Fully customizable colors. Toggles for "Show Midlines" (50% of FVG) and "Show Structure Breaks" (BOS lines) to further reduce noise. Performance: Built on Pine Script v6 with null-safe execution and optimized garbage collection for zero-lag performance on all timeframes. Disclaimer: Risk metrics, position sizing, and performance data displayed by this indicator are for informational and educational purposes only. This tool does not execute trades, manage funds, or guarantee future results. Always trade with a regulated broker and verify calculations independently.
Indicatore Pine Script®
di PyraTime
13
Range Indicator Golden Pocket, Liquidity, FairValueGapOverview This indicator is a comprehensive institutional market structure toolkit. It is designed to identify high-probability reversal zones by merging three powerful technical analysis concepts: Fibonacci Golden Pockets (61.8% - 65%), Liquidity Pool Analysis (Swing Failure Patterns), and Fair Value Gaps (FVG). By automating the detection of price inefficiencies and "stop runs," it helps traders navigate complex price action with objective, rule-based confirmation. What the Script Does The script continuously monitors a user-defined lookback period to define a trading range. Within this range, it dynamically plots: Golden Pockets: High-confluence retracement zones (calculated as 0.35 - 0.382 internal range levels). Liquidity Zones: Highlighted regions at the absolute high and low (Top/Bottom 5%) where institutional orders and retail stops are typically concentrated. Swing Failure Patterns (SFP): Real-time detection of liquidity grabs where price breaches a range extreme but fails to close outside, signaling a potential trap. Fair Value Gaps (FVG): Visualizes 3-candle price imbalances, showing areas of aggressive buying or selling that often act as future magnets or support/resistance. 2-Candle Confirmation: A momentum-based filter requiring a candle-close confirmation before a reversal signal is generated. For Whom is it? Smart Money Concepts (SMC) & ICT Students: Traders looking for automated liquidity sweeps and market inefficiencies. Fibonacci & Mean Reversion Traders: Those seeking a clean, professional visualization of the Golden Pocket across multiple timeframes. Systematic Day Traders: Who require strict price-action confirmation (SFP and 2-candle rules) to remove emotional bias from their entries. Functions and Input Options 1. Market Structure & Visuals Lookback Period (Default: 100): Defines the window for calculating the range extremes. Box Offset Right (Default: 50): Extends all zones into the future for better anticipatory trading. Show Price Lines & Labels: Displays the exact price for every zone boundary on the right axis for precise execution. 2. Fair Value Gap (FVG) Settings Show Fair Value Gaps: A toggle to enable/disable the plotting of price imbalances. FVG Extension (Default: 10): Determines how many bars into the future the FVG box remains visible. Custom Colors: Separate color inputs for Bullish (Gap Up) and Bearish (Gap Down) inefficiencies. 3. Professional Alert System The script includes five specific alert conditions: GP Touch: Early warning when price enters a Golden Pocket. 2-Candle Pattern: Confirmed momentum shift within a Golden Pocket. SFP Long/Short: Alerts when a Liquidity Grab (Swing Failure) is confirmed at the range high or low. Transparency and Compliance (Moderator Info) Non-Repainting Logic: All signals (SFP, 2-Candle, and FVG) are calculated and triggered based on confirmed candle closes. Drawings use barstate.islast purely for visual efficiency without altering historical data integrity. Educational Context: The script visualizes well-known market principles (Fibonacci, SFPs, and FVGs) to aid traders in their analysis; it does not provide automated financial advice or "black-box" buy/sell signals. Resource Management: Optimized for Pine Script v5, using efficient array and box handling to ensure smooth performance even on lower timeframes.
Indicatore Pine Script®
di realmacgyver77
21
Smart Gap Concepts [MarkitTick]💡 This indicator automates the identification and classification of price gaps, commonly known as Fair Value Gaps (FVG) or Imbalances, by integrating market structure and volume analysis. Unlike standard gap detectors that simply highlight empty space on a chart, this script applies algorithmic filters to categorize gaps into three distinct phases of market movement: Breakaway, Runaway, and Exhaustion. This helps traders understand the potential context of a move rather than just seeing a support or resistance zone. ● Originality and Utility The primary innovation of this tool is its dynamic classification system. It moves beyond visual detection by checking the "why" behind the gap. By referencing Swing Highs and Swing Lows (Market Structure) alongside Volume efficiency, it determines if a gap represents a breakout, a trend continuation, or a climatic end to a move. Additionally, the script features an automated mitigation tracking system that removes gaps from the chart once price has re-tested the midpoint, ensuring the visual workspace remains clean and relevant to current price action. ● Methodology The script operates on a multi-stage logic engine: • Gap Detection It first identifies the core imbalance where the Low of the current bar does not overlap with the High of the bar two periods prior (for bullish gaps), ensuring the intervening candle represents a strong displacement. • Structural Analysis (Breakaway Gaps) The script monitors Pivot Highs and Lows. If a gap occurs simultaneously with a close beyond a key structural Pivot, it is classified as a "Breakaway Gap." This signals the potential start of a new trend. • Volume and Time Analysis (Exhaustion Gaps) To identify potential reversals, the script looks for "Trend Maturity." If a gap forms after a long duration since the last pivot and is accompanied by a volume spike (defined by the Volume Spike Multiplier), it is labeled as an "Exhaustion Gap." • Continuation (Runaway Gaps) If a gap is valid but meets neither the Breakaway nor Exhaustion criteria, it is considered a "Runaway Gap," typically found in the middle of an established trend. • Dynamic Cleanup The script tracks the midpoint of every active gap. If price creates a lower low (for bullish gaps) or higher high (for bearish gaps) beyond this midpoint, the gap is considered mitigated and is removed from the screen. 📖 How to Use Traders can utilize the color-coded classifications to gauge market intent: Breakaway (Default Blue): Watch these zones for potential trend initiations. These are often high-probability areas for a retest entry after a structure break. Runaway (Default Orange): These indicate strong momentum. They can be used to trail stop-losses or add to winning positions, as price should ideally not close below these gaps in a healthy trend. Exhaustion (Default Red): Be cautious when these appear. They suggest the current move is overextended and a reversal or complex pullback may be imminent. • Exhaustion Gap : A Practical Case Study • Breakaway Gap: A Practical Case Study • Runaway Gap : A Practical Case Study ⚙️ Inputs and Settings Min Gap Size (Points): Filters out insignificant gaps smaller than this threshold. Structure Lookback: Defines the sensitivity of the Pivot detection (Swing High/Low). Volume Avg Length & Multiplier: Determines what qualifies as a "Volume Spike" for exhaustion logic. Trend Maturity: The minimum number of bars required to consider a trend "old" enough for an exhaustion signal. Visual Settings: Custom colors for each gap type and box extension length. ● 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.
Indicatore Pine Script®
di MarkitTick
8