Auf geht's

Pivot Points

AG Pro Break-Retest QualityAG Pro Break-Retest Quality AG Pro Break-Retest Quality is a rules-based indicator designed to evaluate the first retest that occurs after a confirmed horizontal structure break. Many tools can mark a breakout. Fewer help traders judge whether the first pullback after that break is constructive, weak, or low quality. This script focuses on that specific task by grading the first post-break retest through a compact structure-acceptance model. What this script does - Detects confirmed horizontal structure breaks using swing-based pivot levels - Waits for the first retest after the break - Scores that retest using reclaim behavior, rejection quality, retest depth, response speed, volatility cleanliness, and optional volume context - Assigns a simple grade: - A = Strong - B = Valid - C = Weak - F = Failed / Low quality How to read it - Break lines mark the structural level that was broken - Retest labels appear when the first retest is detected and graded - Higher grades suggest cleaner post-break acceptance - Lower grades suggest weaker or less efficient retests How the scoring works The retest score is based on a rules-driven model that evaluates: - reclaim strength - candle rejection quality - retest depth control - speed of response after the break - volatility cleanliness - optional volume context This script is not built to predict every continuation move. Its purpose is to help users evaluate the structural quality of the first retest after a confirmed break. Alerts - Structure Break Detected - First Retest Detected - High-Quality Retest Confirmed Design notes The default settings are intentionally kept compact and chart-friendly. The script aims to preserve readability by limiting historical objects on the chart and emphasizing clearer retest grading rather than heavy dashboard-style output. Limitations - This script evaluates only the first retest after a confirmed break - It is based on swing-derived horizontal structure - It does not model broader market context, higher-timeframe bias, or full trade management - Low-liquidity and highly volatile environments may reduce signal quality Important This indicator is not a strategy, not a profit guarantee, and not a substitute for confirmation, context, or risk management. It is a structure-quality tool intended to support discretionary chart reading.
Pine Script® Indikator
von AGProLabs
CRT Liquidity Grab fixed TF by GrimsonCandle Range Trading (CRT) Indicator The Candle Range Trading (CRT) Indicator detects potential bullish and bearish trading setups by analyzing the relationship between two consecutive candles. When a valid CRT pattern forms, the indicator automatically marks it on the chart with clear visual signals. Very special is, first that you can fix the Timeframe. For Example you choose 4h and it will mark for this TF. Then you can go on maybe 14 min TF and it will show you only the 4h Marks not redraw in 15 min TF. Second und kann choose a lookback from 1 to 50 Candles so you can reduce Market noise. So the Indicator looks for High and Lows from x Candles backwards, How the Pattern Works The indicator evaluates two candles and identifies whether they form a bullish or bearish CRT pattern. Bearish CRT Pattern The first candle is bullish. The second candle is bearish. The high of the second candle exceeds the high of the first candle. The close of the second candle remains within the range of the first candle. Bullish CRT Pattern The first candle is bearish. The second candle is bullish. The low of the second candle falls below the low of the first candle. The close of the second candle remains within the range of the first candle. Visual Signals To make pattern recognition simple: Red mark above the candles → Bearish CRT signal Green mark below the candles → Bullish CRT signal You can change the Mark in the Settings. How to Use Watch for green mark as potential bullish signals. Watch for red mark as potential bearish signals. Combine CRT signals with market structure, support/resistance, or other indicators for better confirmation.
Pine Script® Indikator
von Grimson55
AlphaSpark OverlayThis goes on your main chart. It’s designed to be your ultimate visual roadmap without cluttering your screen (perfect for free TradingView accounts since it combines everything I'm using into one). Opening Range (OR): Automatically maps out the NY session opening range and projects the 1.272, 1.618, 2 and 2.618 deviation boxes. Naked 15m Pivots: This is the liquidity magnet. It dynamically plots untouched 15m highs/lows from the last day (or more if you want to) and automatically deletes them the moment price sweeps them. The VWAPs: Clean, subtle markers for the Daily, Weekly, and Session VWAPs, plus "Naked" previous day/week VWAPs that cut off once mitigated. VWAP Price Channel (VPC): A stepped channel that acts as your dynamic structure and trailing stop-loss manager.
Pine Script® Indikator
von AlphaSpark
CPR MTF StatusMulti-timeframe CPR (Central Pivot Range) dashboard that shows the trend bias across 6 standard timeframe pairs all from a single chart. ── TIMEFRAME PAIRS ── Each row pairs a chart timeframe with its natural CPR anchor: 5m → 1H CPR 15m → 4H CPR 1H → Daily CPR 4H → Weekly CPR D → Monthly CPR W → Yearly CPR ── HOW STATUS IS DETERMINED ── For each pair, the indicator computes the previous-period CPR and the current developing CPR, then compares their position: ▲▲ Strong Bull — developing CPR entirely above previous CPR (no overlap) ▲ Light Bull — bands overlap, but developing pivot is above previous pivot — Neutral — pivots are equal ▼ Light Bear — bands overlap, but developing pivot is below previous pivot ▼▼ Strong Bear — developing CPR entirely below previous CPR (no overlap) The previous CPR uses non-repainting data (prior completed period). The developing CPR repaints to reflect the current state — this is intentional for a live dashboard. ── TIMEFRAME VALIDITY ── CPR calculations require the anchor timeframe to be strictly higher than the chart timeframe. When you're on a higher TF chart (e.g. Daily), lower anchor pairs (1H, 4H) cannot compute correctly because request.security can't aggregate full-period HLC from a lower timeframe. The indicator automatically detects this and either hides invalid rows (default) or dims them with "n/a". A hint row appears when rows have been hidden, suggesting you switch to a lower chart timeframe to see all pairs. ── DISPLAY MODES ── Full Mode (default): Vertical table with Chart TF, CPR TF, and color-coded Status columns. Optionally shows previous and developing pivot values. The row matching your current chart timeframe is highlighted. Compact Mode: Single horizontal row of coloured cells — just the CPR label and a status arrow (e.g. "D▲▲"). Hover any cell for full detail. An optional summary cell at the end shows the net score. ── FEATURES ── • Toggle individual timeframe rows on/off • Customizable 5-level color scheme (strong/light bull/bear + neutral) • Optional pivot value columns (prev + developing) • Summary row with bull/neutral/bear count and tinted background • Current chart TF row auto-highlighting • Status line showing bull/bear TF counts • Alerts: all 6 bullish, all 6 bearish, 5+ bullish, 5+ bearish • Table position and text size settings • Works on any symbol ── USAGE TIPS ── • Best used on lower timeframe charts (5m or 15m) to see the most rows • Pairs well with the Vector CPR Bands indicator for full CPR + band analysis • When all or most timeframes align in one direction, it signals strong multi-timeframe confluence
Pine Script® Indikator
von godzcopilot
Reverse ZigZagReverse ZigZag A reimagined ZigZag indicator that processes price data from the most recent bar backwards, solving the biggest frustration with traditional ZigZag implementations: the inaccurate last leg. ━━━━━━━━━━━━━━━━━━━━━━━━ THE PROBLEM Standard ZigZag indicators process bars left-to-right. This means the last leg is always "tentative" — it often anchors to the current bar instead of the actual swing extreme. If the true low was 3 bars ago but price has since bounced, the traditional ZigZag either misses it entirely or draws to the wrong bar. This makes the indicator unreliable precisely where it matters most: at the current price action. THE SOLUTION This indicator flips the logic. Instead of walking forward through history, it starts at the most recent bar and walks backwards. The result: → The last leg is always accurate — it finds the true extreme first, then works outward → No tentative or "pending" pivots — every swing point is drawn to the correct bar → No repainting — pivots don't shift around as new bars form → Clean, consistent results that match what your eyes see on the chart ━━━━━━━━━━━━━━━━━━━━━━━━ HOW IT WORKS Phase 1 — Initialization Starting from the current bar, the indicator walks left until it finds a price range that exceeds the deviation threshold. The more recent extreme becomes the first confirmed pivot. Phase 2 — Backward Walk From that first pivot, the algorithm continues left, tracking running highs and lows. When price reverses by more than the deviation %, a pivot is confirmed and the direction flips. This continues across the full lookback window. Phase 3 — Drawing Lines and labels are drawn between all confirmed pivots. Labels show the price and the magnitude of each swing move. ━━━━━━━━━━━━━━━━━━━━━━━━ SETTINGS • Deviation % — Minimum reversal required to confirm a new pivot (default: 5%). Lower values capture smaller swings, higher values show only major structure. • Lookback Bars — How far back to calculate (default: 500). Increase for longer history. • Show Price Labels — Toggle pivot labels showing price and swing magnitude. • Line Color / Width — Customize appearance. • High/Low Pivot Colors — Separate colors for swing highs and lows. ━━━━━━━━━━━━━━━━━━━━━━━━ USE CASES • Swing traders identifying reversal points and market structure • Harmonic pattern recognition where accurate pivot placement is critical • Elliott Wave analysis requiring precise swing labeling • Support/resistance identification from confirmed swing levels • Measuring swing magnitude to gauge momentum shifts ━━━━━━━━━━━━━━━━━━━━━━━━ NOTES • The indicator recalculates on the last bar, so all drawing happens once per bar update — this is efficient and avoids the overhead of managing state across bars. • Works on any timeframe and any instrument. ━━━━━━━━━━━━━━━━━━━━━━━━
Pine Script® Indikator
von sylox
2
Smart Money: Auto Order Blocks [identityKa]Overview The Smart Money: Auto Order Blocks is a professional-grade volume and structural mapping tool designed for SMC (Smart Money Concepts) traders. Order Blocks represent areas where large financial institutions have accumulated significant buy or sell positions. Unlike basic pivot indicators that leave cluttered lines on the chart indefinitely, this script introduces a Smart Mitigation Engine that automatically tracks the validity of these institutional zones in real-time. Core Mechanics & Detection The algorithm uses pivot sensitivity to locate origin points of major market imbalances: Bearish Order Blocks (Supply): Detected at the absolute high of a structural swing before a major downward move. The box is drawn from the wick's high to the highest candle body in that cluster, encapsulating the entire institutional sell zone. Bullish Order Blocks (Demand): Detected at the absolute low of a structural swing before a major upward move. The box encapsulates the wick's low up to the lowest candle body. The Smart Mitigation Engine A fundamental rule of SMC is that once an Order Block is fully pierced and the price closes beyond it, the institutional orders within that zone are considered filled or "Mitigated." This script constantly monitors the closing price. If a candle strictly closes above a Bearish OB, or strictly below a Bullish OB, the algorithm mathematically invalidates the zone. Upon mitigation, the box is instantly deleted from the chart, ensuring that only "Fresh" and highly reactive unmitigated zones are visible to the trader. This keeps the workspace incredibly clean. HUD Dashboard & AI Logic The on-chart intelligence panel evaluates the proximity of the live price to the active Order Blocks: Dangerous: Displayed actively whenever the current live price is trading inside the coordinates of an unmitigated Order Block. This serves as a warning that the price is in an institutional high-friction area where sharp rejections and high volatility are imminent. LONG / SHORT: The engine tracks the macro bias based on the last mitigation event. If a Bearish OB was broken upwards (invalidated resistance), the macro bias shifts to LONG. If a Bullish OB was broken downwards, the bias shifts to SHORT. How to Use It This tool provides exceptional context for trade entries. When the AI Suggestion reads "LONG," traders should patiently wait for the price to pull back into a green Bullish OB zone. Once the price enters the zone (triggering the "Dangerous" state), traders can drop to a lower timeframe (e.g., 5-minute) to spot a micro-reversal pattern before executing a trade aligned with the macro trend.
Pine Script® Indikator
von IdentityKa
2
Dynamic Trendlines & Breakouts [identityKa]Overview The Dynamic Trendlines & Breakouts is an automated structural analysis tool designed to remove human subjectivity from drawing trendlines. By utilizing mathematical pivot extremes, the script identifies the dominant market geometry in real-time. More importantly, it incorporates a Smart Volume Filter to distinguish between genuine structural breakouts and low-volume retail traps (fakeouts). Core Engine Mechanics The indicator operates on two primary algorithmic pillars: Dynamic Coordinate Mapping: The script calculates the most recent pivot highs and pivot lows based on a user-defined lookback sensitivity. It then draws precision-extended dashed lines connecting these coordinates, forming dynamic Resistance (Upper Line) and Support (Lower Line) boundaries. Volume-Confirmed Breakouts: The script continuously monitors the closing price relative to these extended lines. However, a crossover is not enough. If the "Volume Confirmation" feature is active, the engine checks a 20-period Simple Moving Average of the volume. A Bullish "B" (Buy) or Bearish "S" (Sell) label is only printed if the breakout candle is accompanied by above-average institutional volume, significantly increasing the probability of trend continuation. HUD Dashboard & AI Proximity Logic The integrated on-chart panel tracks the last confirmed breakout state and utilizes an ATR-based proximity sensor to generate the AI Suggestion: Dangerous: Displayed actively whenever the current price is within a 0.5 Average True Range (ATR) distance of either the upper or lower trendline. This alerts the trader that the price is actively testing a major structural boundary, making new entries highly risky until a clear bounce or volume-confirmed breakout occurs. LONG / SHORT: Triggered when the last structural breakout was Bullish (LONG) or Bearish (SHORT), provided the price is safely trending away from the immediate resistance/support lines. How to Use It This tool is ideal for momentum and breakout traders. When the price approaches a trendline (AI Suggestion reads "Dangerous"), prepare for a setup. Do not front-run the breakout. Wait for the engine to print the "B" or "S" label, confirming that both the structural level has been breached and the volume supports the move. Once confirmed, trade in the direction of the new momentum.
Pine Script® Indikator
von IdentityKa
Liquidity Magnet Zones [identityKa]Overview The Liquidity Magnet Zones is an advanced Smart Money Concepts (SMC) indicator that identifies and manages unmitigated pools of liquidity. Institutional algorithms gravitate toward liquidity to fill large orders. This script mathematically plots these high-probability areas—Buy Side Liquidity (BSL) and Sell Side Liquidity (SSL)—and actively manages them, deleting zones the moment they are "swept" to keep the chart clean and relevant. Core Mechanics: BSL & SSL Detection The engine uses pivot point analysis to map market extremes: Buy Side Liquidity (BSL): Formed at major structural highs. Retail traders typically place stop-losses (buy-to-cover orders) above these highs. The script identifies these unmitigated peaks and draws a dashed line projecting into the future. Sell Side Liquidity (SSL): Formed at major structural lows. Retail traders place sell-stop orders below these lows. The script tracks these valleys as magnetic targets for price action. Smart Mitigation (The Sweep Engine) Unlike static drawing tools, this indicator constantly evaluates the live price against the drawn liquidity zones. If a candlestick wick or body pierces a BSL or SSL line, the liquidity is considered "Swept" (mitigated). The script instantly removes the line from the chart, triggering a real-time alert that institutional orders have likely been absorbed, opening the door for a structural reversal. HUD Dashboard & Post-Sweep AI Logic The integrated on-chart panel evaluates the structural bias based on the most recent liquidity event: Dangerous: Displayed actively while the price is piercing and sweeping a liquidity line. This warns traders that extreme volatility is present as stop-losses trigger, making it highly risky to enter breakout trades. SHORT: Triggered after BSL has been swept. SMC logic dictates that Smart Money forces price upward to trigger buy-stops, providing the necessary liquidity to execute large sell orders. Therefore, the post-sweep bias becomes Bearish (SHORT). LONG: Triggered after SSL has been swept. Smart Money forces price downward to trigger sell-stops, allowing them to accumulate buy orders. The post-sweep bias becomes Bullish (LONG). How to Use It This tool is designed for reversal and mitigation trading, not breakout trading. Do not blindly place limit orders at BSL or SSL lines. Instead, wait for the price to hit the line (AI Suggestion reads "Dangerous"). Drop to a lower timeframe (e.g., 1m or 5m) and look for a Change of Character (CHoCH) confirming that Smart Money is indeed reversing the trend after engineering liquidity.
Pine Script® Indikator
von IdentityKa
2
Auto Dynamic S/R Zones Pro [identityKa]Overview The Auto Dynamic S/R Zones Pro is a structural Price Action utility that automatically identifies, draws, and manages Supply (Resistance) and Demand (Support) liquidity zones. Unlike traditional pivot indicators that draw single horizontal lines, this script constructs volumetric "boxes" to represent areas of historical institutional interest. Furthermore, it incorporates a Smart Mitigation Engine that automatically cleans the chart by deleting zones once they have been functionally broken or fully mitigated by price action. Core Zone Calculation Methodology The script utilizes historical pivot detection (ta.pivothigh and ta.pivotlow) based on a user-defined lookback/lookforward sensitivity. Once a structural extreme is found, the engine calculates the boundaries of the zone to capture the entire rejection area rather than just the wick tip: Resistance Zones (Supply): The top of the box is anchored to the absolute high of the pivot candle. The bottom of the box is calculated using the maximum value between the open and close of that same candle (capturing the wick-to-body spread). Support Zones (Demand): The bottom of the box is anchored to the absolute low of the pivot candle. The top of the box is calculated using the minimum value between the open and close (capturing the lower wick-to-body spread). The Smart Mitigation Engine (Chart Cleanup) To prevent chart clutter and outdated data, the script utilizes dynamic arrays to manage the drawn boxes. The script continuously monitors the closing price relative to all active zones. If a candlestick closes strictly above the upper boundary of a Resistance box, or strictly below the lower boundary of a Support box, the zone is mathematically considered "Mitigated" (broken). Upon mitigation, the script instantly deletes the box and its associated label from the chart history, firing a breakout alert and leaving only fresh, untested zones visible. HUD Dashboard & AI Logic The integrated on-chart panel evaluates the immediate relationship between the current price and the active S/R arrays: Dangerous: Triggered whenever the current closing price is actively printing inside the coordinates of any active Support or Resistance box. This indicates price is in a high-friction decision zone where rejections are highly probable. LONG / SHORT: The engine tracks the most recent structural breakout. If the last mitigated zone was a Resistance, it adopts a "LONG" bias indicating bullish structure. If the last mitigated zone was a Support, it adopts a "SHORT" bias indicating bearish structure, provided the price is not currently stuck inside another zone. How to Use It This indicator simplifies top-down analysis. Traders can use a higher timeframe (e.g., 1H or 4H) to let the script automatically map out major untested supply and demand zones. When the price enters an active zone (triggering the "Dangerous" AI state), traders can drop to a lower timeframe to look for reversal patterns. Alternatively, traders can trade the momentum of the breakouts by setting alerts for when a zone is officially broken/mitigated.
Pine Script® Indikator
von IdentityKa
Smart Pivot Reversals [identityKa]Overview The Smart Pivot Reversals is a structural Price Action indicator designed to automatically detect and highlight market swing highs (Tops) and swing lows (Bottoms). Instead of relying on lagging moving averages to find reversals, this script uses raw bar-by-bar analysis to identify local structural extremes. To increase signal reliability, it includes optional, mathematically strict filters for macro-trend alignment and momentum exhaustion. Underlying Concepts & Calculations At its core, the indicator utilizes the standard ta.pivothigh and ta.pivotlow functions. The detection mechanism is entirely governed by two user-defined parameters: Left Bars (Sensitivity): The number of preceding bars that must have a lower high (for a Top) or a higher low (for a Bottom). A smaller number detects micro-swings, while a larger number identifies major structural points. Right Bars (Confirmation): The number of subsequent bars required to validate the pivot. Note on Visualization: The script uses a negative offset equal to the "Right Bars" value. This means the "TOP" or "BOTTOM" label is plotted exactly on the pivot candle historically, only after the confirmation bars have closed. Smart Validation Filters (Optional Logic) To filter out noise in ranging markets, traders can enable two concurrent mathematical filters: Macro Trend Filter (EMA): When activated, the script calculates a standard Exponential Moving Average (default length 200). A pivot low (Bottom) is only validated if the closing price is strictly above the EMA (identifying pullbacks in an uptrend). A pivot high (Top) is only validated if the closing price is strictly below the EMA. Momentum Strict Mode (RSI): When activated, the script checks the Relative Strength Index (default length 14) at the exact moment the pivot is confirmed. A Top is only valid if the RSI is in the Overbought zone (≥70). A Bottom is only valid if the RSI is in the Oversold zone (≤30). HUD Dashboard & State Tracker The script features a built-in, customizable on-chart panel that aggregates the last confirmed structural pivot and outputs an AI-style state suggestion: LONG: Triggered and sustained when the last confirmed structure was a valid BOTTOM. SHORT: Triggered and sustained when the last confirmed structure was a valid TOP. Dangerous: Displayed during periods of transition or neutral states before a definitive structure is confirmed. How to Use It This tool is highly effective for traders utilizing Price Action methodologies, particularly on intraday charts (such as 15-minute or 1-hour timeframes). The printed Top/Bottom labels serve as excellent objective points for drawing support/resistance zones or trendlines. Traders can use the optional EMA and RSI filters to mechanically ignore counter-trend setups and only focus on high-probability reversal structures that align with the broader market context.
Pine Script® Indikator
von IdentityKa
EdgeGate Premarket Breakout LevelsOverview EdgeGate™ Premarket Breakout Levels is designed for traders who use a premarket breakout strategy and want a simple way to visualize the key levels that often drive early-session momentum. The indicator automatically plots: Premarket High Premarket Low Previous New York Session High Previous New York Session Low These levels help traders quickly identify potential breakout zones, liquidity areas, and key intraday structure without needing to manually mark sessions each day. What the Indicator Shows Premarket High / Low During the premarket session (default 04:00–09:30 ET), the indicator continuously tracks the session range and plots: Premarket High Premarket Low Once the premarket session closes, these levels become fixed and extend across the trading day. These levels are commonly used by traders watching for premarket breakout setups after the opening bell. Previous NY Session High / Low The indicator also plots the previous regular New York session range (09:30–16:00 ET): Prev NY High Prev NY Low These levels often act as important areas of: support and resistance liquidity sweeps breakout continuation or rejection zones How Traders Use These Levels Traders using a premarket breakout strategy typically watch for: Price consolidating below Premarket High before a breakout Momentum moves through Premarket Low for downside continuation Reactions at Previous NY Session High or Low Liquidity sweeps before trend continuation This indicator helps keep those reference levels clearly visible throughout the trading session. Customization Users can customize: Premarket session times Line colors Line styles (solid, dashed, dotted) Line thickness This allows the levels to be styled to match individual chart layouts. 🟣 About EdgeGate™ EdgeGate™ builds tools around one principle: Structure. Liquidity. Execution. We focus on developing precision-based session and liquidity frameworks designed for intraday traders who care about context, not clutter. This is Version 1.0.0 of the EdgeGate™ public toolkit — released free to the TradingView community. More session tools and execution-focused models coming soon. 🟣 Version EdgeGate™ Premarket Breakout Levels Version: 1.0.0 Release Type: Initial Public Release Status: Stable Build Philosophy: Clean session structure only Included in v1.0.0 Premarket High / Low tracking (ET) Previous NY Session High / Low tracking (ET) Live Premarket High / Low plotting during premarket Locked Premarket levels after session close Previous NY session High / Low displayed on current chart Customizable line colors, widths, and styles Session-based level framework designed for premarket breakout traders 🟣 Release Standard (EdgeGate™ Framework) All EdgeGate™ public tools will follow a structured release format: Version number Release type (Major / Minor / Patch) Documented feature set Defined behavioral philosophy Transparent future roadmap 🆓 Open Source This script is released free and open-source for the community. You’re welcome to modify, improve, and build upon it respectfully. ⚠️ Disclaimer For educational purposes only. Not financial advice.
Pine Script® Indikator
von EdgeGateLabs
Hammer Reversal StructureThe script combines: Hammer / inverse hammer geometry Recent support or resistance zone interaction Sweep-and-reclaim behavior Optional cluster shelf and prior range context Volume confirmation Optional EMA 9 / EMA 20 / VWAP confluence notes This version is designed to reduce weak textbook-only signals by requiring the candle to form in a more meaningful location on the chart. It supports both Trend and Consolidation modes, includes configurable strictness, and offers debug tools such as candidate labels, gate tables, and plotted structure levels for review and tuning. Signals shown: H = Bull Hammer IH = Bearish Inverse Hammer Best used as a reversal-context tool, not as a standalone entry system.
Pine Script® Indikator
von Term401
trend line [odnac]Overview This indicator automatically detects swing highs and swing lows, and draws trendlines connecting valid highs to highs and lows to lows. Lines automatically terminate when price breaks through them. Four pivot detection methods are supported. Trendline Conditions High Trendline (Descending Resistance): Drawn only when the current swing high is lower than the previous swing high Low Trendline (Ascending Support): Drawn only when the current swing low is higher than the previous swing low Wick Breach Filter: If any candle wick (high/low) between two pivot points touches or crosses the trendline, the line is not drawn Breakout Detection: When the closing price crosses the trendline, the line is terminated at that bar Pivot Detection Methods (4 modes) Swing Confirm Detects highs and lows based on left/right bar count, but only accepts pivot points that pass an additional bearish/bullish confirmation condition. Produces fewer but more reliable swing points with less noise. Pivot High/Low Uses raw ta.pivothigh / ta.pivotlow values directly. Any point that is higher or lower than the surrounding N bars on each side is recognized as a pivot. Williams Fractal Confirms a pivot when the center bar's high/low is greater or less than N bars on both sides. The default value of 2 produces the classic 5-bar fractal pattern. Donchian Uses the highest high and lowest low over N bars as pivot points. A simple and clean channel-based pivot detection method. Settings > Trendline Mode : Select pivot detection method > Swing Left/Right Bars : Number of bars on each side for Swing Confirm mode > Pivot Left/Right Bars : Number of bars on each side for Pivot High/Low mode > Fractal Bars : Number of bars on each side for Williams Fractal > Donchian Length : Lookback period for Donchian mode > Show Labels : Toggle swing point labels on/off > Show High/Low Trendlines : Toggle high/low trendlines on/off > High/Low Line Color : Color of trendlines Notes Trendlines are drawn based on confirmed pivot points only, with no repainting The wick breach filter may result in fewer lines being drawn. This is intentional — only clean, high-confidence trendlines are displayed Each mode has its own independent parameters, so be sure to adjust settings individually when switching modes
Pine Script® Indikator
von odnac
Dynamic Support & Resistance [UAlgo]Dynamic Support & Resistance is a pivot driven structure indicator that detects recurring reaction prices and converts them into live support and resistance zones. The script does not treat every pivot as an isolated event. Instead, it groups nearby pivots into shared price areas, counts how many times the market has respected each area, and only promotes a level visually once it reaches the required minimum number of touches. This creates a cleaner and more practical market structure map. When price reacts again near an existing zone, the level is updated rather than duplicated. As a result, the plotted areas represent repeated interaction and growing structural significance instead of a large collection of disconnected swing points. Each active level is displayed as a channel centered on the level price. The size of that channel is based on the user selected tolerance percentage, so every level is shown as a reaction zone rather than a single exact line only. A center line and a text label are also added, which makes the structure easier to read in live chart conditions. The script also includes a clear invalidation model. Support becomes invalid when price closes meaningfully below the zone by more than the selected break threshold. Resistance follows the opposite logic. Once invalidated, the level is removed from the active structure map, which keeps the chart focused on areas that are still relevant. This makes the indicator useful for traders who want a simple but adaptive framework for mapping horizontal support and resistance. It works well for identifying repeated reaction zones, tracking the growth of structural importance through multiple touches, and recognizing when a level has finally lost validity. 🔹 Features 🔸 Pivot Based Structure Detection The script starts from confirmed pivot highs and pivot lows. This means support and resistance zones are built from meaningful swing points rather than from arbitrary rolling highs and lows. As a result, the detected levels are more closely aligned with actual market turning areas. 🔸 Level Clustering Instead of Raw Pivot Plotting A newly detected pivot is not always turned into a brand new level. The script first checks whether that pivot belongs to an existing active zone within the allowed tolerance. If it does, the existing level is updated. If it does not, a new level is created. This prevents unnecessary duplication and keeps the structure map organized. 🔸 Touch Counting and Strength Filtering Every level tracks how many times price has reacted around it. A zone becomes visually important only after it reaches the required minimum number of touches. This helps filter out weak one time reactions and highlights price areas that have shown repeated acceptance or rejection. 🔸 Adaptive Reaction Zones Each level is displayed as a channel rather than as a single price only. The channel width is calculated from the level price and the selected tolerance percentage. This makes the plotted area more realistic because support and resistance usually behave as zones rather than exact ticks. 🔸 Dynamic Price Recentering When a new pivot is assigned to an existing level, the script updates the level price using an average based on the previous stored price and the new pivot. This gradually shifts the zone toward the center of actual reaction activity, which makes the level more representative over time. 🔸 Separate Support and Resistance Maps Support and resistance are stored independently in their own arrays. This allows the script to manage bullish and bearish reaction zones separately while preserving clean logic for visualization, touch counting, invalidation, and cleanup. 🔸 Live Visual Rendering Once a level becomes strong enough, the script draws: a reaction channel, a center line, and a label showing the role and price. This produces a chart friendly display that is easy to interpret during live trading or post analysis. 🔸 Invalidation by Closing Break Levels are not removed by random intrabar noise alone. Instead, support is invalidated only when closing price moves below the level by more than the selected break percentage, and resistance is invalidated only when closing price moves above it by more than that threshold. This helps reduce premature removals. 🔸 Automatic Cleanup Broken levels are removed from the active arrays after invalidation. This keeps the script efficient and prevents the internal structure store from filling with irrelevant levels. 🔸 Label Position Refresh On the last bar, active labels are shifted slightly forward so they remain readable and do not sit directly on top of current candles. This small detail improves chart presentation significantly. 🔹 Calculations 1) Pivot Detection float ph = ta.pivothigh(high, pivotLen, pivotLen) float pl = ta.pivotlow(low, pivotLen, pivotLen) int pIdx = bar_index - pivotLen if not na(ph) resistances.processPoint(ph, -1, pIdx) if not na(pl) supports.processPoint(pl, 1, pIdx) This is the starting point of the script. The code uses ta.pivothigh and ta.pivotlow to detect confirmed swing highs and swing lows. Because pivots are only confirmed after pivotLen bars on both sides, the actual pivot bar is not the current bar. That is why the script calculates: pIdx = bar_index - pivotLen This gives the real bar index where the pivot occurred. Then the pivot is passed into the correct structure map: pivot highs go into the resistance array, pivot lows go into the support array. So at this stage, the script is transforming raw swing points into candidate support or resistance events. 2) Grouping New Pivots Into Existing Levels method processPoint(array levels, float price, int role, int idx) => bool found = false for in levels if lvl.active float tolerance = lvl.price * zonePct if math.abs(price - lvl.price) <= tolerance lvl.price := (lvl.price * lvl.count + price) / (lvl.count + 1) lvl.count += 1 lvl.updateVisuals() found := true break if not found SRLevel newLvl = SRLevel.new(price, 1, role, true, na, na, na, idx) levels.push(newLvl) This method decides whether a new pivot should strengthen an existing level or create a completely new one. For every active level in the relevant array, the script calculates a tolerance band: tolerance = lvl.price * zonePct Then it checks whether the new pivot price is close enough to that level: math.abs(price - lvl.price) <= tolerance If the pivot falls inside the allowed zone, the script treats it as another touch of the same structure. It then updates the stored level price using an average weighted by the existing touch count: lvl.price := (lvl.price * lvl.count + price) / (lvl.count + 1) This is important. The level does not stay frozen forever. It gradually recenters as more pivots are absorbed into it. At the same time, the touch count increases, which strengthens the zone statistically. If no active level is close enough, the script creates a fresh support or resistance level with an initial count of one. So this method is the core clustering engine of the whole indicator. 3) Minimum Touch Logic and Zone Construction method updateVisuals(SRLevel this) => if this.active and this.count >= minStrength color c = this.role == 1 ? colSup : colRes float tolerance = this.price * zonePct float top = this.price + tolerance float bot = this.price - tolerance This is the first visual gate. A level is drawn only if two conditions are true: the level must still be active, and its touch count must be greater than or equal to the minimum strength input. That means weak single touch levels can exist internally, but they are not shown until they prove themselves. Once the level qualifies, the script calculates the channel boundaries around the center price: top = this.price + tolerance bot = this.price - tolerance So the plotted zone is always centered on the current level price and expands above and below it by the selected tolerance percentage. This is what turns the raw pivot cluster into an actual support or resistance zone. 4) Drawing the Channel, Center Line, and Label if na(this.bx) this.bx := box.new( left=this.start_idx, top=top, right=bar_index, bottom=bot, border_color=color.new(c, 0), border_style=line.style_dotted, bgcolor=color.new(c, 80), extend=extend.right ) else this.bx.set_top(top) this.bx.set_bottom(bot) if na(this.ln) this.ln := line.new( x1=this.start_idx, y1=this.price, x2=bar_index, y2=this.price, color=c, width=1, extend=extend.right ) else this.ln.set_y1(this.price) this.ln.set_y2(this.price) Once a level is strong enough, the script renders its visual structure. The box represents the full support or resistance channel from the starting pivot index to the current bar, and it is extended to the right so the zone remains visible into future bars. The line is drawn exactly at the stored level price, which serves as the center of the zone. Because the price can shift slightly over time as new pivots are absorbed, the center line is updated dynamically as well. So visually, each confirmed level contains: a shaded reaction area, a center reference line, and an ongoing extension into the future. This gives the user both a zone view and a central price reference at the same time. 5) Text Label Calculation string txt = str.format("{0} - {1,number,#.##}", this.role == 1 ? "Support" : "Resistance", this.price) if na(this.lbl) this.lbl := label.new( x=bar_index, y=this.price, text=txt, style=label.style_label_left, color=color.new(color.black, 100), textcolor=colTxt, size=size.small ) else this.lbl.set_xy(bar_index, this.price) this.lbl.set_text(txt) This snippet builds and updates the text label for each visible level. The label text is generated from the level role and the current averaged level price. So if the level belongs to the bullish structure map, the label shows Support and the current price. If it belongs to the bearish structure map, it shows Resistance and the current price. The label is then either created or updated at the latest bar. This means the label always reflects the most current state of the zone instead of staying attached to an outdated price. 6) Invalidation Logic method checkInvalidation(array levels, float currentPrice) => for in levels if lvl.active float threshold = lvl.price * breakPct bool broken = false if lvl.role == 1 if currentPrice < lvl.price - threshold broken := true else if currentPrice > lvl.price + threshold broken := true if broken lvl.active := false lvl.updateVisuals() This method decides when a level should stop being considered valid. For every active level, the script calculates a break threshold based on the level price and the selected invalidation percentage: threshold = lvl.price * breakPct Then it applies directional logic. For support: price must close below the level by more than the threshold. For resistance: price must close above the level by more than the threshold. This is important because it means the script does not remove zones on a tiny touch or minor overshoot. A meaningful closing break is required. When that break happens, the level is marked inactive and its visuals are refreshed so the box, line, and label are deleted. 7) Visual Removal of Broken Levels else if not this.active if not na(this.bx) this.bx.delete() this.bx := na if not na(this.ln) this.ln.delete() this.ln := na if not na(this.lbl) this.lbl.delete() this.lbl := na This is the part of updateVisuals that handles invalidated levels. Once a level is no longer active, the script deletes all visual objects associated with it: the channel box, the center line, and the text label. This keeps the chart focused on only those support and resistance zones that are still valid. It also prevents broken levels from continuing to influence the user visually after the market has already moved through them. 8) Cleanup of Inactive Objects From Memory method cleanup(array levels) => int n = levels.size() if n > 0 for i = n - 1 to 0 SRLevel lvl = levels.get(i) if not lvl.active levels.remove(i) Deleting a level visually is only one part of the process. The script also removes inactive levels from the calculation arrays. This reverse loop is important because removing array elements while looping forward can shift indices and create logic errors. By iterating from the end toward zero, the script safely removes inactive items. This keeps the internal storage efficient and prevents the structure engine from wasting time checking already broken zones on future bars. 9) Last Bar Label Position Update if barstate.islast for lvl in supports if lvl.active and not na(lvl.lbl) lvl.lbl.set_x(bar_index + 5) for lvl in resistances if lvl.active and not na(lvl.lbl) lvl.lbl.set_x(bar_index + 5) This small block improves readability on the chart. On the last visible bar, the script shifts active labels slightly to the right of the current candle. That creates a cleaner presentation and reduces overlap between labels and price bars. Although this does not change the structural logic of the indicator, it improves usability in live analysis and makes the levels easier to read at a glance. 10) Full Execution Flow if not na(ph) resistances.processPoint(ph, -1, pIdx) if not na(pl) supports.processPoint(pl, 1, pIdx) supports.checkInvalidation(close) resistances.checkInvalidation(close) supports.cleanup() resistances.cleanup() This compact block summarizes how the script behaves on every bar. First, it checks whether a new pivot high or pivot low has been confirmed. Second, it sends that pivot into the correct level array. Third, it checks whether any active support or resistance has been invalidated by the current closing price. Finally, it removes inactive levels from memory. So the script is constantly cycling through four steps: detect, cluster, invalidate, clean. That is why the indicator remains dynamic. It is always updating the active structure map as the market evolves.
Pine Script® Indikator
von UAlgo
4
Luminous Pivot S&R Matrix [Pineify]Luminous Pivot S&R Matrix — Dynamic Support & Resistance Zones with ATR-Adaptive Width and Breakout Detection The Luminous Pivot S&R Matrix is a dynamic support and resistance indicator that automatically identifies significant pivot highs and pivot lows, constructs ATR-adaptive zones around them, and monitors each zone in real time for breakout invalidation. Unlike static horizontal line tools that require manual placement, this indicator continuously scans price action for structurally significant turning points using a configurable lookback window, then wraps each pivot in a volatility-scaled zone whose width adapts to current market conditions via the Average True Range (ATR). When price closes beyond a zone's pivot level, the zone is automatically deactivated and visually dimmed, while a breakout signal is plotted — giving traders a fully automated, self-managing support and resistance framework that stays relevant as markets evolve. Key Features Automatic pivot detection using a configurable lookback length to identify both major and minor structural turning points in price ATR-adaptive zone construction that dynamically scales the width of each support and resistance zone based on current market volatility Real-time zone management with automatic extension of active zones to the current bar and visual invalidation when zones are broken Breakout detection system that flags bullish breakouts (close above resistance) and bearish breakouts (close below support) with triangle markers and candle coloring Memory management system that limits the number of displayed zones per side, automatically removing the oldest zones to keep charts clean and readable Built-in alert conditions for both bullish and bearish breakouts, enabling automated notification workflows How It Works The indicator operates through a three-stage pipeline: pivot detection, zone construction, and dynamic zone management. Stage 1: Pivot Detection The indicator uses Pine Script's built-in ta.pivothigh() and ta.pivotlow() functions with a user-defined lookback length (default: 15 bars). A pivot high is confirmed when a bar's high is the highest value within the lookback window on both sides. Similarly, a pivot low is confirmed when a bar's low is the lowest value within that same window. Because confirmation requires bars to the right of the pivot, detected pivots are inherently lagged by the lookback length — this is by design, as it ensures only structurally validated turning points are plotted, filtering out noise and false signals. Stage 2: ATR-Adaptive Zone Construction Once a pivot is confirmed, the indicator constructs a zone around it. Rather than using a fixed-width band, the zone boundaries are calculated using the 14-period ATR value at the pivot bar, scaled by the user's ATR multiplier (default: 0.8). The zone extends from pivot price + (ATR × multiplier) / 2 to pivot price − (ATR × multiplier) / 2 . This means zones are naturally wider during volatile market conditions and narrower during calm periods, providing contextually appropriate support and resistance bands. A horizontal line is drawn at the exact pivot price, and a semi-transparent box fills the zone area. Stage 3: Dynamic Zone Management & Breakout Detection On every bar, the indicator iterates through all active zones. Active zones are extended rightward to the current bar, keeping them visually current. The indicator then checks whether price has closed beyond the zone's pivot level — above for resistance zones, below for support zones. When a breakout occurs, the zone is deactivated (marked inactive), its visual appearance is dimmed to gray with a dashed line style, and a breakout flag is raised. This flag triggers the plotted triangle signal and candle coloring for that bar. Trading Ideas and Insights Zone Bounce Entries — When price approaches an active support zone from above, look for bullish reversal candlestick patterns (hammer, engulfing) within the zone for potential long entries. The zone's ATR-based width provides a natural area for price to find buyers, and the wider the zone, the more volatility the market has been experiencing — suggesting a larger potential reaction. Breakout Continuation Trades — When a bullish breakout signal fires (green triangle), it confirms that price has closed above a resistance pivot. Traders can use this as confirmation to enter long positions, especially when the breakout occurs on above-average volume. The invalidated zone often becomes new support on retests. Zone Density Analysis — Areas where multiple support or resistance zones cluster together represent stronger structural levels. When several pivots form at similar price levels, the overlapping zones create a high-confluence area that is more likely to hold or produce significant breakouts when finally violated. Failed Breakout Recognition — If price triggers a breakout signal but quickly reverses back into the zone on the next bar, this suggests a false breakout or stop hunt. Traders can watch for these failed breakouts as potential reversal signals in the opposite direction. Trend Context — In a strong uptrend, you will observe support zones consistently holding while resistance zones are frequently broken (bullish breakout signals). In a downtrend, the opposite pattern emerges. Tracking the ratio of bullish to bearish breakouts provides a structural view of trend strength. How Multiple Indicators Work Together The Luminous Pivot S&R Matrix integrates three complementary analytical techniques into a unified support and resistance system: Pivot point detection provides the structural price levels, ATR-based zone construction adds volatility context to those levels, and the real-time breakout detection system transforms static levels into dynamic, self-managing trading zones — together forming a complete support and resistance analysis framework. The pivot detection engine serves as the foundation, identifying bars where price has demonstrably reversed direction. The configurable lookback length allows traders to tune the sensitivity — a shorter lookback (5-10) captures minor swing points suitable for intraday trading, while a longer lookback (15-30) identifies major structural levels appropriate for swing and position trading. The ATR-adaptive zone construction addresses a fundamental limitation of traditional pivot-based indicators: a single price line rarely captures the full area where supply or demand exists. By expanding each pivot into a zone scaled by the ATR, the indicator acknowledges that support and resistance are areas , not exact prices. The ATR multiplier gives traders control over how much volatility context to incorporate — a lower multiplier (0.3-0.5) creates precision zones for tight stop placement, while a higher multiplier (1.0-1.5) creates wider zones that capture the full range of potential price reaction. The breakout detection and zone lifecycle management system is what transforms this from a static level-drawing tool into a dynamic analytical framework. By automatically tracking whether each zone remains active or has been invalidated, the indicator eliminates the manual overhead of monitoring multiple levels. The visual differentiation between active zones (solid colored) and broken zones (gray dashed) provides instant context about which levels are still structurally relevant. The memory management system ensures that only the most recent zones remain on the chart, preventing visual clutter that accumulates with traditional pivot indicators. Unique Aspects Volatility-adaptive zone width — Unlike fixed-width pivot zones or percentage-based bands, the ATR scaling ensures zones automatically widen during volatile periods and narrow during calm periods, providing contextually appropriate support and resistance areas across all market conditions. Self-managing zone lifecycle — Zones are not simply drawn and forgotten. Each zone is actively monitored, extended, and eventually invalidated when broken. The visual transition from active (colored, solid) to broken (gray, dashed) creates an intuitive map of which levels remain structurally significant. Structural pivot validation — By requiring confirmation bars on both sides of a pivot, the indicator only plots levels where price has demonstrably reversed. This eliminates the noise of minor fluctuations and focuses attention on levels where genuine supply or demand has been observed. Clean chart design with memory management — The configurable zone limit per side prevents the chart from becoming cluttered with historical levels. The oldest zones are automatically removed when new ones form, ensuring the chart always shows only the most relevant current levels. Dual breakout signaling — Breakouts are communicated through three simultaneous channels: plotted triangle markers, candle color changes, and configurable alert conditions. This multi-channel approach ensures traders never miss a breakout event regardless of how they monitor their charts. How to Use Add the Luminous Pivot S&R Matrix to your chart. It overlays directly on the price chart, displaying colored zones at detected pivot levels. Observe the colored zones — green zones represent support areas (pivot lows), and red zones represent resistance areas (pivot highs). Active zones have solid lines and colored fills; broken zones appear gray with dashed lines. Watch for breakout signals — a green triangle below a bar indicates price has closed above a resistance zone (bullish breakout), while a red triangle above a bar indicates price has closed below a support zone (bearish breakout). Breakout candles are also colored accordingly. Use active zones as potential entry areas — look for price reactions (bounces, rejections) when price approaches an active zone. Combine with candlestick patterns or other confirmation tools for higher-probability entries. Monitor zone invalidation patterns — frequent resistance breakouts suggest bullish momentum, while frequent support breakdowns suggest bearish momentum. This provides a structural view of the prevailing trend. Set up alerts using the built-in alert conditions ("Bullish Breakout" and "Bearish Breakout") to receive notifications when price breaks through an active zone, even when you are not watching the chart. Combine with volume indicators, trend filters, or momentum oscillators for additional confirmation before executing trades based on zone reactions or breakout signals. Customization Pivot Lookback (default: 15) — Controls how many bars on each side are required to confirm a pivot. Increase for major structural levels suitable for higher timeframes (20-30); decrease for more frequent pivot detection on lower timeframes (5-10). Zone ATR Multiplier (default: 0.8) — Scales the 14-period ATR to determine zone width. Increase for wider zones that capture more price reaction area (1.0-1.5); decrease for tighter, more precise zones (0.3-0.5). Max Active Zones per side (default: 5) — Limits how many support and resistance zones are displayed simultaneously. Increase if you want to see more historical context (8-15); decrease for a cleaner chart with only the most recent levels (2-3). Support / Resistance Colors — Customize the zone and signal colors to match your chart theme or personal preference. Zone Transparency (default: 85) — Controls the opacity of zone box fills and borders. Lower values make zones more prominent; higher values keep them subtle and non-distracting. Conclusion The Luminous Pivot S&R Matrix provides a methodologically rigorous approach to automated support and resistance analysis by combining structural pivot detection with volatility-adaptive zone construction and real-time breakout monitoring. By treating support and resistance as dynamic zones rather than static lines, and by automatically managing the lifecycle of each zone from creation through invalidation, this indicator eliminates the manual overhead of traditional S/R analysis while providing richer contextual information. Whether you are a day trader looking for precise intraday bounce zones, a swing trader identifying key structural levels for position entries, or a position trader monitoring major support and resistance breaks for trend confirmation, the Luminous Pivot S&R Matrix delivers a clean, self-managing, and visually intuitive framework for understanding where the market's key structural boundaries lie — and when they are being broken.
Pine Script® Indikator
von Pineify
Nadaraya-Watson Dynamic Envelopes [identityKa]Welcome to another premium-grade, free-to-use trading tool developed by identityKa. The Nadaraya-Watson Dynamic Envelopes is a highly advanced, visually smooth overlay indicator designed to capture dynamic support and resistance zones. Instead of relying on traditional, jagged moving averages, this indicator utilizes a Gaussian-inspired smoothing technique (via an optimized ALMA mathematical engine) to wrap the price action in a flowing, highly responsive channel. Whether you are a day trader looking for mean-reversion setups or a swing trader identifying macro tops and bottoms, this indicator provides crystal-clear visual guidance without cluttering your chart. 🔥 Key Features: Dynamic Smoothing Engine: Creates non-jagged, flowing upper (resistance) and lower (support) bands that adapt to market volatility. Mean Reversion Signals: Prints distinct triangle shapes (Red for Bearish, Green for Bullish) when the price action sharply interacts with the outer envelopes, highlighting high-probability reversal zones. Smart HUD Dashboard: Includes a clean, fully customizable on-chart dashboard that displays the current engine status, price position relative to the midline, and a real-time AI Suggestion (LONG, SHORT, or Dangerous) based on the algorithmic state. 100% Customizable: Every aspect of the indicator, from bandwidth smoothness and multipliers to theme colors (featuring the signature identityKa neon palette) and dashboard positioning, can be adjusted in the settings menu. 💡 How to Trade with It: Mean Reversion: Look for bullish (green) triangle signals when the price touches or pierces the lower green envelope for potential long entries. Conversely, look for bearish (red) triangle signals at the upper red envelope for short entries. Trend Continuation: In strong trending markets, the midline (white) often acts as dynamic support/resistance. Pro Tip: This indicator works best when combined with a primary trend filter (such as our Alpha SuperTrend Signal). Avoid taking reversal signals against a very strong macroeconomic trend unless confirmed by other Price Action concepts. ⚙️ Settings & Alerts: The script comes with built-in alert conditions for both Support Bounces (Bullish) and Resistance Rejections (Bearish), allowing you to automate your workflow. All settings are globally accessible in English. Elevate your chart quality. Trade with precision. Trade with identityKa.
Pine Script® Indikator
von IdentityKa
Liquidity Sweep Rider Institutional HFT Grabber Liquidity Sweep Rider Strategy (Swing Pivot + Volume Filter) Publication Description: This is an open-source Pine Script v6 strategy that identifies potential liquidity sweep patterns around confirmed swing highs and lows. It uses: Pivot points (ta.pivothigh / ta.pivotlow) to mark historical swing levels where orders (such as stops or pending entries) often cluster. A volume filter requiring above-average volume (SMA-based with multiplier) on the sweep candle to highlight stronger moves. Classic sweep logic: price wicks beyond the level but closes back inside, suggesting a possible reversal after liquidity is taken. Entry rules: Long: after a downside sweep below a recent swing low (with volume condition). Short: after an upside sweep above a recent swing high (with volume condition). Features include: Optional toggles to enable/disable long/short directions. ATR-based stop-loss and take-profit (configurable multipliers and risk-reward ratio). Visual plots for liquidity levels, entry signals, background highlights, and an info table. Alert conditions for long/short triggers. Important notes: This is an educational/example script for backtesting and learning. Past performance does not indicate future results. Trading involves significant risk of loss — use proper risk management and never risk more than you can afford to lose. No guarantees of profitability are made. Always test thoroughly on demo accounts before live use. Customize parameters (pivot lengths, volume multiplier, ATR settings) based on the instrument and timeframe you trade. Works on various markets/timeframes but performs differently depending on liquidity and volatility. Feel free to fork/modify the code. Feedback and improvements are welcome! (≈ 3–4 paragraphs, clear, educational, includes risk disclaimer, explains logic + usage without hype.)
Pine Script® Strategie
von uzair2join
Ram - Fibonacci Pivot PointsFibonacci Pivot Points — Pine Script Absolutely! Let's build this for TradingView. Here's a clean, professional Pine Script for Fibonacci Pivot Points:Created a file, read a fileCreated a file, read a fileFibonacci Pivot Points Pine Script for TradingViewfib_pivot_points.pinePresented fileDoneHere's a breakdown of what this script does: 📐 How the Levels are Calculated LevelFormulaFib RatioPP(H + L + C) / 3—R1 / S1PP ± 0.382 × Range38.2%R2 / S2PP ± 0.618 × Range61.8%R3 / S3PP ± 1.000 × Range100% ⚙️ Key Features Multi-timeframe — switch between Daily, Weekly, 4H, or 1H pivots Fully customisable — toggle R3/S3, R2/S2, R1/S1 and change colours Smart labels — show level name + exact price on the right side Zone highlight — subtle background tint when price is between R1/S1 7 built-in alerts — get notified when price crosses any level 🚀 How to Add to TradingView Open TradingView → Pine Editor (bottom panel) Paste the script and click "Add to chart" Open Settings to choose your pivot timeframe and toggle levels 💡 Trading Tips PP is your neutral line — bias is bullish above, bearish below R1/S1 are your first profit targets or reversal zones R2/S2 are high-probability bounce areas on strong trending days R3/S3 only reached on high-volatility or news-driven sessions — treat as extreme levels
Pine Script® Indikator
von helloram12
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
Pine Script® Indikator
von UAlgo
3