Empiece

Indicadores y estrategias

Breakout Pullback Reload Continue (BPRC) v2Breakout Pullback Reload Continue (BPRC) v2 BPRC v2 is the official continuation of the original BPRC indicator. This version preserves the original breakout logic while improving signal presentation and updating default settings for better consistency across symbols and timeframes. What BPRC Does BPRC identifies structured breakout conditions relative to a dynamic SMA baseline. Signals are generated when: • Price exceeds a volatility-adjusted threshold • Pullback conditions are satisfied • Directional continuation confirms The indicator automatically adapts to different markets using ATR or Z-Score normalization. Key Features • Volatility-adjusted breakout detection • Universal normalization across symbols and timeframes • Configurable minimum volatility floor • Alternating signal enforcement (prevents consecutive same-direction signals) • TradingView Style-tab configurable signal shapes (Arrow, Triangle, Square, Label, etc.) • Built-in Buy and Sell alert conditions Version 2 Improvements • Updated default settings • Style-tab shape selection • Cleaner signal presentation • Continued development and support The original BPRC remains available but is now considered legacy.
Indicador Pine Script®
por dwatersman
LiqLines Pro: Auto & Manual Percentage Grid Description: The LiqLines Pro indicator is a pure structural mapping tool designed to plot dynamic, percentage-based reference levels for any chosen asset. It allows traders to visualize exact mathematical distances from specific top and bottom coordinates, either automatically or via manual selection. Core Mechanics and Calculation Engine: 1. Auto-Detection vs. Manual Level Selection Auto-Detection (Default): By default, the script utilizes the ta.highest() and ta.lowest() functions over a user-defined lookback period (default 500 bars). It identifies the macro structural extremes within this window and projects the percentage grid based on those prices. Manual Level Selection (Anchoring): The core feature of this tool is its integration of Pine Script's input.price() functionality. Users can override the auto-detection engine to set custom origin points. By selecting the indicator's "Settings" or "Reset Inputs", users can use their mouse to click directly on the chart, manually selecting the top or bottom level at any specific wick, breakout candle, or structural gap. Furthermore, users can freely adjust these levels by simply dragging and dropping the anchor lines up or down to new areas on the chart. The entire grid instantly recalculates based on this newly selected price. The script also includes a parity-check safety measure; if the asset is changed and the selected level falls completely out of bounds, it defaults back to auto-detection seamlessly. 2. Modular Percentage Tiers & Customization Instead of relying on standard fixed ticks, the script calculates strict percentage deviations (e.g., +1.00%, +5.00%, -10.00%) from the active top and bottom levels. To maintain a clean chart interface, users have full control to toggle individual percentage lines on or off for both upward and downward directions. This allows traders to fully customize their grid, showing only the specific percentage levels they need for their strategy. By default, only the micro-levels (1% to 10%) are enabled . 3. Dynamic Proximity Alerts The script includes a built-in mathematical proximity detector. It continuously calculates the absolute distance between the current close price and the plotted percentage lines. If the price enters a proximity threshold (strictly defined as a 0.1% distance from the level), the specific line and its corresponding label dynamically change color to Yellow. This provides visual feedback when price interacts with a specific percentage deviation zone. Map your own structural levels and define your own trading zones…
Indicador Pine Script®
por GeronimoScalper
18
Market Dominance + Liquidity Sweep + OBMarket Dominance + Liquidity Sweep + Order Block 📊 🔄 Dominance Shift — Detects when the market structure changes direction. A bullish shift is confirmed when a candle body closes above the last swing high; a bearish shift when it closes below the last swing low. Each shift is marked with a B or S label. 💧 Liquidity Sweep — Identifies liquidity grabs where price spikes beyond a key swing level but fails to hold, signaling a potential reversal. Marked with an ✕ above or below the candle. 📦 Order Block — On every dominance shift, the indicator automatically identifies and draws the last opposing candle before the impulse move (the order block zone). The box extends to the right until price invalidates it by closing beyond its boundary. 🎯 OB Touch — A small triangle appears when price re-tests the order block with a wick spike, without the body entering the zone — a potential entry signal. 📈 Dynamic EMA Filter — An EMA with dynamic coloring filters signals by trend direction. Cyan when price is above, red when below. 🔊 Alerts — Full alert system for every signal type, compatible with TradingView's "Any call to the alert() function."
Indicador Pine Script®
por jake_theboss
4
Institutional Liquidity Flow Engine [JOAT]Institutional Liquidity Flow Engine Introduction The Institutional Liquidity Flow Engine is an advanced open-source volume analysis indicator that combines relative volume monitoring, buyer/seller strength analysis, multi-timeframe alignment detection, and comprehensive flow metrics into a unified institutional-grade tool. This indicator helps traders identify when institutional money is entering or exiting positions by analyzing volume patterns, pressure dynamics, and liquidity conditions across multiple timeframes. Unlike basic volume indicators that simply show volume bars, this engine dissects volume into actionable intelligence: relative volume (RVOL) to identify unusual activity, buyer/seller strength ratios to determine who controls the market, accumulation/distribution trends to track smart money positioning, and multi-timeframe alignment to confirm directional conviction. The indicator is designed for traders who understand that volume precedes price and that institutional footprints can be detected through systematic volume analysis. Why This Indicator Exists This indicator addresses a critical gap in retail trading: the ability to detect institutional activity in real-time. Institutional traders move large positions that create detectable volume signatures. By combining multiple volume analysis methodologies, this indicator reveals: Relative Volume Analysis: Identifies when volume is significantly above or below average, signaling potential institutional activity Buyer/Seller Strength: Quantifies the balance of power between buyers and sellers using volume-weighted calculations Multi-Timeframe Alignment: Confirms whether volume patterns align across 1m, 5m, 15m, 30m, 1h, 2h, 4h, Daily, and Weekly timeframes Flow Metrics: Tracks Money Flow Index (MFI), On-Balance Volume (OBV), Accumulation/Distribution (A/D), and VWAP deviation Liquidity Classification: Categorizes market conditions as Strong Buying, Strong Selling, Balanced, or Thin liquidity Each component provides a different lens on volume behavior. RVOL shows intensity, buyer/seller strength shows direction, MTF alignment shows conviction, flow metrics show institutional positioning, and liquidity classification shows market conditions. Together, they create a comprehensive view of institutional activity. Core Components Explained 1. Relative Volume (RVOL) Analysis RVOL is calculated as current volume divided by the average volume over a specified period (default 20 bars): avgVolume = ta.sma(volume, volumeLength) relativeVolume = avgVolume > 0 ? volume / avgVolume : 1.0 The indicator classifies RVOL into five categories: Extreme (RVOL >= 3.0): Institutional-level activity, potential climax moves High (RVOL >= 1.5): Above-average activity, significant interest Normal (RVOL >= 1.0): Average activity, typical market conditions Low (RVOL >= 0.5): Below-average activity, reduced interest Very Low (RVOL < 0.5): Minimal activity, thin liquidity RVOL thresholds are customizable. Higher RVOL often precedes significant price moves as institutions accumulate or distribute positions. 2. Buyer/Seller Strength Analysis The indicator calculates buyer and seller strength using volume-weighted analysis: buyerVolume = close > open ? volume : 0 sellerVolume = close < open ? volume : 0 buyerStrength = ta.sma(buyerVolume, volumeLength) sellerStrength = ta.sma(sellerVolume, volumeLength) Strength ratios are calculated as percentages: Buyer Ratio: (buyerStrength / totalStrength) * 100 Seller Ratio: (sellerStrength / totalStrength) * 100 When buyer ratio exceeds 70%, bullish pressure dominates. When seller ratio exceeds 70%, bearish pressure dominates. The indicator also integrates ATR-based strength calculations to filter for significant moves and RSI-based strength classification (Strong/Moderate/Weak) for additional context. 3. Multi-Timeframe Alignment The indicator requests RVOL data from three customizable timeframes (default: 5m, 15m, 60m) and calculates alignment: mtf1_bullish = rvol_mtf1 > 1.0 and vol_mtf1 > ta.sma(vol_mtf1, 20) mtfAlignment = (mtf1_bullish ? 1 : 0) + (mtf2_bullish ? 1 : 0) + (mtf3_bullish ? 1 : 0) Alignment status: Strong Aligned (3/3): All timeframes show elevated volume - high conviction Aligned (2/3): Majority timeframes show elevated volume - moderate conviction Weak (1/3): Only one timeframe shows elevated volume - low conviction No Alignment (0/3): No timeframes show elevated volume - no conviction Strong alignment across multiple timeframes indicates institutional participation at scale, as large orders are often split across timeframes to minimize market impact. 4. Flow Metrics Suite Money Flow Index (MFI): Volume-weighted RSI that measures buying and selling pressure: mfi = ta.mfi(close, volumeLength) MFI > 80 indicates overbought conditions with high volume, MFI < 20 indicates oversold conditions with high volume. On-Balance Volume (OBV): Cumulative volume indicator that adds volume on up days and subtracts on down days: obv = ta.cum(math.sign(ta.change(close)) * volume) obvTrend = obv > obvMA ? "Bullish" : obv < obvMA ? "Bearish" : "Neutral" OBV divergences from price often signal reversals. Accumulation/Distribution (A/D): Measures the cumulative flow of money into and out of a security: ad = ta.cum(close == high and close == low or high == low ? 0 : ((2 * close - low - high) / (high - low)) * volume) Rising A/D with rising price confirms uptrend, falling A/D with rising price signals distribution. VWAP Deviation: Measures how far price is from volume-weighted average price: vwap = ta.vwap(close) vwapDeviationPercent = vwap != 0 ? ((close - vwap) / vwap) * 100 : 0 Large deviations often mean-revert as institutions take advantage of inefficient pricing. 5. Volume Speed & Acceleration The indicator calculates volume momentum and acceleration: Volume ROC: Rate of change in volume over 5 periods Volume Acceleration: Change in volume ROC (second derivative) Volume Momentum: Current volume minus 10-period SMA Volume Trend: Increasing or Decreasing based on EMA crossover Accelerating volume often precedes breakouts or breakdowns as institutional orders hit the market. 6. Liquidity Classification System The indicator classifies current liquidity conditions: Strong Buying: High RVOL + positive net pressure (buyer strength > seller strength) Strong Selling: High RVOL + negative net pressure (seller strength > buyer strength) Balanced: Normal RVOL with relatively equal buyer/seller strength Thin: Low RVOL indicating reduced liquidity and potential for slippage Pressure intensity is calculated as: pressureLevel = math.abs(netPressure) / avgVolume pressureIntensity = pressureLevel >= 2.0 ? "Extreme" : pressureLevel >= 1.0 ? "High" : pressureLevel >= 0.5 ? "Moderate" : "Low" Visual Elements RVOL Histogram: Main plot showing relative volume with color-coded intensity (extreme = magenta, high = yellow, normal = green, low = gray) Reference Lines: Horizontal lines at 1.0 (average), 1.5 (high threshold), and 3.0 (extreme threshold) Buyer Pressure Fill: Background fill showing buyer pressure ratio (0-100%) Volume Oscillator: Histogram overlay showing short-term vs long-term volume momentum MFI Line: Thick line overlay showing Money Flow Index with gradient colors Information Table: Comprehensive dashboard displaying all metrics in real-time The table displays 15 metrics: 1. RVOL (current relative volume) 2. Status (Extreme/High/Normal/Low/Very Low) 3. Volume Trend (Increasing/Decreasing) 4. Pressure (Bullish/Bearish/Neutral) 5. Buyer Strength (percentage) 6. Seller Strength (percentage) 7. RSI (current value) 8. Liquidity (Strong Buying/Strong Selling/Balanced/Thin) 9. MTF Alignment (Strong Aligned/Aligned/Weak/No Alignment) 10. A/D Trend (Accumulation/Distribution/Neutral) 11. OBV Trend (Bullish/Bearish/Neutral) 12. MFI (current value) 13. VWAP Deviation (percentage) 14. Volume Momentum (percentage) Input Parameters Volume Analysis: Volume MA Length: Period for volume moving average (default: 20) High RVOL Threshold: Multiplier for high volume detection (default: 1.5) Extreme RVOL Threshold: Multiplier for extreme volume detection (default: 3.0) Multi-Timeframe Settings: Show Multi-Timeframe Analysis: Toggle MTF calculations (default: enabled) Timeframe 1/2/3: Customizable timeframes for alignment analysis (default: 5m, 15m, 60m) Buyer/Seller Strength: ATR Length: Period for ATR calculation (default: 14) RSI Length: Period for RSI calculation (default: 14) RSI Overbought/Oversold: Thresholds for RSI classification (default: 70/30) Display Options: Show Info Table: Toggle information dashboard (default: enabled) Show Volume Histogram: Toggle RVOL histogram (default: enabled) Show VWAP Deviation: Toggle VWAP calculations (default: enabled) Table Position: Choose dashboard location (Top Right/Top Left/Bottom Right/Bottom Left) Colors: All colors are customizable including bullish, bearish, neutral, extreme volume, and high volume colors. How to Use This Indicator Step 1: Monitor RVOL for Unusual Activity Watch for RVOL spikes above 1.5 (high) or 3.0 (extreme). These indicate institutional activity. Extreme RVOL often marks climax moves or major reversals. Step 2: Check Buyer/Seller Strength Identify who controls the market. Buyer ratio > 70% suggests bullish control, seller ratio > 70% suggests bearish control. Look for divergences where price moves one direction but strength moves another. Step 3: Confirm with MTF Alignment Strong alignment across multiple timeframes confirms institutional conviction. Weak or no alignment suggests retail-driven moves that may lack follow-through. Step 4: Analyze Flow Metrics Check MFI, OBV, and A/D for confirmation. Rising OBV with rising price confirms uptrend. Falling A/D with rising price warns of distribution. Step 5: Assess Liquidity Conditions Strong Buying or Strong Selling conditions with high RVOL often precede significant moves. Thin liquidity conditions increase risk of slippage and false moves. Step 6: Look for Volume Acceleration Accelerating volume momentum often precedes breakouts. Decelerating volume momentum often precedes consolidation or reversal. Best Practices Use on liquid instruments (major forex pairs, large-cap stocks, major crypto) for most reliable signals Combine with price action analysis - volume shows intent, price shows result Pay attention to RVOL spikes at key support/resistance levels Look for volume divergences: price making new highs/lows without volume confirmation often fails MTF alignment is most reliable on trending markets, less reliable in choppy conditions Extreme RVOL can signal exhaustion - be cautious of chasing moves with RVOL > 5.0 Use VWAP deviation for mean reversion opportunities when price extends far from VWAP Monitor A/D and OBV for early warning signs of trend changes Indicator Limitations Volume analysis works best on liquid instruments with consistent volume patterns Low-volume instruments or off-market hours can produce unreliable RVOL readings MTF alignment requires sufficient data on all timeframes - may not work on newly listed instruments Volume precedes price but doesn't guarantee direction - high volume can occur on both breakouts and fakeouts Buyer/seller strength calculations assume close > open = buying and close < open = selling, which is a simplification RVOL thresholds may need adjustment for different instruments and market conditions The indicator shows what is happening, not why - fundamental catalysts can override technical volume patterns Extreme RVOL can persist longer than expected during major news events or market dislocations Technical Implementation Built with Pine Script v6 using: Custom RVOL calculations with dynamic thresholds Volume-weighted buyer/seller strength analysis Multi-timeframe security requests with proper lookahead settings Comprehensive flow metrics (MFI, OBV, A/D, VWAP) Volume momentum and acceleration calculations Real-time liquidity classification system Dynamic table with 15 metrics and color-coded cells Thick histogram and line plots for enhanced visibility 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 integration approach. While individual components (RVOL, MFI, OBV, A/D, buyer/seller strength) are established concepts, this indicator is justified because: It synthesizes six distinct volume analysis methodologies into a unified system The multi-timeframe alignment detection provides institutional conviction measurement not available in standard volume indicators Buyer/seller strength calculations combine volume, ATR, and RSI for multi-dimensional pressure analysis The liquidity classification system categorizes market conditions in real-time Volume speed and acceleration metrics provide early warning of momentum shifts The comprehensive dashboard presents 15 metrics simultaneously for holistic volume analysis Integration of flow metrics (MFI, OBV, A/D, VWAP) with RVOL and strength analysis creates layered confirmation Each component contributes unique information: RVOL shows intensity, buyer/seller strength shows direction, MTF alignment shows conviction, flow metrics show positioning, liquidity classification shows conditions, and volume acceleration shows momentum. The indicator's value lies in presenting these complementary perspectives simultaneously with a unified classification system. 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. Volume analysis is a tool for understanding market dynamics, not a crystal ball for predicting future price movement. High volume does not guarantee profitable trades. Past volume patterns do not guarantee future volume patterns. Market conditions change, and strategies that worked historically may not work in the future. The metrics displayed are mathematical calculations based on current market data, not predictions of future price movement. High RVOL, strong buyer/seller ratios, and MTF alignment do not guarantee profitable trades. Users must conduct their own analysis and risk assessment before making trading decisions. 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
Indicador Pine Script®
por officialjackofalltrades
4
ORB Strategy [LuciTech]Credit: Bassic ORB: My Strategy Template: -What it does This is a complete Opening Range Breakout (ORB) strategy that captures the first directional breakout after the New York market open. It defines the opening range using the 9:30–9:45 AM ET window, then monitors for a close above the high or below the low of that range within a 75-minute validity window (until 11:00 AM ET). Only the first confirmed breakout per day is traded — one long signal and one short signal maximum per ORB session. -How it works The script captures the highest high and lowest low formed between 9:30 and 9:45 AM ET each day. A midline (average of the high and low) is also calculated. After the ORB window closes, the strategy watches for the first candle that closes beyond either boundary. If no breakout occurs before 11:00 AM ET, no trade is taken for that day. Entries are sized using a fixed percentage of equity risked per trade, with position size automatically calculated based on the distance to the chosen stop loss. -Stop loss options ATR — stop placed using Average True Range × multiplier Candle — stop placed at the high/low of a specified number of candles back Midline — stop placed at the ORB midpoint (halfway between the ORB high and low) Take profit is set automatically using the configured Risk:Reward ratio. An optional breakeven feature moves the stop to entry price once a specified R multiple is reached. -Relative Volume filter An optional RVOL filter compares the breakout candle's volume against a simple moving average of the prior N bars. If the ratio does not meet the minimum threshold (e.g. 1.5 = 50% above average), the entry is skipped. The arrows still plot on all valid breakouts regardless of the RVOL filter, so you can visually review filtered-out signals. A debug label option is available to display the RVOL ratio on each signal bar for threshold calibration. -Additional filters Time filter — restrict entries to a custom time window Day filter — select which days of the week to allow trades Month filter — select which months to allow trades Position type filter — allow longs only, shorts only, or both -Alerts The strategy supports webhook alerts in three formats: Standard JSON, Telegram JSON, and a concise Telegram format with emoji. Alerts fire on confirmed entry with entry price, stop loss, and take profit included.
Estrategia Pine Script®
por TradesLuci
AboB7rr AboB7rr 🌊🌊 — Multi-School Professional System v6 A comprehensive TradingView indicator that combines 6 analysis schools and 8 independent strategies into one powerful dashboard. ✦ 6 Analysis Schools: Technical (EMA + SuperTrend) | SMC/ICT | RSI+MACD+Volume Ichimoku+VWAP | Harmonic PRZ | Elliott Wave ABC ✦ 8 Independent Strategies (S1–S8): EMA200 Breakout | RSI Divergence | VWAP+Div | Bollinger MACD Cross | AO+StochRSI | Ichimoku Full | ST x3+StochRSI ✦ Smart Dashboard with auto Trade Plan (RR 1:2) Entry | SL | TP1 | TP2 | TP3 — calculated automatically ✦ Real-time alerts for every signal and strategy ✦ ZigZag HH/HL/LH/LL structure labels ✦ Order Blocks | BOS | CHoCH | FVG | Liquidity Zones Created with love for the trading community 🌊 All rights reserved — not for resale.
Indicador Pine Script®
por AboB7r
2
Institutional Liquidity GrabWhat it does This indicator detects institutional liquidity grabs — a Smart Money Concept (SMC) where price briefly sweeps beyond a key swing level to trigger resting stop-loss orders, then reverses sharply. The indicator automates the full detection pipeline: identifying swing highs/lows, clustering them into liquidity pools, detecting sweeps, and confirming the grab with price action. To be used on every time-frame How it works The detection follows a multi-step process: Swing Detection — Swing highs and lows are identified using a configurable lookback window. The algorithm checks whether a bar's high (or low) is the highest (or lowest) within a symmetric window of N bars on each side. Liquidity Pool Formation — When multiple swing points cluster near the same price level (within a configurable ATR-based threshold), they form a liquidity pool. The more "touches" a level has, the stronger the pool. Equal highs/lows are detected and marked accordingly, as these tend to attract institutional stop hunts. Sweep Detection — A sweep occurs when price penetrates beyond a pool level by a minimum distance (ATR-based), but the candle closes back on the other side. This wick-based behavior is characteristic of liquidity grabs where institutions trigger stops and immediately reverse. Confirmation — After a sweep, the indicator waits for a configurable number of bars to confirm that price stays on the "correct" side (below a swept high, above a swept low). Only confirmed grabs produce signals, which significantly reduces false positives compared to detecting sweeps alone. Quality Scoring (1–5 stars) — Each confirmed grab receives a quality score based on: number of touches at the level (more = stronger liquidity), whether it was an equal high/low formation, and whether the sweep candle had a volume spike. This helps traders prioritize the highest-probability setups. What makes this original Most liquidity sweep indicators simply detect when price crosses above a swing high or below a swing low. This indicator goes further by: Clustering swing points into proper liquidity pools with touch counting, rather than treating each swing in isolation Requiring price confirmation after the sweep (not just the sweep itself), which eliminates a large number of false signals Providing a multi-factor quality score so traders can filter for only the best setups Combining volume analysis with structural analysis in a single tool Supporting both pending (unconfirmed) and confirmed grab visualization How to use it Bullish signal (green "GRAB" label below price): Price swept below a low-side liquidity pool and confirmed back above it. This suggests a potential long setup, as sell-side liquidity has been taken. Bearish signal (red "GRAB" label above price): Price swept above a high-side liquidity pool and confirmed back below it. This suggests a potential short setup, as buy-side liquidity has been taken. Pool boxes show where liquidity is currently resting. Red boxes mark high-side pools (potential sell-side targets), green boxes mark low-side pools (potential buy-side targets). Purple boxes indicate that the pool has been swept and confirmed. Use the quality filter to only show grabs with a minimum star rating. Higher-quality grabs (3+ stars) combine multiple touches, equal level formations, and volume spikes. Combine with higher-timeframe structure analysis, order blocks, or fair value gaps for confluence. Alerts The indicator provides three types of alerts (configurable via inputs): Confirmed Grab — Fires when a liquidity grab has been fully confirmed. The alert message includes the price level, quality score, direction (potential long/short), and whether a volume spike was present. Pending Sweep — Fires immediately when a sweep is detected, before confirmation. Useful for early heads-up notifications. New Liquidity Pool — Fires when a new pool with sufficient touches is identified. To set up: Add the indicator → click "Alert" → select "Institutional Liquidity Grab v2" → choose "Any alert() function call". All enabled alert types will fire through a single alert. Limitations and notes This indicator identifies potential reversal setups based on market structure. It does not predict future price movement and is not a standalone trading system. Like all structural indicators, performance varies across markets and timeframes. The default settings are a starting point — adjust them to match your instrument's volatility and your trading style. The confirmation mechanism introduces a small lag by design. This is a deliberate trade-off to reduce false signals. Volume data quality varies by instrument. On instruments with unreliable volume data, consider disabling the volume filter.
Indicador Pine Script®
por xriswart
Ornstein-Uhlenbeck Mean Reversion Probability Bands [UAlgo]Ornstein-Uhlenbeck Mean Reversion Probability Bands is a statistical mean reversion indicator that models price as a mean reverting process and projects dynamic probability style zones around an estimated equilibrium mean. The script uses a rolling lookback of closing prices, fits an Ornstein-Uhlenbeck inspired parameter set from recent behavior, and then converts that estimate into inner and outer deviation bands around the current mean. The indicator runs directly on price ( overlay=true ) and is built to help traders identify when price is stretched away from its estimated equilibrium. Instead of using a fixed moving average and static standard deviation, the script attempts to infer a mean reverting structure from the data itself. It estimates the long term mean, the speed of reversion, and an equilibrium style dispersion measure, then plots two upside and two downside mean reversion zones. When price pushes into the upper or lower band regions, the script calculates a standardized distance from the estimated mean and displays a probability style label with both the percentage score and the current z score. This gives the user a quick visual read of how statistically extended price is relative to the model. A key strength of this script is that it combines: A rolling Ornstein-Uhlenbeck style parameter estimation Adaptive mean reversion zones Probability style stretch labels at band events A clean overlay presentation with visible upper and lower probability regions Important note: The percentage label in this script is a normal distribution coverage style score derived from the current z score. It is best understood as a probabilistic stretch measure, not a literal exact OU first passage probability. 🔹 Features 🔸 1) Ornstein-Uhlenbeck Inspired Mean Reversion Model The script estimates a mean reverting process from recent closing prices instead of relying only on a moving average. It uses a rolling regression style approach on consecutive price observations, then converts those estimates into Ornstein-Uhlenbeck style parameters. This makes the indicator more model driven than a standard band tool. 🔸 2) Rolling Adaptive Mean Line The central mean line is not a fixed average only. It is the estimated equilibrium level ( mu ) of the fitted process. As the rolling price sample changes, the model updates and the mean shifts with changing market structure. The mean line also changes color depending on whether current price is above or below that estimated equilibrium. 🔸 3) Dual Mean Reversion Zones (Inner and Outer) The script builds two sets of reversion bands around the mean: Inner bands using the inner multiplier Outer bands using the outer multiplier This creates a layered framework where the inner zone marks an early stretch area and the outer zone marks a more extreme statistical extension. 🔸 4) Probability Style Stretch Labels When price crosses into the upper or lower band regions, the script calculates a z score based on current distance from the estimated mean and converts it into a percentage style probability score. The label shows: A directional marker The probability style percentage The current z score This gives the user both a visual event trigger and a numeric measure of extension. 🔸 5) Visual Zone Based Design The indicator uses filled upper and lower zones rather than emphasizing the band lines themselves. This creates a cleaner chart display where the mean line stays visible and the stretch regions are highlighted as colored areas above and below it. This makes the indicator easy to read during fast chart scanning. 🔸 6) Configurable Lookback, Time Step, and Band Width Users can customize: The rolling lookback period used for model estimation The time step parameter ( dt ) used in OU conversion The inner band multiplier The outer band multiplier This makes the script adaptable to different timeframes, instruments, and preferred sensitivity levels. 🔸 7) Built In Estimation Safeguards The parameter estimation logic includes fallback protections. If the inferred model parameters are unstable or unrealistic, the script falls back to simpler sample statistics. This helps prevent unusable outputs during difficult market regimes or low quality fits. 🔸 8) Directional Touch Event Logic The script tracks both upper side and lower side band interaction: Upper side events can signal statistically stretched bullish price movement Lower side events can signal statistically stretched bearish price movement Labels are only created on crossing events, which helps reduce repeated prints while price remains outside the band. 🔹 Calculations 1) Rolling Price Queue Management The script stores recent closing prices in an array with a fixed maximum length: price_array.update_queue(close, length_input) The queue update method behaves differently depending on bar state: On a new bar, it pushes the latest value On an updating live bar, it overwrites the last stored value This keeps the rolling sample aligned with the current chart state without duplicating the active bar. 2) Fallback Mean and Dispersion Estimates Before attempting the OU style fit, the script calculates simple fallback values: float fallback_mu = src_array.avg() float fallback_sigma = src_array.stdev() These act as safety defaults if the regression based OU estimate is not reliable. Important note: In this script, fallback_sigma is a simple sample standard deviation of price levels, not return volatility. 3) AR(1) Style Regression on Consecutive Prices The model estimation is built from consecutive price pairs: x = price y = price The script computes: Mean of x Mean of y Covariance between x and y Variance of x Then it estimates: float b = sum_cov / sum_var_x This creates an AR(1) style coefficient that is later translated into OU style parameters. 4) Conversion from AR(1) Form to OU Style Parameters If the estimated b is within a valid range: if b > 0.05 and b < 0.95 the script computes: float a = mean_y - b * mean_x float mu_exact = a / (1.0 - b) float theta_exact = -math.log(b) / dt Interpretation: mu_exact is the estimated long run mean. theta_exact is the implied mean reversion speed. The conversion assumes the AR(1) relation is a discrete time representation of a mean reverting process. 5) Residual Variance and Equilibrium Dispersion The script next measures residual error from the AR(1) fit: float err = y_i - (a + b * x_i) float var_err = sum_err_sq / (n - 1) Then it converts that residual variance into an equilibrium variance estimate: float var_eq = var_err / (1.0 - b * b) Finally: float calc_sigma = math.sqrt(var_eq) Important implementation note: The variable named sigma in this script is used as an equilibrium style standard deviation around the mean, not as the continuous time OU diffusion coefficient from the SDE form. 6) Stability Filter for the Estimated Sigma Even if the AR(1) fit is mathematically valid, the script only accepts the calculated sigma when it is reasonably close to the fallback sample standard deviation: if calc_sigma < fallback_sigma * 1.5 and calc_sigma > fallback_sigma * 0.5 If this test fails, the script keeps the fallback values instead. This helps avoid unstable band widths caused by bad short term fits. 7) Final Parameter Output The estimation method returns: OU_Params.new(theta, mu, sigma_eq) Where: theta is the estimated reversion speed mu is the estimated equilibrium mean sigma_eq is the accepted equilibrium dispersion measure These parameters are then used to build the bands. 8) Band Construction The script computes four band levels around the estimated mean: float up_out = mean_val + (dev_val * mult_outer) float up_in = mean_val + (dev_val * mult_inner) float dn_in = mean_val - (dev_val * mult_inner) float dn_out = mean_val - (dev_val * mult_outer) Interpretation: Inner bands represent a milder deviation from the mean. Outer bands represent a more extreme deviation from the mean. 9) Mean and Zone Visualization The mean line is explicitly plotted: p_mean = plot(ou_bands.mean, color=color_mean, linewidth=2, title="Mean") The inner and outer band plots are also created, but their colors are fully transparent: color color_inner_up = color.new(#ffb74d, 100) color color_outer_up = color.new(#ef5350, 100) ... This means the visible structure mainly comes from the zone fills: fill(p_ui, p_uo, ...) fill(p_li, p_lo, ...) So the user sees clean upper and lower probability zones rather than several bright boundary lines. 10) Touch and Crossing Logic The script first checks whether price is currently inside a stretch area: bool touch_upper = close >= ou_bands.upper_inner bool touch_lower = close <= ou_bands.lower_inner Then it checks for fresh crossings: bool cross_up_in = ta.crossover(close, ou_bands.upper_inner) bool cross_up_out = ta.crossover(close, ou_bands.upper_outer) bool cross_dn_in = ta.crossunder(close, ou_bands.lower_inner) bool cross_dn_out = ta.crossunder(close, ou_bands.lower_outer) Labels are only created when price is touching the region and a fresh crossing occurs. This avoids creating labels on every bar that remains outside the band. 11) Z Score Calculation When an event occurs, the script calculates the standardized distance from the mean: float current_z_score = dev_val != 0 ? math.abs(close - mean_val) / dev_val : 0.0 Interpretation: A z score of 1 means price is one equilibrium standard deviation away from the estimated mean. Higher values indicate a more statistically stretched condition. 12) Probability Style Score Calculation The script converts the z score into a percentage style score using an approximation of the error function: float x = math.abs(z_score) / math.sqrt(2.0) ... float prob = erf_approx * 100.0 Because erf(|z| / sqrt(2)) corresponds to the probability mass within plus or minus that z distance under a normal distribution, the output behaves like a confidence or coverage score. Important note: This is not a direct OU mean reversion probability in the strict stochastic process sense. It is a normal distribution style stretch score based on the current z distance. 13) Upper Event Label Logic When price crosses into the upper band region: if (touch_upper and cross_up_in) or (touch_upper and cross_up_out) the script prints a bearish styled label above the bar: "▼ %" + str.tostring(probability, "#.##") + " (Z:" + str.tostring(current_z_score, "#.##") + ")" This reflects the idea that price is statistically extended above the mean and may be vulnerable to reversion. 14) Lower Event Label Logic When price crosses into the lower band region: if (touch_lower and cross_dn_in) or (touch_lower and cross_dn_out) the script prints a bullish styled label below the bar: "▲ %" + str.tostring(probability, "#.##") + " (Z:" + str.tostring(current_z_score, "#.##") + ")" This reflects the idea that price is statistically extended below the mean and may be vulnerable to reversion. 15) Role of the Time Step Input The dt_input parameter affects the conversion from the AR(1) coefficient into the OU reversion speed: float theta_exact = -math.log(b) / dt A larger dt lowers the inferred theta for the same b . A smaller dt raises the inferred theta for the same b .
Indicador Pine Script®
por UAlgo
Malaysian SnR Levels [UAlgo]Malaysian SnR Levels is a structure based support and resistance overlay that automatically plots three level types on the chart: A-Levels, which act as resistance V-Levels, which act as support Gap Levels, which mark qualifying candle to candle price gaps The script is built for traders who want clean horizontal reference levels that stay active until price decisively crosses through them. Instead of drawing every pivot forever, the indicator manages each level as a stateful object with freshness and activity tracking. A newly created level begins as fresh , becomes unfresh after its first wick interaction, and remains active until price fully crosses through it. Once broken, the level stops extending and is archived on the chart. A major strength of this implementation is its optional multi timeframe workflow. You can leave the timeframe input empty to detect levels on the current chart, or select a higher timeframe to project higher timeframe A, V, and Gap levels onto a lower timeframe execution chart. This makes the script useful for both local chart structure and top down level mapping. The result is a practical support and resistance engine focused on: Pivot based resistance and support Gap based structural levels Fresh versus unfresh state tracking Automatic break detection Optional MTF level projection 🔹 Features 🔸 1) Automatic A-Levels and V-Levels The script detects pivot highs and pivot lows and converts them into horizontal support and resistance levels: A-Levels come from confirmed pivot highs and behave as resistance V-Levels come from confirmed pivot lows and behave as support These are built from pivot calculations on close , not on raw high and low extremes, which gives the levels a close based structural character. 🔸 2) Automatic Gap Levels In addition to pivots, the script detects directional gap style levels when two consecutive candles move in the same direction and the open to prior close gap exceeds a minimum tick distance. Bullish gap logic creates a gap level at the previous close. Bearish gap logic also creates a gap level at the previous close. This gives the indicator a third structural layer beyond classic pivot based support and resistance. 🔸 3) Fresh and Unfresh State Tracking Every new level starts as fresh . A fresh level is considered untouched. Once price interacts with the level by wick, it becomes unfresh : The line style changes to dashed The width becomes thinner The color shifts to the unfresh color theme This helps traders quickly distinguish untouched levels from levels that have already been tested. 🔸 4) Active Until Full Break A level stays active until price crosses through it. Once broken, the level: Stops extending Fixes its endpoint at the break time Keeps the historical line visible Stops updating as an active level This is useful because old levels remain visible for review, while current active levels continue projecting forward. 🔸 5) Multi Timeframe Detection (Optional) The script supports a selectable detection timeframe: Leave it empty to use the current chart timeframe Set it to a higher timeframe to project higher timeframe levels onto the current chart This is especially useful when traders want to execute on a lower timeframe while respecting higher timeframe structure. 🔸 6) Minimum Gap Filter in Ticks Gap levels are filtered by a configurable minimum distance in ticks. This avoids plotting tiny micro gaps and helps keep only more meaningful dislocations. 🔸 7) Duplicate Level Protection Before adding a new level, the script checks whether an active level already exists near the same price. If another active level is within a small tick range, the new one is skipped. This reduces clutter and prevents nearly identical levels from stacking on top of each other. 🔸 8) Separate Visibility Controls Users can independently choose whether to display: A-Levels V-Levels Gap Levels This makes the tool adaptable for different workflows, such as only plotting pivot levels or only monitoring gap structure. 🔸 9) Full Visual Customization The script provides separate color controls for: Fresh A-Levels Unfresh A-Levels Fresh V-Levels Unfresh V-Levels Fresh Gap Levels Unfresh Gap Levels It also allows customization of: Fresh line width Unfresh line width Label size This makes it easy to fit the indicator into different chart styles. 🔸 10) Label Projection to the Right Each active level includes a compact label showing its type: A V Gap The label is automatically pushed several time steps to the right of current price so it stays readable and aligned with the level. 🔸 11) Automatic Level Count Management The script keeps the number of stored levels under control using a maximum active limit. When capacity is exceeded, it tries to remove an older inactive level first. This helps maintain chart cleanliness and stay within TradingView object limits. 🔹 Calculations 1) Pivot Based A-Level and V-Level Detection The script calculates pivots using close, not high or low: float ph = ta.pivothigh(close, pivotLength, pivotLength) float pl = ta.pivotlow(close, pivotLength, pivotLength) Interpretation: A-Level = confirmed close based pivot high V-Level = confirmed close based pivot low Because pivot confirmation requires bars on both sides, the level time is aligned to the true pivot bar using: int ph_t = not na(ph) ? time : na int pl_t = not na(pl) ? time : na 2) Gap Level Detection Logic The script defines bullish and bearish gap conditions using consecutive candles in the same direction plus a minimum gap size measured in ticks. Bullish gap: bool bullishGap = prevBullish and isBullish and (open - close ) >= syminfo.mintick * minGapTicks Bearish gap: bool bearishGap = prevBearish and isBearish and (close - open) >= syminfo.mintick * minGapTicks If either condition is true, the gap level is set at: gap_price := close So the reference price for the gap level is the previous candle’s close. 3) Multi Timeframe Data Selection The script computes levels in a helper function and can either use: Local chart data directly Or higher timeframe data through request.security = request.security(...) If the timeframe input is empty, local values are used. Otherwise, the security values are used: float ph = tf == "" ? loc_ph : sec_ph This gives flexible MTF projection while keeping one consistent logic engine. 4) New Level Event Detection To prevent the same pivot or gap from being added multiple times, the script checks whether the timestamp of the detected event changed: bool new_ph = not na(ph_t) and ph_t != nz(ph_t ) bool new_pl = not na(pl_t) and pl_t != nz(pl_t ) bool new_gap = not na(gap_t) and gap_t != nz(gap_t ) This is an important implementation detail because it avoids a common Pine issue where na != na can propagate as na and block reliable detection. 5) Level Creation and Duplicate Protection Before a new level is added, the script checks existing active levels and rejects duplicates that are too close: if lvl.isActive and math.abs(lvl.price - p) < syminfo.mintick * 10 exists := true This means levels within 10 ticks of an existing active level are treated as duplicates and not added. 6) Level Initialization When a level is created, it starts as: Fresh = true Active = true A line is drawn from the source time and extended to the right: line.new(st, p, st + timeStep, p, xloc=xloc.bar_time, color=c, width=lineWidthFresh, extend=extend.right) A label is also created and placed several time steps to the right: label.new(cur_time + timeStep * 5, p, t, ...) This keeps the label visually separated from the current candle. 7) Fresh to Unfresh Transition Logic A level becomes unfresh when price first touches it by wick while the level is still active. For A-Levels: touchedWick := h >= this.price For V-Levels: touchedWick := l <= this.price For Gap levels: touchedWick := h >= this.price and l <= this.price Once touched: The level remains active isFresh becomes false The line becomes dashed The width changes to the unfresh width The line and label colors switch to the unfresh palette This means a wick touch weakens the level visually, but does not break it. 8) Break / Deactivation Logic A level becomes inactive only when price crosses through it, not merely when it is touched. Cross up condition: bool crossedUp = (o <= this.price and c > this.price) or (c_prev < this.price and c > this.price) Cross down condition: bool crossedDown = (o >= this.price and c < this.price) or (c_prev > this.price and c < this.price) If either is true: this.isActive := false this.lvlLine.set_x2(curTime) this.lvlLine.set_extend(extend.none) this.lvlLabel.set_x(curTime) Interpretation: The level stops projecting and is fixed at the break time. 9) Time Step Handling The script uses the current bar’s time distance to position and extend labels: int timeStep = bar_index > 0 ? time - time : 60000 This is important because the script uses xloc.bar_time , so horizontal positioning is time based rather than bar index based. 10) Maximum Level Management When the array exceeds the user defined maximum, the script tries to remove an inactive level first: if this.size() > maxLevels int removeIdx = 0 for i = 0 to this.size() - 1 SnRLevel lvl = this.get(i) if not lvl.isActive removeIdx := i break Then it deletes that level’s line and label. Important implementation note: If no inactive level is found, removeIdx remains 0, so the oldest level in the array is removed. 11) A-Level, V-Level, and Gap Interpretation In this script: A-Levels are close based pivot highs and function like resistance V-Levels are close based pivot lows and function like support Gap Levels are prior close reference levels from qualifying directional gaps All three share the same lifecycle framework: Fresh Unfresh after wick touch Inactive after a full cross through
Indicador Pine Script®
por UAlgo
Gann Static Step-Cycle (Two-Way) v.3This Pine Script indicator implements a Static Step-Cycle logic based on the Gann Square of 9, specifically designed to track price movements relative to a fixed "Anchor" (like an All-Time High) through 360° cycles. ​Core Mechanism: Static vs. Dynamic ​Unlike most indicators that recalculate with every new swing, this script remains Static. It stays fixed on an Anchor price (e.g., 25,476.40) and only updates when price completes a full 360° vibration. ​Step-by-Step Working ​1. Anchoring and Initialization ​The script starts with a user-defined ath_price (Anchor). ​It calculates the square root of this anchor to find its base vibration: \sqrt{\text{Anchor}}. ​2. The Shift Logic (The "Step" System) ​This is the heart of the indicator. It defines a "trading box" of one full Gann cycle: ​Upper Boundary (+360°): calculated as (\sqrt{\text{Anchor}} + 2)^2. ​Lower Boundary (-360°): calculated as (\sqrt{\text{Anchor}} - 2)^2. ​The Shift: If the price closes above the +360° line or below the -360° line, the indicator "steps" up or down. That boundary becomes the new Anchor, and a fresh set of levels is plotted. ​3. Calculating Gann Degrees (Vibrations) ​Within the active cycle, the script plots specific geometric angles: ​90° (Cardinal): Root increment of \pm 0.5. ​180° (Opposition): Root increment of \pm 1.0. ​270° (1.5 Vibration): Root increment of -1.5. In Gann theory, this is known as the "Trend Exhaustion" or "Death Zone," often coinciding with the end of an Elliott Wave 5. ​Key Features for Trading
Indicador Pine Script®
por OVIMONT
2
KNN Machine Learning Momentum IndicatorKNN Machine Learning Momentum Indicator 🌌 Overview This script implements a K-Nearest Neighbors (KNN) machine learning algorithm combined with Dimensionality Reduction to estimate short-term price momentum. 💬 Feedback & Suggestions If you have any questions regarding the logic, or suggestions for new features, please feel free to leave a comment below! Your feedback helps improve the algorithm for everyone. 🧠 Core Methodology The indicator follows a KNN machine learning pipeline: Feature Engineering: It utilizes a multi-faceted feature set including RSI variations, Price-to-MA deviations, and Oscillatory Momentum. Normalization (Z-Score): All features are standardized into Z-scores, ensuring the KNN distance calculation is not biased by different scales of data. Dimensionality Reduction: To reduce noise and the "curse of dimensionality," the script compresses features into three orthogonal Principal Components (Momentum, Mean Reversion, and Dynamics). KNN Engine: The algorithm searches the historical lookback window for the 'K' most similar patterns using the Minkowski Distance metric and applies a Gaussian Kernel to weight the closest neighbors more heavily. 🚀 Strategic Target: Momentum vs. Absolute Price A key distinction of this algorithm is its target objective. Rather than attempting to predict the exact future price (which is often prone to extreme noise), this model focuses on estimating latent market momentum.By analyzing how current feature sets relate to historical momentum shifts, the KNN engine identifies the underlying "energy" of the market. This approach allows traders to capture the probable direction and strength of the next move, providing a more robust edge in dynamic market regimes than unstable price forecasting. 🛡️ Understanding the "Curse of Dimensionality" A common pitfall in KNN-based trading strategies is the Curse of Dimensionality. This Script addresses this by implementing a Dimensionality Reduction layer. By condensing 9 raw technical features into 3 highly descriptive "Principal Components," we maintain a dense feature space. This ensures that the "nearest neighbors" found by the algorithm are truly statistically significant patterns rather than random noise. 🛠️ Key Features Dynamic Probability Engine: Visualizes the confidence of the model through gradient bar coloring. Trend Filter (EMA): Integrated EMA filter to distinguish between "Trend" signals (stronger) and "Counter-Trend" signals (lighter). Minkowski Distance Tuning: Adjust the p parameter to switch between Manhattan (p=1), Euclidean (p=2), or higher-order distance metrics. Visual Analytics: Clean, institutional-grade UI with clear signal shapes and background highlighting. 📈 How to Trade Bull/Bear Signals: Large shapes with labels indicate signals that align with the major EMA trend (High Conviction).Small Shapes: Indicate potential signals that are counter to the major trend (Use with caution/mean reversion). Bar Colors:Bright Cyan/Red: High confidence prediction. Slate Gray: Low confidence / Neutral market regime. ⚠️ Disclaimer Machine learning models are subject to overfitting and market regime shifts. This indicator is intended to be used as a decision-support tool and should be combined with proper risk management and additional technical analysis.Algorithm: K-Nearest Neighbors (KNN)Distance Metric: Minkowski DistancePreprocessing: Z-Score Normalization + Dimensionality Reduction
Indicador Pine Script®
por SatohK
Candle Body Momentum [UkutaLabs]█ OVERVIEW Candle Body Momentum is a price-action driven indicator that measures directional strength by comparing an Exponential Moving Average (EMA) of the closing price against an EMA of the opening price. Instead of relying on traditional momentum formulas, this tool focuses purely on the candle body — the space between open and close — to reveal which side of the market is in control. When the EMA of the close is above the EMA of the open, buyers are demonstrating sustained pressure. When the EMA of the close is below the EMA of the open, sellers are in control. This simple comparison creates a clean and intuitive view of real directional momentum. █ HOW IT WORKS • Calculates an EMA of the closing price • Calculates an EMA of the opening price • Compares the two values to determine directional bias • Displays the relationship visually for quick interpretation Because candle bodies represent commitment (not just volatility), this method filters out much of the noise created by wicks and intrabar spikes. █ HOW TO USE Trend Confirmation Use Candle Body Momentum to confirm directional bias. If price is trending and the close EMA remains above the open EMA, the trend is supported by sustained buying pressure. Momentum Shifts Crossovers between the two EMAs can signal potential shifts in control before traditional moving average systems react. Pullback Validation During retracements, watch whether body momentum flips temporarily or remains aligned with the broader trend. Market Conditions • Strong separation = strong momentum • Compression = weakening momentum • Frequent crossovers = ranging conditions █ WHY IT’S DIFFERENT Traditional momentum indicators use mathematical derivatives of price. Candle Body Momentum focuses on something simpler and often more meaningful: Who is consistently closing stronger than they opened? This gives traders a clean, price-driven perspective on directional strength without unnecessary complexity.
Indicador Pine Script®
por UkutaLabs
Time ORB [AlgoRich]What does this script do? This indicator is a Time-Based Open Range Breakout (ORB) tool. It monitors price action during a specific user-defined time window, identifies the high and low of that period, and then projects those levels forward as actionable breakout zones. Key Features: Calculation Modes: You can choose to calculate the range based on Wicks (high/low) or Candle Bodies (open/close) depending on your strategy's sensitivity. Extension Limit: To prevent chart clutter, the script includes an "Extension End Time." Once this time is reached, the levels and signals are disabled for the day. Signal Logic: Breakout Alerts: It triggers "Buy" or "Sell" labels when a candle closes outside the established range. Reversal (Second Entry): It has a built-in feature to catch a second breakout if the first move was a "fakeout" and the price reverses to the opposite side. Timezone Management: Includes a UTC offset input to ensure the range aligns perfectly with local market opening hours. How to trade it: Bullish Breakout: Look for long entries when price closes above the Top Line. Bearish Breakout: Look for short entries when price closes below the Bottom Line. Equilibrium: The center line acts as a "fair value" or a target/neutral zone.
Indicador Pine Script®
por AlgoRichPRO
KDE Reversals [UAlgo]KDE Reversals is a statistical reversal oscillator that measures where the current price sits inside its recent distribution using a Kernel Density Estimation based cumulative probability model. Instead of relying on fixed momentum formulas or classic overbought and oversold oscillators, the script builds a rolling sample of recent source values, estimates a smoothed empirical distribution, and converts the current value into a percentile style reading from 0 to 100. The result is a non parametric probability oscillator that answers a simple question: how extreme is the current price relative to the recent sample? Very high readings mean the current value is located near the upper tail of the recent distribution. Very low readings mean it is near the lower tail. The script then uses user defined upper and lower reversal zones to detect potential turning points when the percentile reading exits those extreme regions. The indicator runs in a separate pane ( overlay=false ) and combines: A rolling KDE based empirical CDF oscillator Upper and lower statistical reversal zones Gradient coloring based on percentile position Background highlighting in extreme conditions Optional reversal labels when the percentile exits an extreme zone This makes the tool especially useful for traders who want a more distribution aware approach to reversal detection rather than a fixed oscillator threshold based only on momentum formulas. Educational tool only. Not financial advice. 🔹 Features 🔸 1) KDE Based Empirical CDF Oscillator The core output of the script is a percentile style oscillator built from Kernel Density Estimation. It estimates the cumulative distribution position of the current source value relative to a rolling lookback sample and expresses that result as a percentage from 0 to 100. This gives a probabilistic location measure rather than a raw momentum reading. 🔸 2) Rolling Lookback Distribution Model The script stores a rolling window of recent source values in an internal array. As new bars arrive, the oldest values are removed once the array reaches the configured length. This keeps the distribution adaptive to recent market behavior. Because the model is rolling, the oscillator can adjust as the market shifts from one regime to another. 🔸 3) Non Parametric Reversal Logic Unlike indicators that assume a fixed normal distribution of prices, this script uses a kernel smoothed empirical distribution. That means the reversal zones are based on the actual recent sample shape, not a rigid assumption about how price should be distributed. This can make the signal more responsive to skewed, compressed, or uneven recent market structure. 🔸 4) Custom Upper and Lower Reversal Zones Users can define: An upper reversal zone in percentile terms A lower reversal zone in percentile terms These thresholds determine what counts as statistically stretched relative to the recent sample. This allows the indicator to be tuned for more aggressive or more selective reversal detection. 🔸 5) Reversal Triggers on Exit from Extremes The script does not trigger simply because the oscillator enters an extreme zone. Instead, it triggers when the percentile reading exits the extreme zone: A sell trigger occurs when the oscillator crosses back below the upper threshold A buy trigger occurs when the oscillator crosses back above the lower threshold This design aims to catch reversal confirmation after an extreme condition begins to unwind. 🔸 6) Dynamic Gradient Coloring The percentile line is colored with a gradient between bullish and bearish colors based on its position between the lower and upper thresholds. This makes it easy to identify whether the current reading is leaning toward lower tail, neutral, or upper tail conditions. 🔸 7) Upper and Lower Zone Fills The script includes gradient fills above and below the midline so the oscillator visually emphasizes upper tail and lower tail behavior. This improves readability and helps the user quickly identify whether the current reading is operating in a statistically stretched region. 🔸 8) Extreme Zone Background Highlighting When the oscillator is above the upper threshold or below the lower threshold, the pane background is lightly highlighted. This creates an immediate visual cue that the current reading is inside a high probability reversal watch zone. 🔸 9) Optional Reversal Labels When enabled, the script prints: A downward label after a bearish reversal trigger An upward label after a bullish reversal trigger These labels are intentionally simple and keep the pane clean while still marking the event clearly. 🔸 10) Flexible Source Selection The user can choose which source series to analyze, not only close. This allows the KDE engine to be applied to other price derived series if desired. 🔹 Calculations 1) Rolling Data Queue The script stores recent source values in a custom KDEData object: type KDEData array prices int length Each bar, the new value is pushed into the array: this.prices.push(val) if this.prices.size() > this.length this.prices.shift() This creates a fixed length rolling sample used for the KDE calculation. 2) Interquartile Range (IQR) Calculation To make the bandwidth estimate more robust, the script computes the interquartile range from a sorted copy of the rolling sample: int q1_idx = int(math.floor(n * 0.25)) int q3_idx = int(math.floor(n * 0.75)) sorted.get(q3_idx) - sorted.get(q1_idx) The IQR is later used as part of the spread estimate for kernel bandwidth selection. 3) Robust Spread Estimate The script combines sample standard deviation and IQR based scaling: float stdev = this.prices.stdev() float iqr = this.get_iqr() float spread = math.min(stdev, iqr / 1.34) Interpretation: iqr / 1.34 is a robust estimate of standard deviation under near normal assumptions. Taking the minimum of stdev and iqr / 1.34 helps reduce the effect of extreme outliers when setting the kernel width. If the spread collapses to zero, the script falls back to a very small positive value. 4) KDE Bandwidth Selection The kernel bandwidth is computed using a Silverman style rule: float h = 1.06 * spread * math.pow(n, -0.2) This gives the smoothing width used in the Gaussian kernel estimation. Larger sample size reduces the bandwidth, while larger spread increases it. If the calculated bandwidth is zero, the script forces a small fallback: if h == 0 h := 0.0001 5) Gaussian Error Function Approximation The script defines its own approximation of the error function: erf(float x) => ... This function is then used to build the standard normal cumulative distribution function: norm_cdf(float z) => float sqrt2 = math.sqrt(2) 0.5 * (1.0 + erf(z / sqrt2)) This is the mathematical core that converts standardized distances into cumulative probabilities. 6) KDE Based Empirical CDF Calculation For the current price, the script computes a smoothed empirical CDF by averaging the Gaussian CDF centered on every historical sample point: for i = 0 to n - 1 float xi = this.prices.get(i) float z = (current_price - xi) / h sum_prob += norm_cdf(z) Then: (sum_prob / n) * 100.0 Interpretation: Each historical observation contributes a smooth cumulative probability curve. Averaging them creates a KDE smoothed empirical percentile estimate for the current price. This is more stable than a raw rank percentile because it smooths the distribution instead of using hard cutoffs only. 7) Warm Up Condition The indicator only computes the KDE percentile once the rolling sample is fully populated: if kde.prices.size() == lengthInput cdf_percent := kde.get_kde_cdf(srcInput) Before that, the output remains na , which prevents incomplete early calculations. 8) Oscillator Interpretation The resulting cdf_percent is a percentile style value: Near 0 means the current source is near the lower tail of the recent distribution Near 50 means it is near the middle of the recent distribution Near 100 means it is near the upper tail of the recent distribution This is not a momentum ratio. It is a location measure inside the recent smoothed distribution. 9) Threshold Logic The user defines: float upperThreshold = input.float(95.0, ...) float lowerThreshold = input.float(5.0, ...) These thresholds define statistically extreme regions. For example: A 95 reading means the source is near the top tail of the recent sample A 5 reading means the source is near the bottom tail 10) Reversal Trigger Conditions The script does not trigger on entry into the zone. It triggers when the oscillator exits the zone: Bearish reversal trigger: bool sellTrigger = ta.crossunder(cdf_percent, upperThreshold) Bullish reversal trigger: bool buyTrigger = ta.crossover(cdf_percent, lowerThreshold) Interpretation: A sell trigger means the percentile was above the upper threshold and then moved back below it. A buy trigger means the percentile was below the lower threshold and then moved back above it. This acts more like a reversion confirmation than an early warning. 11) Visual Gradient Line The main oscillator line color is derived from its current percentile position: color cdfColor = color.from_gradient(cdf_percent, lowerThreshold, upperThreshold, col_bull, col_bear) This creates a smooth transition from bullish coloring in the lower reversal area toward bearish coloring in the upper reversal area. 12) Gradient Fill Zones The script fills the area between the percentile line and the hidden midline (50) separately for upper and lower halves: fill(p_cdf, p_mid, top_value=100, bottom_value=50, ...) fill(p_cdf, p_mid, top_value=50, bottom_value=0, ...) This gives the oscillator a cleaner and more informative visual structure than a plain line alone. 13) Background Highlighting When the oscillator is inside an extreme zone, the pane background is lightly shaded: bgcolor(cdf_percent >= upperThreshold ? ... : cdf_percent <= lowerThreshold ? ... : na) This does not trigger a signal by itself. It simply highlights that the reading is currently in a statistically extreme region. 14) Reversal Labels If labels are enabled, the script marks reversal exits with simple directional arrows: For bearish reversal: label.new(bar_index, cdf_percent + 3, "▼", ...) For bullish reversal: label.new(bar_index, cdf_percent - 3, "▲", ...) The labels are plotted near the oscillator value, not on price, which keeps the indicator self contained in its own pane.
Indicador Pine Script®
por UAlgo
Support/Resistance Channel Breakout [SuprAlgo]📌 Support/Resistance Channel Breakout Support/Resistance Channel Breakout automatically draws dynamic support & resistance zones from rolling highs and lows, then signals clean breakout events with labels and ready-to-use alerts. Keep it simple, fast, and visual: adjust the channel thickness, choose the source (High/Low or Close), and set a cooldown between signals to filter noise. Ideal for spotting reliable breakouts in any market and timeframe. 🔶 How it works Resistance = highest(High/Close, period) Support = lowest(Low/Close, period) Surrounds each level with a channel (width set by Channel Multiplier). Bullish breakout → close breaks above the resistance channel after being inside. Bearish breakout → close breaks below the support channel after being inside. Cooldown (N bars) prevents spam signals and reduces noise. ⚙️ Settings Channel Multiplier (1 = 0.0001%) → Controls channel thickness. Higher = wider zones, lower = tighter breakouts. Period Support & Resistance → Number of bars used to detect highs & lows. Higher = more stable zones, lower = more reactive. Source (High/Low or Close) → High/Low = classic S/R, Close = more reactive, based on candle closes. Minimum Bars Between Breakouts → Enforces a cooldown between signals. 🔔 Built-in Alerts Choose from ready-made alerts in Create Alert → Condition: this indicator: 🔔 Breakout Resistance Channel → “Breakout above resistance channel detected.” 🔔 Breakout Support Channel → “Breakout below support channel detected.” 🔔 Breakout Support/Resistance Channel → “Breakout support/resistance channel detected.”
Indicador Pine Script®
por SuprAlgo
Daily MGI - OnlyFlowMGI (Market Generated Information) plots key daily reference levels used by auction market and order flow traders. It draws Prior Day High, Low, Mid, and Close, Overnight High/Low, Opening Range, Initial Balance, RTH VWAP, and Value Area levels — all with price labels extending to the current bar. Each line originates from the bar where the level was actually printed, giving you immediate visual context on where the market established its boundaries. Features: - Full Day (ETH) or RTH Only mode for prior day levels - Configurable Opening Range and Initial Balance durations with ±50/100/150/200% extensions - RTH VWAP and session midline - Approximate prior day Value Area (VAH/VAL/POC) - All levels togglable with customizable colors and label sizes - Lines draw from their origin point to the current bar Built as a lightweight alternative to paid order flow packages. Designed for futures (ES, NQ, etc.) but works on any instrument with defined RTH/ETH sessions. Adjust the RTH and ETH session times in settings to match your market.
Indicador Pine Script®
por ofderk
Smart Money Gold Map [XAUUSD Kill Zones + Liquidity Sweeps]An all-in-one session mapping and market structure overlay designed specifically for XAUUSD. Combines kill zone timing, Asian range liquidity sweeps, and dynamic psychological levels into a single clean tool. No repainting. The green and red diamonds mark Asian range liquidity sweeps, not direct buy/sell signals. They highlight where smart money grabbed liquidity so you can build your own trade thesis around them. 🔶 SESSION KILL ZONES Highlights the two most important windows for gold trading: • London Kill Zone (07:00-10:00 GMT) where the majority of gold's daily range gets established • NY AM Kill Zone (12:00-15:00 GMT) for US macro data and continuation/reversal of London Blue and purple backgrounds with "LDN" and "NY" labels at each session open so you always know where you are in the trading day. 🔶 ASIAN RANGE + LIQUIDITY SWEEPS The Asian session (22:00-06:00 GMT) defines the overnight consolidation range that London and NY will target. The indicator: • Draws the Asian range as a box on your chart • Detects when price sweeps the Asian high/low and reverses back inside • Marks each sweep with a diamond (green = low swept, red = high swept) • Fires once per sweep per day to keep the chart clean Gold consistently respects this pattern because institutional stops cluster at Asian session extremes. If you trade ICT or SMC concepts, this is the setup you're already looking for. 🔶 PSYCHOLOGICAL LEVELS At all-time highs, there is no historical resistance above current price. Round numbers become the primary S/R framework. The indicator draws: • $100 major levels as solid gold lines ($5000, $5100, $5200...) • $50 minor levels as dashed lines ($5050, $5150, $5250...) • Optional $25 midpoints as dotted lines for precision scalping Levels update dynamically around current price with dollar value labels. 🔶 REAL-TIME DASHBOARD Compact dashboard showing: • Active session with color coding • VWAP premium/discount • RSI with extreme highlighting • ATR for volatility context • Asian range width and sweep status • London and NY session ranges • Nearest psych resistance + support with distance • Zone position (near support, mid-range, near resistance) • Volatility context: TIGHT = compressed Asian range, often followed by explosive moves during kill zones 🔶 6 BUILT-IN ALERTS • Asian low swept (watch for long setup) • Asian high swept (watch for short setup) • London Kill Zone open • NY Kill Zone open • Price hit major psychological resistance • Price hit major psychological support 🔶 HOW TO USE Apply to XAUUSD on 15m, 30m, or 1H for the best session visibility. When London KZ opens, check the dashboard. If the Asian low got swept and price is sitting at VWAP discount near a $100 psych level, you have confluence for a long setup. The indicator surfaces all of this without needing to draw a single line manually. During NY, watch for continuation of London's direction or reversal at the next psych level. Session range lines show exactly where London established its high and low. When the volatility read shows "TIGHT", pay extra attention. Compressed Asian ranges tend to precede big directional moves. 🔶 SETTINGS Fully adjustable: • Session times (set to your broker's timezone) • Psych level steps ($100, $50, $25) • Number of levels displayed • All colors and visual toggles
Indicador Pine Script®
por DefinedEdge
Planetary Fan Array [BlueprintResearch]█ Planetary Fan Array automatically detects ZigZag price pivots and draws Gann-style fan angles whose slope is driven by real-time planetary longitude — not fixed geometric ratios. Each time price reverses direction, the indicator anchors a new set of fan lines at the pivot and traces their path using accumulated planetary motion, creating a dynamic framework where the angles evolve with celestial mechanics. Designed as the pivot-based companion to Price and Longitude Angles , which draws fan lines from a single user-selected anchor point. Use both together: Price and Longitude Angles for static analysis from a key high or low, and Planetary Fan Array for automatic swing-by-swing tracking as new pivots form. Powered by the open-source Blueprint Ephemeris library (VSOP87D + ELP2000-82 + Meeus) — all planetary positions computed directly in Pine Script, no external data required. Validated against NASA's DE440 ephemeris: all bodies under 0.1° RMS (Sun 0.004°, planets 0.005°–0.017°, Moon 0.062°, Pluto 0.059°). █ HOW IT WORKS The indicator combines two independent systems: 1. Pivot Detection A ZigZag algorithm (via DevLucem/ZigLib) identifies significant highs and lows on price. The "Pivot Sensitivity" control sets the minimum bars between pivots — higher values produce fewer, more significant swings. 2. Longitude-Driven Fan Angles At each pivot, the indicator begins accumulating planetary longitude (degrees traveled since the pivot). This accumulation is converted to price movement using a configurable $/° (price per degree) ratio, producing diagonal fan lines whose slope reflects actual planetary speed — including natural curves during retrograde motion. Three fan lines are drawn per swing: • 1x1 — 1° of longitude = 1 unit of price (on by default, toggleable) • Ratio 2 — User-selectable (1x8 through 8x1) • Ratio 3 — User-selectable (1x8 through 8x1) Fan direction follows the swing: upward swings project fan lines upward from the pivot low, downward swings project downward from the pivot high. Mirror Mode inverts this for resistance/support analysis. █ FEATURES Automatic Swing Detection • ZigZag-based pivot identification with configurable sensitivity, deviation, and backstep • New fan angles automatically generated at each confirmed pivot • Up to 30 historical swings preserved with full polyline rendering (Max History: 5–30, default 15) Three Calculation Modes • Single — Track one planet's longitude accumulation • Average — Midpoint of two planets' accumulated longitude • Synodic — Angular separation between two planets (synodic cycle phase) 12 Celestial Bodies • ☉ Sun · ☽ Moon · ☿ Mercury · ♀ Venus · 🜨 Earth · ♂ Mars · ♃ Jupiter · ♄ Saturn · ⛢ Uranus · ♆ Neptune · ♇ Pluto • 🜨 ERA (Earth Rotation Angle) — sidereal time, requires ≤15-minute timeframe Swing Extensions • Extend the last 1–3 completed swings to the current bar so prior angles remain visible when a new pivot forms • Default extends 1 prior swing — you never lose the trend you were tracking Future Projections • Project fan lines up to 250 bars into the future from the current bar • Projections use bar-index positioning for clean rendering on non-continuous markets (stocks, futures, indexes) • Projected lines maintain the same color and style as historical lines — no visual break at the transition Curved Polylines • Fan lines are rendered as polylines that follow the actual longitude path bar by bar • Natural curvature during retrograde periods — no straight-line approximation • Optional smooth curves for non-continuous markets Visual System • Planet-specific HSV color palette consistent with Price and Longitude Angles • Optional color overrides for the 1x1 line and ratio lines independently • Configurable line width (1–5 pixels) applied to all fan lines • Per-ratio line styles (Solid, Dotted, Dashed) and transparency controls • Green ▲ and red ▼ pivot markers at detected lows and highs — these are the swing points the indicator builds its fan angles from • Optional ZigZag connecting line with configurable width • Info panel showing $/°, mode, planet, degrees traveled, swing direction, and swing count (X/Y where Y is your Max History setting) • Warning indicator when both user ratios are set to the same value Alerts • 1x1 Cross — fires when price crosses the 1x1 fan line • Ratio 2 Cross — fires when price crosses the second ratio fan line • Ratio 3 Cross — fires when price crosses the third ratio fan line • New Pivot — fires when a new pivot is detected and swing direction changes █ HOW TO USE 1. Add the indicator to your chart. You'll immediately see green ▲ and red ▼ triangle markers on the chart — these mark every detected swing low and swing high. When prompted, click a significant high or low to set your starting point. Fan angles will only be drawn from that point forward. 2. Select your planet(s) in the Planet Selection group. For single-planet analysis, choose your planet as the Primary. For Average or Synodic modes, select both planets. 3. Choose Geocentric (Earth-centered, standard astrology) or Heliocentric (Sun-centered) in the Planet Selection group. Sun and Moon are always geocentric regardless of this setting. 4. Adjust "Price per 1°" to scale the fan angles to your market. Start with 1.0 and increase or decrease until the 1x1 line aligns with meaningful price action. This is the most important calibration step. 5. Set "Pivot Sensitivity" to control how many swings appear. Higher values (30-50) show only major turns; lower values (10-15) catch smaller moves. 6. Choose your two additional fan ratios. The 1x1 is on by default; Ratio 2 and Ratio 3 let you add steeper or shallower angles (e.g., 2x1 for faster price/degree, 1x2 for slower). All three ratios can be toggled independently. 7. Enable Extend Swings (default: 1) to keep the prior swing's angles visible after a new pivot forms. 8. Use future projections to see where fan lines will extend. On non-continuous markets, projections automatically space correctly across market gaps. 9. Check the info panel in the top-right corner. The "Swings" row shows how many completed swings are being tracked out of your Max History limit (e.g., "12/15"). Increase Max History (up to 30) in the Appearance group to keep more swings on screen, or decrease it to reduce visual clutter. █ WHAT MAKES THIS ORIGINAL Most planetary angle indicators on TradingView use a single fixed anchor point chosen by the user. This indicator takes a fundamentally different approach: it automatically detects price pivots and generates a new set of longitude-driven fan angles at every swing reversal. The result is a living framework that adapts as the market develops new structure. Key technical contributions: • Automatic pivot-to-pivot longitude accumulation — fan angles are driven by actual planetary motion between detected swings, not static geometric construction • Net displacement through retrograde — longitude accumulates through retrograde motion (allowing negative deltas) rather than clipping to zero, producing smooth fan lines without plateaus • Polyline-based curved fan rendering — each fan line is a bar-by-bar polyline following the planet's actual path, not a straight line between endpoints • Global longitude history arrays — planetary positions are stored every bar and reused for extensions, eliminating recalculation discontinuities on non-continuous markets • Bar-index projection positioning — future projections use bar_index instead of bar_time, preventing vertical line artifacts on non-continuous markets (stocks, futures, indexes during market close) • Swing extension system — completed swings can be extended to the current bar, preserving visual continuity when new pivots form • Full VSOP87D + ELP2000-82 + Meeus ephemeris computed in real time — 511 terms (1.6% of full theory) delivering sub-0.1° accuracy against JPL DE440 █ LIMITATIONS & TIPS • TradingView limits polylines to 100. Each swing uses 3 polylines (one per ratio). With Extend Swings active, keep Max History ≤ 20 to avoid hitting the cap. • The $/° ratio is market-specific. What works for Bitcoin ($50/°) won't work for ES ($0.50/°). Experiment with the scale to find meaningful alignment. • ERA (Earth Rotation Angle) rotates ~360°/day — only useful on intraday timeframes ≤15 minutes. A runtime error appears if you select ERA on higher timeframes. • On non-continuous markets (stocks, futures), the fan line may show a slightly steeper segment across weekend/holiday gaps because the planet moved during market close. This is astronomically accurate — the visual compression is inherent to how non-continuous charts display time. • For mission-critical timing, always cross-reference with professional tools such as JPL Horizons , Swiss Ephemeris, or Astro.com. █ COMPANION INDICATOR • Price and Longitude Angles — The static anchor version. Draw fan lines from any user-selected high or low with 9 Gann ratios (1x8 through 8x1), zodiac bar coloring, aspect table, and cycle counter. Use it for focused analysis of a single key level; use Planetary Fan Array for automatic swing-by-swing coverage. █ OPEN SOURCE This indicator is part of the fully open-source Planetary Ephemeris project. The core ephemeris library is publicly available for study, modification, and reuse: • BlueprintResearch/blueprint_ephemeris_lib — Planetary calculation engine (VSOP87D, ELP2000-82, Meeus) █ CREDITS & DEPENDENCIES This indicator is built on top of three exceptional open-source libraries. Without the work of these authors, Planetary Fan Array would not exist. • Blueprint Ephemeris by @BlueprintResearch — The astronomical engine powering every planetary calculation in this indicator. Computes real-time ecliptic longitude, declination, and speed for all 11 celestial bodies using VSOP87D (planets), ELP2000-82 (Moon), and Meeus algorithms (Pluto) — entirely within Pine Script. Open source (CC BY-SA 4.0). • ZigLib by @DevLucem — The backbone of all pivot detection in this indicator. Provides the ZigZag algorithm that identifies swing highs and lows, returning precise pivot times and prices that anchor every fan angle. Without ZigLib, there are no swings. • hsvColor by @kaigouthro — The color system behind the planet-specific HSV palette. Provides HSV color construction and gradient interpolation that gives each celestial body its distinct visual identity. Open source (MPL-2.0). • Theoretical framework inspired by W.D. Gann's price-time geometry and Patrick Mikula's Gann's Scientific Methods Unveiled , Volume 2, which details the relationship between planetary longitude and price movement.
Indicador Pine Script®
por BlueprintResearch
3
RSI Divergence (Regular + Hidden + Live) - StableLogicTake your momentum trading to the next level with the RSI Divergence (Regular + Hidden + Live) indicator . This tool doesn't just look at the past; it actively tracks developing price action to spot potential reversals and trend continuations before they fully form. Packed with a clean, gradient-based UI, this indicator automatically scans for four specific types of divergences and visually plots them directly on your oscillator panel. 🌟 Key Features Complete Divergence Detection: Automatically identifies and plots all four major types of divergence: Regular Bullish: Price makes a Lower Low, but RSI makes a Higher Low (Trend Reversal). Regular Bearish: Price makes a Higher High, but RSI makes a Lower High (Trend Reversal). Hidden Bullish: Price makes a Higher Low, but RSI makes a Lower Low (Trend Continuation). Hidden Bearish: Price makes a Lower High, but RSI makes a Higher High (Trend Continuation). Live "Pending" Divergences: Unlike traditional indicators that only plot after a pivot is fully confirmed (which inherently causes lag), this script features a Live Tracking engine. It compares the current real-time candle to the last confirmed pivot, drawing a dashed line to warn you of a developing divergence. Smart Invalidation Logic: The live tracking feature includes a mathematical crossover check. If the RSI line breaks the divergence trendline prematurely, the pending signal is automatically invalidated, keeping your chart free of false signals. Modern Visuals: Features sleek gradient fills for the Overbought (>70) and Oversold (<30) zones, making momentum extremes easy to spot at a glance. ⚙️ Settings & Customization RSI Length: Standard RSI lookback period (Default: 14). Pivot Lookback (Delay): Determines how many bars are required to confirm a swing high or low. A lower number (e.g., 3) makes the indicator faster but slightly riskier/noisier. The default of 5 is a balanced standard. History Depth: Controls how far back the indicator searches for past pivots to compare against (Default: 20). Show Live (Pending)?: Toggle the real-time dashed tracking lines on or off. Custom Colors: Fully customize the line and label colors for every single type of divergence to match your personal chart theme. Pro Tips for Trading Divergence Pending = Prepare: When you see a dashed orange "Live Pending" line, do not enter immediately. Use it as a warning to get your trigger ready. Wait for the candle to close or look for a confirmation signal (like a bullish engulfing or pin bar) on the price chart. Context is King: Regular divergences work best at major support/resistance levels. Hidden divergences work best when trading with the higher timeframe trend. Combine Tools: RSI divergence is a powerful tool, but it shouldn't be used in isolation. Combine it with Volume, Moving Averages, or Market Structure breaks for high-probability setups. *** Disclaimer: This script is for educational and analytical purposes only and does not constitute financial advice.
Indicador Pine Script®
por Stable_Logic