Começar

Pesquisar nos scripts por "fib"

HarmonicPatternTrackingLibrary "HarmonicPatternTracking" Library contains few data structures and methods for tracking harmonic pattern trades via pinescript. method draw(this)   Creates and draws HarmonicDrawing object for given HarmonicPattern   Namespace types: HarmonicPattern   Parameters:      this (HarmonicPattern) : HarmonicPattern object   Returns: current HarmonicPattern object method addTrade(this)   calculates HarmonicTrade and sets trade object for HarmonicPattern   Namespace types: HarmonicPattern   Parameters:      this (HarmonicPattern) : HarmonicPattern object   Returns: bool true if pattern trades are valid, false otherwise method delete(this)   Deletes drawing objects of HarmonicDrawing   Namespace types: HarmonicDrawing   Parameters:      this (HarmonicDrawing) : HarmonicDrawing object   Returns: current HarmonicDrawing object method delete(this)   Deletes drawings of harmonic pattern   Namespace types: HarmonicPattern   Parameters:      this (HarmonicPattern) : HarmonicPattern object   Returns: current HarmonicPattern object HarmonicDrawing   Drawing objects of Harmonic Pattern   Fields:      xa (series line) : xa line      ab (series line) : ab line      bc (series line) : bc line      cd (series line) : cd line      xb (series line) : xb line      bd (series line) : bd line      ac (series line) : ac line      xd (series line) : xd line      x (series label) : label for pivot x      a (series label) : label for pivot a      b (series label) : label for pivot b      c (series label) : label for pivot c      d (series label) : label for pivot d      xabRatio (series label) : label for XAB Ratio      abcRatio (series label) : label for ABC Ratio      bcdRatio (series label) : label for BCD Ratio      xadRatio (series label) : label for XAD Ratio HarmonicTrade   Trade tracking parameters of Harmonic Patterns   Fields:      initialEntry (series float) : initial entry when pattern first formed.      entry (series float) : trailed entry price.      initialStop (series float) : initial stop when trade first entered.      stop (series float) : current stop updated as per trailing rules.      target1 (series float) : First target value      target2 (series float) : Second target value      target3 (series float) : Third target value      target4 (series float) : Fourth target value      status (series int) : Trade status referenced as integer      retouch (series bool) : Flag to show if the price retouched after entry HarmonicProperties   Display and trade calculation properties for Harmonic Patterns   Fields:      fillMajorTriangles (series bool) : Display property used for using linefill for harmonic major triangles      fillMinorTriangles (series bool) : Display property used for using linefill for harmonic minor triangles      majorFillTransparency (series int) : transparency setting for major triangles      minorFillTransparency (series int) : transparency setting for minor triangles      showXABCD (series bool) : Display XABCD pivot labels      lblSizePivots (series string) : Pivot label size      showRatios (series bool) : Display Ratio labels      useLogScaleForScan (series bool) : Use log scale to determine fib ratios for pattern scanning      useLogScaleForTargets (series bool) : Use log scale to determine fib ratios for target calculation      base (series string) : base on which calculation of stop/targets are made.      entryRatio (series float) : fib ratio to calculate entry      stopRatio (series float) : fib ratio to calculate initial stop      target1Ratio (series float) : fib ratio to calculate first target      target2Ratio (series float) : fib ratio to calculate second target      target3Ratio (series float) : fib ratio to calculate third target      target4Ratio (series float) : fib ratio to calculate fourth target HarmonicPattern   Harmonic pattern object to track entire pattern trade life cycle   Fields:      id (series int) : Pattern Id      dir (series int) : pattern direction      x (series float) : X Pivot      a (series float) : A Pivot      b (series float) : B Pivot      c (series float) : C Pivot      d (series float) : D Pivot      xBar (series int) : Bar index of X Pivot      aBar (series int) : Bar index of A Pivot      bBar (series int) : Bar index of B Pivot      cBar (series int) : Bar index of C Pivot      dBar (series int) : Bar index of D Pivot      przStart (series float) : Start of PRZ range      przEnd (series float) : End of PRZ range      patterns (bool ) : array representing the patterns      patternLabel (series string) : string representation of list of patterns      patternColor (series color) : color assigned to pattern      properties (HarmonicProperties) : HarmonicProperties object containing display and calculation properties      trade (HarmonicTrade) : HarmonicTrade object to track trades      drawing (HarmonicDrawing) : HarmonicDrawing object to manage drawings
Biblioteca Pine Script®
por Trendoscope
3
Fibonacci Zone Study w/Candles - R3c0nTraderCredits: Thank you "eykpunter" for granting me permission to use "Fibonacci Zones" to create this study What does this do? How is it different? This study was created so it can be used with the strategy 'Fibonacci Zone DCA Strategy - R3c0nTrader' in order to generate buy/sell signals for a 3Commas bot. I was not able to use "eykpunter's" "Fibonacci Zones" to create these signals as it was missing the code for this. To create the buy or sell signal you need to be able to create an alert for when the price moves through the Fib levels. Unfortunately, the "price" is not available to be selected when creating an alert with the original study. Hence the need to create this new study and to resolve the issue. This study has overlay turned off by default so it will appear in a separate pane below your active chart. I did this so I can clearly view and separate the strategy from the study. Steps Overview: Add the study to your chart Configure the study to match the Fib length you used in the strategy. Create Alerts from the study to generate the buy or sell signals to 3Commas The below steps for creating signals are just examples! Since there are numerous ways you can open or close a trade from a signal, please do your own testing. This cannot be understated. Example of how to generate buy signals: After adding the study, select the three dots for this study and click on "Add an alert on Fibonacci Zone Study /w Candles…" Setup the condition to trigger the alert. If you want to initiate a buy when the price crosses over the top of the lower Fib zone (downtrend zone), then use the following: Condition>Fibonacci Zone Study>Price High>Crossing Up>Fibonacci Zone Study>Top-Low Fib Border Options>Once per bar Expiration>Open-ended Alert actions>Webhook URL (use the 3Commas webhook URL) Alert name>Enter a name, "BUY Paper-Fib-Bot" Message>Use the 3Commas message from the paper bot to open the trade Example of how to generate sell signals: After adding the study, select the three dots for this study and click on "Add an alert on Fibonacci Zone Study /w Candles…" Setup the condition to trigger the alert. If you want to initiate a sell when the price reaches the top of the High Fib zone (uptrend zone), then try the following: Condition>Fibonacci Zone Study>Price High>Crossing Up>Fibonacci Zone Study>Top-High Fib Border (Note: I used "Crossing Up" but "Crossing" is another option; I just haven't tested it yet with a paper bot) Options>Once per bar Expiration>Open-ended Alert actions>Webhook URL (use the 3Commas webhook URL) Alert name>Enter a name, "SELL Paper-Fib-Bot" Message>Use the 3Commas message from the paper bot to close the trade
Indicador Pine Script®
por R3c0nTrader
4
Superior-Range Bound Renko - Strategy - 11-29-25 - SignalLynxSuperior-Range Bound Renko Strategy with Advanced Risk Management Template Signal Lynx | Free Scripts supporting Automation for the Night-Shift Nation 🌙 1. Overview Welcome to Superior-Range Bound Renko (RBR) — a volatility-aware, structure-respecting swing-trading system built on top of a full Risk Management (RM) Template from Signal Lynx. Instead of relying on static lookbacks (like “14-period RSI”) or plain MA crosses, Superior RBR: Adapts its range definition to market volatility in real time Emulates Renko Bricks on a standard, time-based chart (no Renko chart type required) Uses a stack of Laguerre Filters to detect genuine impulse vs. noise Adds an Adaptive SuperTrend powered by a small k-means-style clustering routine on volatility Under the hood, this script also includes the full Signal Lynx Risk Management Engine: A state machine that separates “Signal” from “Execution” Layered exit tools: Stop Loss, Trailing Stop, Staged Take Profit, Advanced Adaptive Trailing Stop (AATS), and an RSI-style stop (RSIS) Designed for non-repainting behavior on closed candles by basing execution-critical logic on previous-bar data We are publishing this as an open-source template so traders and developers can leverage a professional-grade RM engine while integrating their own signal logic if they wish. 2. Quick Action Guide (TL;DR) Best Timeframe: 4 Hours (H4) and above. This is a high-conviction swing-trading system, not a scalper. Best Assets: Volatile instruments that still respect market structure: Bitcoin, Ethereum, Gold (XAUUSD), high-volatility Forex pairs (e.g., GBPJPY), indices with clean ranges. Strategy Type: Volatility-Adaptive Trend Following + Impulse Detection. It hunts for genuine expansion out of ranges, not tiny mean-reversion nibbles. Key Feature: Renko Emulation on time-based candles. We mathematically model Renko Bricks and overlay them on your standard chart to define: “Equilibrium” zones (inside the brick structure) “Breakout / impulse” zones (when price AND the impulse line depart from the bricks) Repainting: Designed to be non-repainting on closed candles. All RM execution logic uses confirmed historical data (no future bars, no security() lookahead). Intrabar flicker during formation is allowed, but once a bar closes the engine’s decisions are stable. Core Toggles & Filters: Enable Longs and Shorts independently Optional Weekend filter (block trades on Saturday/Sunday) Per-module toggles: Stop Loss, Trailing Stop, Staged Take Profits, AATS, RSIS 3. Detailed Report: How It Works A. The Strategy Logic: Superior RBR Superior RBR builds its entry signal from multiple mathematical layers working together. 1) Adaptive Lookback (Volatility Normalization) Instead of a fixed 100-bar or 200-bar range, the script: Computes ATR-based volatility over a user-defined period. Normalizes that volatility relative to its recent min/max. Maps the normalized value into a dynamic lookback window between a minimum and maximum (e.g., 4 to 100 bars). High Volatility: The lookback shrinks, so the system reacts faster to explosive moves. Low Volatility: The lookback expands, so the system sees a “bigger picture” and filters out chop. All the core “Range High/Low” and “Range Close High/Low” boundaries are built on top of this adaptive window. 2) Range Construction & Quick Ranges The engine constructs several nested ranges: Outer Range: rangeHighFinal – dynamic highest high rangeLowFinal – dynamic lowest low Inner Close Range: rangeCloseHighFinal – highest close rangeCloseLowFinal – lowest close Quick Ranges: “Half-length” variants of those, used to detect more responsive changes in structure and volatility. These ranges define: The macro box price is trading inside Shorter-term “pressure zones” where price is coiling before expansion 3) Renko Emulation (The Bricks) Rather than using the Renko chart type (which discards time), this script emulates Renko behavior on your normal candles: A “brick size” is defined either: As a standard percentage move, or As a volatility-driven (ATR) brick, optionally inhibited by a minimum standard size The engine tracks a base value and derives: brickUpper – top of the emulated brick brickLower – bottom of the emulated brick When price moves sufficiently beyond those levels, the brick “shifts”, and the directional memory (renkoDir) updates: renkoDir = +2 when bricks are advancing upward renkoDir = -2 when bricks are stepping downward You can think of this as a synthetic Renko tape overlaid on time-based candles: Inside the brick: equilibrium / consolidation Breaking away from the brick: momentum / expansion 4) Impulse Tracking with Laguerre Filters The script uses multiple Laguerre Filters to smooth price and brick-derived data without traditional lag. Key filters include: LagF_1 / LagF_W: Based on brick upper/lower baselines LagF_Q: Based on HLCC4 (high + low + 2×close)/4 LagF_Y / LagF_P: Complex averages combining brick structures and range averages LagF_V (Primary Impulse Line): A smooth, high-level impulse line derived from a blend of the above plus the outer ranges Conceptually: When the impulse line pushes away from the brick structure and continues in one direction, an impulse move is underway. When its direction flips and begins to roll over, the impulse is fading, hinting at mean reversion back into the range. 5) Fib-Based Structure & Swaps The system also layers in Fib levels derived from the adaptive ranges: Standard levels (12%, 23.6%, 38.2%, 50%, 61%, 76.8%, 88%) from the main range A secondary “swap” set derived from close-range dynamics (fib12Swap, fib23Swap, etc.) These Fibs are used to: Bucket price into structural zones (below 12, between 23–38, etc.) Detect breakouts when price and Laguerre move beyond key Fib thresholds Drive zSwap logic (where a secondary Fib set becomes the active structure once certain conditions are met) 6) Adaptive SuperTrend with K-Means-Style Volatility Clustering Under the hood, the script uses a small k-means-style clustering routine on ATR: ATR is measured over a fixed period The range of ATR values is split into Low, Medium, High volatility centroids Current ATR is assigned to the nearest centroid (cluster) From that, a SuperTrend variant (STK) is computed with dynamic sensitivity: In quiet markets, SuperTrend can afford to be tighter In wild markets, it widens appropriately to avoid constant whipsaw This SuperTrend-based oscillator (LagF_K and its signals) is then combined with the brick and Laguerre stack to confirm valid trend regimes. 7) Final Baseline Signals (+2 / -2) The “brain” of Superior RBR lives in the Baseline & Signal Generation block: Two composite signals are built: B1 and B2: They combine: Fib breakouts Renko direction (renkoDir) Expansion direction (expansionQuickDir) Multiple Laguerre alignments (LagF_Q, LagF_W, LagF_Y, LagF_Z, LagF_P, LagF_V) They also factor in whether Fib structures are expanding or contracting. A user toggle selects the “Baseline” signal: finalSig = B2 (default) or B1 (alternate baseline) finalSig is then filtered through the RM state machine and only when everything aligns, we emit: +2 = Long / Buy signal -2 = Short / Sell signal 0 = No new trade Those +2 / -2 values are what feed the Risk Management Engine. B. The Risk Management (RM) Engine This script features the Signal Lynx Risk Management Engine, a proprietary state machine built to separate Signal from Execution. Instead of firing orders directly on indicator conditions, we: Convert the raw signal into a clean integer (Fin = +2 / -2 / 0) Feed it into a Trade State Machine that understands: Are we flat? Are we in a long or short? Are we in a closing sequence? Should we permit re-entry now or wait? Logic Injection / Template Concept: The RM engine expects a simple integer: +2 → Buy -2 → Sell Everything else (0) is “no new trade” This makes the script a template: You can remove the Superior RBR block Drop in your own logic (RSI, MACD, price action, etc.) As long as you output +2 or -2 into the same signal channel, the RM engine can drive all exits and state transitions. Aggressive vs Conservative Modes: The input AgressiveRM (Aggressive RM) governs how we interpret signals: Conservative Mode (Aggressive RM = false): Uses a more filtered internal signal (AF) to open trades Effectively waits for a clean trend flip / confirmation before new entries Minimizes whipsaw at the cost of fewer trades Aggressive Mode (Aggressive RM = true): Reacts directly to the fresh alert (AO) pulses Allows faster re-entries in the same direction after RM-based exits Still respects your pyramiding setting; this script ships with pyramiding = 0 by default, so it will not stack multiple positions unless you change that parameter in the strategy() call. The state machine enforces discipline on top of your signal logic, reducing double-fires and signal spam. C. Advanced Exit Protocols (Layered Defense) The exit side is where this template really shines. Instead of a single “take profit or stop loss,” it uses multiple, cooperating layers. 1) Hard Stop Loss A classic percentage-based Stop Loss (SL) relative to the entry price. Acts as a final “catastrophic protection” layer for unexpected moves. 2) Standard Trailing Stop A percentage-based Trailing Stop (TS) that: Activates only after price has moved a certain percentage in your favor (tsActivation) Then trails price by a configurable percentage (ts) This is a straightforward, battle-tested trailing mechanism. 3) Staged Take Profits (Three Levels) The script supports three staged Take Profit levels (TP1, TP2, TP3): Each stage has: Activation percentage (how far price must move in your favor) Trailing amount for that stage Position percentage to close Example setup: TP1: Activate at +10% Trailing 5% Close 10% of the position TP2: Activate at +20% Trailing 10% Close another 10% TP3: Activate at +30% Trailing 5% Close the remaining 80% (“runner”) You can tailor these quantities for partial scaling out vs. letting a core position ride. 4) Advanced Adaptive Trailing Stop (AATS) AATS is a sophisticated volatility- and structure-aware stop: Uses Hirashima Sugita style levels (HSRS) to model “floors” and “ceilings” of price: Dungeon → Lower floors → Mid → Upper floors → Penthouse These levels classify where current price sits within a long-term distribution. Combines HSRS with Bollinger-style envelopes and EMAs to determine: Is price extended far into the upper structure? Is it compressed near the lower ranges? From this, it computes an adaptive factor that controls how tight or loose the trailing level (aATS / bATS) should be: High Volatility / Penthouse areas: Stop loosens to avoid getting wicked out by inevitable spikes. Low Volatility / compressed structure: Stop tightens to lock in and protect profit. AATS is designed to be the “smart last line” that responds to context instead of a single fixed percentage. 5) RSI-Style Stop (RSIS) On top of AATS, the script includes a RSI-like regime filter: A McGinley Dynamic mean of price plus ATR bands creates a dynamic channel. Crosses above the top band and below the lower band change a directional state. When enabled (UseRSIS): RSIS can confirm or veto AATS closes: For longs: A shift to bearish RSIS can force exits sooner. For shorts: A shift to bullish RSIS can do the same. This extra layer helps avoid over-reactive stops in strong trends while still respecting a regime change when it happens. D. Repainting Protection Many strategies look incredible in the Strategy Tester but fail in live trading because they rely on intrabar values or future-knowledge functions. This template is built with closed-candle realism in mind: The Risk Management logic explicitly uses previous bar data (open , high , low , close ) for the key decisions on: Trailing stop updates TP triggers SL hits RM state transitions No security() lookahead or future-bar access is used. This means: Backtest behavior is designed to match what you can actually get with TradingView alerts and live automation. Signals may “flicker” intrabar while the candle is forming (as with any strategy), but on closed candles, the RM decisions are stable and non-repainting. 4. For Developers & Modders We strongly encourage you to mod this script. To plug your own strategy into the RM engine: Look for the section titled: // BASELINE & SIGNAL GENERATION You will see composite logic building B1 and B2, and then selecting: baseSig = B2 altSig = B1 finalSig = sigSwap ? baseSig : altSig You can replace the content used to generate baseSig / altSig with your own logic, for example: RSI crosses MACD histogram flips Candle pattern detectors External condition flags Requirements are simple: Your final logic must output: 2 → Buy signal -2 → Sell signal 0 → No new trade That output flows into the RM engine via finalSig → AlertOpen → state machine → Fin. Once you wire your signals into finalSig, the entire Risk Management system (Stops, TPs, AATS, RSIS, re-entry logic, weekend filters, long/short toggles) becomes available for your custom strategy without re-inventing the wheel. This makes Superior RBR not just a strategy, but a reference architecture for serious Pine dev work. 5. About Signal Lynx Automation for the Night-Shift Nation 🌙 Signal Lynx focuses on helping traders and developers bridge the gap between indicator logic and real-world automation. The same RM engine you see here powers multiple internal systems and templates, including other public scripts like the Super-AO Strategy with Advanced Risk Management. We provide this code open source under the Mozilla Public License 2.0 (MPL-2.0) to: Demonstrate how Adaptive Logic and structured Risk Management can outperform static, one-layer indicators Give Pine Script users a battle-tested RM backbone they can reuse, remix, and extend If you are looking to automate your TradingView strategies, route signals to exchanges, or simply want safer, smarter strategy structures, please keep Signal Lynx in your search. License: Mozilla Public License 2.0 (Open Source). If you make beneficial modifications, please consider releasing them back to the community so everyone can benefit.
Estratégia Pine Script®
por SignalLynx
FibNexus [CHE]FibNexus — Auto-Fibonacci with Adaptive TrendLen + TFRSI Triggers What it is. FibNexus is a chart overlay that auto-anchors Fibonacci levels to the most relevant swing range without any manual timeframe picking. It does this by computing an adaptive trend length (“TrendLen”) from recent price behavior, then drawing retracements/extensions from the detected swing High/Low. A built-in TFRSI module adds LONG/SHORT triggers and ready-made alerts. What makes FibNexus different (the TrendLen edge) Most Fibonacci tools either (a) use fixed lookbacks or (b) force you to choose a higher reference timeframe (or a multiplier of it) and then place Fibs on those higher-TF swings. Your earlier Ultimate Fibonacci Trading Tool \ follows that higher-reference approach (auto TF, multiplier, or manual) and emphasizes custom level/label options. ( ) FibNexus flips that workflow: * It doesn’t rely on a higher timeframe or a static lookback. * Instead, it measures multiple window lengths inside the current chart timeframe and selects the one that best fits the data right now. * From that data-driven window, it automatically finds the most recent swing high & low and draws the entire Fib stack from there. * When the statistically “best” window changes, anchors update once, labels refresh cleanly, and then lines just extend to the right on each new bar. Result: No more guesswork about “which timeframe or lookback should I use?”—FibNexus adapts the anchors to market conditions and keeps the drawing noise low. How TrendLen works (transparent, deterministic) 1. Scan windows: The script evaluates a series of lookbacks (10, 20, …, 500 bars). 2. Score by correlation: For each window, it computes the correlation between price and its lagged version and picks the window with the highest correlation (the strongest, most self-consistent trend segment). 3. Anchor the swing: On a confirmed bar and only when TrendLen changes, it scans the last `TrendLen` bars to capture the highest high and lowest low and marks them with “X”. 4. Draw once, extend later: It deletes the old Fib objects, redraws the active levels from those anchors, and from then on extends the lines to the right as new bars print (no redraw spam). This makes FibNexus responsive (it adapts when the structure shifts) and quiet (it doesn’t constantly repaint Fibs). Fibonacci engine (levels, labels, direction) * Retracements: 0.000 · 0.236 · 0.382 · 0.500 · 0.618 · 0.786 · 1.000 * Extensions: 1.618 · 2.618 · 3.618 · 4.236 * Label styles: *Default* (percent + price), *None*, *Percentage*, *Price* * Label sizing: *tiny → huge* * Bull/Bear context: Direction is inferred from mid-range positioning; prices are projected accordingly (retracement vs. extension math is handled for both cases). * Selective toggles: You can show/hide any level and color it independently. Momentum & signals (TFRSI module) FibNexus embeds your TFRSI (“The Forbidden RSI \ ”) as the momentum/trigger layer. TFRSI is your open-source oscillator published on TradingView and designed for fast, normalized momentum readouts with customizable length/smoothing. ( ) * Defaults: `TFRSI length = 6`, `signal smoothing = 2` * Triggers: * LONG when TFRSI crosses up through the Long level (default 2.0) * SHORT when TFRSI crosses down through the Short level (default 98.0) * On-chart labels: Green LONG under the bar, red SHORT above the bar. * Spam control: Keep only the N most recent labels to avoid clutter. * Confirmed bars only: Signals/labels finalize at bar close to reduce flicker. Alerts (ready for TradingView) * LONG signal (TFRSI crossover) * SHORT signal (TFRSI crossunder) * TrendLen changed (anchors/Fibs recalculated) * Price crossed a Fib level (any active level) Use the provided `alertcondition(...)` entries in the TV dialog. Optionally enable instant `alert()` calls with verbose text (avoid duplicates if you also add alertconditions). Typical use-cases & playbook * Level reaction trading: In trends, watch 0.382 / 0.5 / 0.618 for reaction. A TFRSI up-cross near a retracement in an uptrend is a straightforward continuation setup; the opposite applies in downtrends. * Breakout objectives: After clearing the 1.000 line (old swing), 1.618 is a common first extension target; beyond that, 2.618/3.618/4.236 map stretch objectives. * Chop control: In range conditions, keep signals conservative (e.g., stick with the tight defaults 2.0/98.0 or raise thresholds). Always seek confluence (candlesticks, volume, HTF bias). * Less micromanagement: You don’t need to babysit timeframe selection or anchors—TrendLen recomputes only when the data say so. Inputs (by group) * Core: TFRSI length & smoothing. * Fibonacci Levels: Per-level toggles, numeric values, colors. * Fibonacci Labels: Style (percentage/price/both/none) and size. * Signals: Max number of visible LONG/SHORT labels (or 0 = off). * TFRSI Trigger: Long/Short thresholds (defaults 2.0 / 98.0). * Alerts: Master enable, per-event toggles, optional instant `alert()`. Performance & UX * Overlay indicator; efficient object handling. * Clean redraw policy: Full re-draw only when TrendLen changes; otherwise Fibs extend horizontally. * Clarity: Auto-marked swing anchors (“X”), configurable labels/colors. Credits & references * TFRSI – “The Forbidden RSI \ ” (open-source publication and description on TradingView). Used here as the momentum basis. * “Ultimate Fibonacci Trading Tool \ ” (your earlier open-source tool on TradingView). Focuses on higher-reference timeframe selection (auto/multiplier/manual) and rich labeling controls; FibNexus replaces the fixed/higher-TF anchor logic with adaptive TrendLen in the current timeframe. Risk disclaimer This indicator is for educational/information purposes only and is not financial advice. No performance guarantees; past behavior does not predict future results. Trading involves substantial risk (including total loss). Always do your own research, test on demo, use risk management, and consult a licensed advisor where appropriate. Use at your own risk. Disclaimer: The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context. Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved. By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk. Enhance your trading precision and confidence with FibNexus ! 🚀 Happy trading Chervolino
Indicador Pine Script®
por chervolino
1
Volume Forks [Trendoscope]🎲 Volume Forks - Advanced Price Analysis with Recursive Auto-Pitchfork and Angled Volume Profile The Volume Forks Indicator is a comprehensive research tool that combines two innovative techniques, Recursive Auto-Pitchfork and Angled Volume Profile . This indicator provides traders with valuable insights into price dynamics by integrating accurate pitchfork drawing and volume analysis over angled levels. The indicator does following things Detects Pitchfork formations automatically on the chart over Recursive Zigzag Instead of drawing forks based on fib levels, volume distribution over ABC of pitchfork is calculated and drawn in the direction of the handle. 🎲 Brief about Pitchfork Pitchfork is drawn when price forms ABC pattern. Pitchfork draws a series of parallel lines in the direction of trend which can be used for support and resistance. There are many methods of drawing pitchfork. In all cases, a line joining B​C  will make the base of pitchfork and fork lines are drawn from different points of the base. All the fork lines will be parallel. But, the handle of the base defines the direction of fork lines. Classification of pitchfork is mainly based on the starting and ending points of the handle. 🎲 Regular Types Here, end of the handle is always fixed and it will be the mid point of B and C. 🎯 Andrews Pitchfork Handle starts from A and joins the base at mid of B and C. Forks are drawn based on fib ratios from the handle 🎯 Schiff Pitchfork Handle starts from Bar of A and price of middle of AB and joins the base at mid of B and C Forks are drawn based on fib ratios from the handle 🎯 Modified Schiff Pitchfork Handle starts from mid of A and B and joins the base at mid of B and C Forks are drawn based on fib ratios from the handle 🎲 Inside Types Here, C will act as end of the handle which joins the Base B​C . 🎯 Andrews Pitchfork (Inside) Handle starts from A and joins the base at C Forks are drawn based on fib ratios from the handle 🎯 Schiff Pitchfork (Inside) Handle starts from Bar of A and price of (A+B)/2 and joins the base at C Forks are drawn based on fib ratios from the handle 🎯 Modified Schiff Pitchfork (Inside) Handle starts from mid of A and B and joins the base at C Forks are drawn based on fib ratios from the handle 🎲 Brief about Pitchfork The Angled Volume Profile technique expands on the concept of volume profile by measuring volume distribution levels over angled levels rather than just horizontal levels. By selecting a starting point and angle interactively, traders can assess volume distribution within specific price trends. This feature is particularly useful for analysing volume dynamics in trending markets. 🎲 Settings Indicator settings include few things which determine the scanning of pitchforks and few which determines drawing of volume profile lines. Please note that, due to pine limitations of 500 lines, if there are too many formations on the chart, volume profile may not appear correctly. If that happens, please reduce the number of volume forks per formation.
Indicador Pine Script®
por Trendoscope
19
6-9 session & levels6-9 Session & Levels - Customizable Range Analysis Indicator Description: This indicator provides comprehensive session-based range analysis designed for intraday traders. It calculates and displays key levels based on a customizable session period (default 6:00-9:00 AM ET). Core Features: Session Tracking Monitors user-defined session times with timezone support Displays session open, high, and low levels Highlights session range with optional box visualization Shows previous day RTH (Regular Trading Hours: 9:30 AM - 4:00 PM) levels Range Levels 25%, 50%, and 75% range levels within the session Range deviations at 0.5x, 1.0x, and 2.0x multiples Fibonacci extension levels (customizable, default 1.33x and 1.66x) Optional fill zones between Fibonacci levels Time Zone Highlighting Marks the 9:40-9:50 AM period as a potential reversal zone Vertical lines with shading to identify key time windows Statistical Analysis Calculates mean and median extension levels based on historical sessions Displays statistics table showing current range, average range, range difference, and z-score Customizable sample size (1-100 sessions) for statistical calculations Option to anchor extensions from either session open or high/low points Input Settings Explained: Session Settings Levels Session Time: Define your session window in HHMM-HHMM format (default: 0600-0900) Time Zone: Choose from UTC, America/New_York, America/Chicago, America/Los_Angeles, Europe/London, or Asia/Tokyo Anchor Settings Show Session Anchor: Toggle the session anchor line (marks session open price at 6:00 AM) Anchor Style/Color/Width: Customize appearance (Solid/Dashed/Dotted, color, 1-4 width) Show Anchor Label: Display price label for the anchor Session Open Line: Similar options for the session open reference line Range Box Settings Show Range Box: Display a shaded rectangle highlighting the session high-to-low range Range Box Color: Set the box background color and transparency Range Levels (25%/50%/75%) Show Range Levels: Toggle all three intermediate levels on/off Individual Level Styling: Each level (25%, 50%, 75%) has its own color, style, and width settings Show Range Level Labels: Display price labels for each level Range Deviations Show Range Deviations: Toggle deviation levels on/off 0.5x/1.0x/2.0x Settings: Each deviation multiplier can be customized with its own color, line style (Solid/Dashed/Dotted), and width Show Range Deviation Labels: Display labels showing the deviation price levels Previous Day RTH Levels Show Previous RTH Levels: Display yesterday's regular trading hours high and low RTH High/Low Styling: Separate color, style, and width settings for each level Show Previous RTH Labels: Toggle price labels for RTH levels Time Zones Show 9:40-9:50 AM Zone: Highlight this specific time period with vertical lines and shading Zone Color: Set the background fill color for the time zone Zone Label Color/Text: Customize the label appearance and text Fibonacci Extension Settings Show Fibonacci Extensions: Toggle Fib levels on/off Fib Extension Color/Style/Width: Customize line appearance Show Fib Extension Labels: Display price labels Fib Ext Level 1/2: Set custom multipliers (default 1.33 and 1.66, range 0-5 in 0.1 increments) Show Fibonacci Fills: Display shaded zones between Fib levels Fib Fill Color: Customize the fill color and transparency Session High/Low Settings Show Session High/Low Lines: Display the actual session extremes Style/Color/Width: Customize line appearance Show Labels: Toggle price labels for high/low levels Extension Stats Settings Show Statistical Levels on Chart: Display mean and median extension levels based on historical data Extension Anchor Point: Choose whether to anchor from "Open" or "High/Low" of the session Number of Sessions for Statistics: Set sample size (1-100, default 60) for calculating averages Mean/Median High Extension: Separate styling for each statistical level (color, style, width) Mean/Median Low Extension: Separate styling for downside statistical levels Tables Show Statistics Table: Display a summary table with current range, average range, difference, z-score, and sample size Table Position: Choose from 9 positions (Bottom/Middle/Top + Center/Left/Right) Table Text Size: Select from Auto, Tiny, Small, Normal, Large, or Huge Display Settings Projection Offset: Number of bars to extend lines forward (default 24) Label Size: Choose from Tiny, Small, Normal, or Large Price Decimal Precision: Set decimal places for price labels (0-6) How It Works: The indicator tracks the specified session period and calculates the session's open, high, low, and range. At the end of the session (9:00 AM by default), it projects all configured levels forward for the trading day. The statistical features analyze the last N sessions (you choose the number) to calculate typical extension behavior from either the session open or the session high/low points. The z-score calculation helps identify whether the current session's range is normal, expanded, or contracted compared to recent history, allowing traders to adjust expectations for the rest of the day. Use Case: This indicator helps traders identify key support and resistance levels based on early session price action, understand current range context relative to historical averages, and spot potential reversal zones during specific time periods. Note: This indicator is for informational purposes only and does not constitute investment advice. Always perform your own analysis before making trading decisions.
Indicador Pine Script®
por lucymatos
Hybrid Linear Regression Channel with Fibonacci LevelsHow to Use the LRC Fib Hybrid Indicator (Detailed Guide) 1. Read the Trend 2.The thick blue line is the linear regression midline. If it’s sloping upward → uptrend (favor longs). If sloping downward → downtrend (favor shorts). The gray channel bounds are ±2 standard deviations (adjustable). 3. Understand Fibonacci Levels Fib lines are projected parallel to the regression slope using the channel width as 100%: Red dashed lines (0.0 to 0.786): Support zones in uptrends. Blue dashed line (0.5): Midline/neutral. Green dashed lines (1.0 to 2.618): Resistance zones in downtrends. Strongest levels: 0.618 (support) and 1.618 (resistance). 4. Buy Signal (Long Entry) Triggered when: Midline is rising (uptrend confirmed). Price crosses above a red Fib level (0.0–0.786). Volume > 20-period average (if confirmation enabled). Action: Enter long on the green triangle (▲). Stop Loss: Below the lower gray channel or recent swing low. Take Profit: At 1.0, 1.272, or 1.618 green Fibs. 5. Sell Signal (Short Entry) Triggered when: Midline is falling (downtrend). Price crosses below a green Fib level (1.272–2.618). Volume > average. Action: Enter short on the red triangle (▼). Stop Loss: Above the upper gray channel. Take Profit: At 1.0, 0.786, or 0.618 red Fibs. 6. Use the Info Table (Bottom-Right) Shows live prices of all Fib levels, current trend ("Up"/"Down"), and signal status ("BUY"/"SELL"/"None"). 7. Customize via Settings (Gear Icon) Regression Length: 50–200 (shorter = faster response). Std Dev Multiplier: 1.5–3.0 (tighter/wider channel). Toggle Fibs: Hide unused levels to declutter. Volume Confirmation: Turn off for pure price action. 8. Set Alerts Right-click chart → Add Alert → Select "Buy Signal" or "Sell Signal" → Enable popup/email/webhook. 9. Best Practices Best in trending markets (avoid chop). Wait for volume spike on bounce. Combine with higher timeframe bias. Use 0.618/1.618 as primary reversal zones. This indicator gives you adaptive trend, precise entries, volume filter, and dynamic targets — all in one clean overlay.
Indicador Pine Script®
por TruSignal_Strategies
MSFA_LibraryLibrary "MSFA_library" TODO: add library description here getDecimals()   Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price getPipSize(multiplier)   Calculates the pip size of the current market   Parameters:      multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)   Returns: The pip size for the current market truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places   Parameters:      number (float) : The number to truncate      decimalPlaces (simple float) : (default=2) The number of decimal places to truncate to   Returns: The given number truncated to the given decimalPlaces toWhole(number)   Converts pips into whole numbers   Parameters:      number (float) : The pip number to convert into a whole number   Returns: The converted number toPips(number)   Converts whole numbers back into pips   Parameters:      number (float) : The whole number to convert into pips   Returns: The converted number getPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period   Parameters:      value1 (float) : The first value to reference      value2 (float) : The second value to reference      lookback (int) : The lookback period to analyze   Returns: The percent change over the two values and lookback period random(minRange, maxRange)   Wichmann–Hill Pseudo-Random Number Generator   Parameters:      minRange (float) : The smallest possible number (default: 0)      maxRange (float) : The largest possible number (default: 1)   Returns: A random number between minRange and maxRange bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(length, maType)   Gets a Moving Average based on type (! MUST BE CALLED ON EVERY TICK TO BE ACCURATE, don't place in scopes)   Parameters:      length (simple int) : The MA period      maType (string) : The type of MA   Returns: A moving average with the given parameters barsAboveMA(lookback, ma)   Counts how many candles are above the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to check   Returns: The bar count of how many recent bars are above the MA barsBelowMA(lookback, ma)   Counts how many candles are below the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently (based on closing prices)   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many times price recently crossed the EMA (based on closing prices) getPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      lookback (int) : The lookback period to look back over      direction (int) : The color of the bar to count (1 = Green, -1 = Red)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)      bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bullish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bearish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar()   Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar()   Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls within the given time session barOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range   Parameters:      startTime (int) : The UNIX date timestamp to begin searching from      endTime (int) : the UNIX date timestamp to stop searching from   Returns: A boolean - true if the current bar falls within the given dates dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze   Parameters:      monday (bool) : Should the script analyze this day? (true/false)      tuesday (bool) : Should the script analyze this day? (true/false)      wednesday (bool) : Should the script analyze this day? (true/false)      thursday (bool) : Should the script analyze this day? (true/false)      friday (bool) : Should the script analyze this day? (true/false)      saturday (bool) : Should the script analyze this day? (true/false)      sunday (bool) : Should the script analyze this day? (true/false)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter(atrValue, maxSize)   Parameters:      atrValue (float)      maxSize (float) tradeCount()   Calculate total trade count   Returns: Total closed trade count isLong()   Check if we're currently in a long trade   Returns: True if our position size is positive isShort()   Check if we're currently in a short trade   Returns: True if our position size is negative isFlat()   Check if we're currentlyflat   Returns: True if our position size is zero wonTrade()   Check if this bar falls after a winning trade   Returns: True if we just won a trade lostTrade()   Check if this bar falls after a losing trade   Returns: True if we just lost a trade maxDrawdownRealized()   Gets the max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).   Returns: The max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized). totalPipReturn()   Gets the total amount of pips won/lost (as a whole number)   Returns: Total amount of pips won/lost (as a whole number) longWinCount()   Count how many winning long trades we've had   Returns: Long win count shortWinCount()   Count how many winning short trades we've had   Returns: Short win count longLossCount()   Count how many losing long trades we've had   Returns: Long loss count shortLossCount()   Count how many losing short trades we've had   Returns: Short loss count breakEvenCount(allowanceTicks)   Count how many break-even trades we've had   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even count longCount()   Count how many long trades we've taken   Returns: Long trade count shortCount()   Count how many short trades we've taken   Returns: Short trade count longWinPercent()   Calculate win rate of long trades   Returns: Long win rate (0-100) shortWinPercent()   Calculate win rate of short trades   Returns: Short win rate (0-100) breakEvenPercent(allowanceTicks)   Calculate break even rate of all trades   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even win rate (0-100) averageRR()   Calculate average risk:reward   Returns: Average winning trade divided by average losing trade unitsToLots(units)   (Forex) Convert the given unit count to lots (multiples of 100,000)   Parameters:      units (float) : The units to convert into lots   Returns: Units converted to nearest lot size (as float) skipTradeMonteCarlo(chance, debug)   Checks to see if trade should be skipped to emulate rudimentary Monte Carlo simulation   Parameters:      chance (float) : The chance to skip a trade (0-1 or 0-100, function will normalize to 0-1)      debug (bool) : Whether or not to display a label informing of the trade skip   Returns: True if the trade is skipped, false if it's not skipped (idea being to include this function in entry condition validation checks) fillCell(tableID, column, row, title, value, bgcolor, txtcolor, tooltip)   This updates the given table's cell with the given values   Parameters:      tableID (table) : The table ID to update      column (int) : The column to update      row (int) : The row to update      title (string) : The title of this cell      value (string) : The value of this cell      bgcolor (color) : The background color of this cell      txtcolor (color) : The text color of this cell      tooltip (string)   Returns: Nothing.
Biblioteca Pine Script®
por hphuc0212
FA_PA_LIBLibrary "FA_PA_LIB" A collection of custom tools & utility functions commonly used for coding Dr Al Brooks, Price Action System with my scripts getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getTopWickPercent()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: Percent of total candle width that is occupied by the upper wick getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBottomWickPercent()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: Percent of total candle width that is occupied by the lower wick getBarMidPoint()   Gets the current candle's midpoint wick to wick   Returns: The current candle's mid point getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage (00.00) bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points isBr()   Checks if the current bar is a Bear Bar   Returns: A boolean - true if the current bar is bear candle isBl()   Checks if the current bar is a Bull Bar   Returns: A boolean - true if the current bar is Bull candle isTrendBar()   Checks if the current bar is a Trend Bar. Candle that its body size is greater than 50% of entire candle size   Returns: A boolean - true if the current bar is Trend candle isBlTrendBar()   Checks if the current bar is a Bull Trend Bar. Bullish candle that its body size is greater than 50% of entire candle size   Returns: A boolean - true if the current bar is Bull Trend candle isBrTrendBar()   Checks if the current bar is a Bull Trend Bar. Bullish candle that its body size is greater than 50% of entire candle size   Returns: A boolean - true if the current bar is Bull Trend candle isBlRevB()   Checks if the current bar is a Bull Reversal Bar. Bullish candle that closes on upper half of candle body   Returns: A boolean - true if the current bar is Bull Reversal candle isBrRevB()   Checks if the current bar is a Bear Reversal Bar. BulBearish candle that closes on lower half of candle body   Returns: A boolean - true if the current bar is Bear Reversal candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)      bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=true) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isBlOB()   Detects Bullish outside bars(OB)   Returns: Returns true if the current bar is a bull outside bar isBrOB()   Detects Bearish outside bars(OB)   Returns: Returns true if the current bar is a bear outside bar
Biblioteca Pine Script®
por Alireza_PH
Visible and Anchored OTE chart [SYNC & TRADE]Thanks for the start @twingall Visible and Anchored OTE chart Indicator for visualizing price levels and optimal trading zones (OTE - Optimal Trading Entry) using Fibonacci levels. Main features Visualization of price ranges using two OTE zones: OTE 70% (79-62 Fibonacci levels) OTE 30% (21-38 Fibonacci levels) Setting up time periods: Ability to use a custom date range Option to work with a higher time frame Flexible display settings: Choose between using candle bodies or the full range for binding Customizable appearance of OTE boxes Customizable text labels Additional levels: Middle line (50.5%) Optional levels of 29.5%, 70.5% and 88% Customizable Fibonacci extensions Indicator settings Main parameters Use Custom Dates - enable a custom date range Start Date/End Date - set a time range Use Higher Timeframe - use a higher time frame Higher Timeframe - select a higher timeframe Setting up OTE zones Show Fib Box - displaying OTE zones Enable Fib Box 79-62 - enabling OTE zone 70% Enable Fib Box 21-38 - enabling OTE zone 30% Show Text - displaying text labels in zones Visual design Text Size - text size (tiny/small/medium/large) Text Color - text color Text Alignment - text alignment Line Thickness - line thickness (1-4) Line Style - line style (Solid/Dashed/Dotted) Fibonacci levels High/Low Lines - displaying extreme levels Midline - displaying the middle line (50.5%) Show 29.5 Line - additional level 29.5% Show 70.5 Line - additional level 70.5% Show 88 Line - additional level 88% Extensions Fibonacci There are 6 customizable extension levels available: Ext#1 (default 1.0) Ext#2 (default 1.27) Ext#3 (default 1.62) Ext#4 (default 2.0) Ext#5 (default 2.62) Ext#6 (default 3.62) For each level, you can configure: On/Off Color Meaning Alerts The indicator provides the following types of alerts: Entering/Exiting OTE Zones: Entering 70% OTE Zone Exiting 70% OTE Zone Entering 30% OTE Zone Exiting 30% OTE Zone Crossing Additional Levels: Crossing 29.5% Level Crossing 70.5% Level Crossing 88% Level Reaching Extension Levels Fibonacci: Alerts for each configured extension level Support for both positive and negative extensions Usage Add the indicator to the chart Configure the required display parameters Set alerts if necessary Use OTE zones to identify potential entry points into the market Notes The indicator automatically updates when the visible area of ​​the chart changes When using a custom date range, make sure the selected period contains data For correct operation with a higher time frame, make sure that historical data is available Visible and Anchored OTE chart Индикатор для визуализации ценовых уровней и зон оптимальной торговли (OTE - Optimal Trading Entry) с использованием уровней Фибоначчи. Основные возможности Визуализация ценовых диапазонов с помощью двух OTE зон: OTE 70% (79-62 уровни Фибоначчи) OTE 30% (21-38 уровни Фибоначчи) Настройка временных периодов: Возможность использования пользовательского диапазона дат Опция работы с высшим таймфреймом Гибкая настройка отображения: Выбор между использованием тел свечей или полного диапазона для привязки Настраиваемый внешний вид боксов OTE Настраиваемые текстовые метки Дополнительные уровни: Средняя линия (50.5%) Опциональные уровни 29.5%, 70.5% и 88% Настраиваемые расширения Фибоначчи Настройка индикатора Основные параметры Use Custom Dates - включение пользовательского диапазона дат Start Date/End Date - установка временного диапазона Use Higher Timeframe - использование высшего таймфрейма Higher Timeframe - выбор высшего таймфрейма Настройка OTE зон Show Fib Box - отображение зон OTE Enable Fib Box 79-62 - включение зоны OTE 70% Enable Fib Box 21-38 - включение зоны OTE 30% Show Text - отображение текстовых меток в зонах Визуальное оформление Text Size - размер текста (tiny/small/medium/large) Text Color - цвет текста Text Alignment - выравнивание текста Line Thickness - толщина линий (1-4) Line Style - стиль линий (Solid/Dashed/Dotted) Уровни Фибоначчи High/Low Lines - отображение крайних уровней Midline - отображение средней линии (50.5%) Show 29.5 Line - дополнительный уровень 29.5% Show 70.5 Line - дополнительный уровень 70.5% Show 88 Line - дополнительный уровень 88% Расширения Фибоначчи Доступно 6 настраиваемых уровней расширения: Ext#1 (по умолчанию 1.0) Ext#2 (по умолчанию 1.27) Ext#3 (по умолчанию 1.62) Ext#4 (по умолчанию 2.0) Ext#5 (по умолчанию 2.62) Ext#6 (по умолчанию 3.62) Для каждого уровня можно настроить: Включение/выключение Цвет Значение Оповещения Индикатор предоставляет следующие типы оповещений: Вход/выход из зон OTE: Вход в зону OTE 70% Выход из зоны OTE 70% Вход в зону OTE 30% Выход из зоны OTE 30% Пересечение дополнительных уровней: Пересечение уровня 29.5% Пересечение уровня 70.5% Пересечение уровня 88% Достижение уровней расширения Фибоначчи: Оповещения для каждого настроенного уровня расширения Поддержка как положительных, так и отрицательных расширений Использование Добавьте индикатор на график Настройте необходимые параметры отображения При необходимости установите оповещения Используйте зоны OTE для определения потенциальных точек входа в рынок Примечания Индикатор автоматически обновляется при изменении видимой области графика При использовании пользовательского диапазона дат убедитесь, что выбранный период содержит данные Для корректной работы с высшим таймфреймом убедитесь в доступности исторических данных
Indicador Pine Script®
por SYNC-AND-TRADE
4
JordanSwindenLibraryLibrary "JordanSwindenLibrary" TODO: add library description here getDecimals()   Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price getPipSize(multiplier)   Calculates the pip size of the current market   Parameters:      multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)   Returns: The pip size for the current market truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places   Parameters:      number (float) : The number to truncate      decimalPlaces (simple float) : (default=2) The number of decimal places to truncate to   Returns: The given number truncated to the given decimalPlaces toWhole(number)   Converts pips into whole numbers   Parameters:      number (float) : The pip number to convert into a whole number   Returns: The converted number toPips(number)   Converts whole numbers back into pips   Parameters:      number (float) : The whole number to convert into pips   Returns: The converted number getPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period   Parameters:      value1 (float) : The first value to reference      value2 (float) : The second value to reference      lookback (int) : The lookback period to analyze   Returns: The percent change over the two values and lookback period random(minRange, maxRange)   Wichmann–Hill Pseudo-Random Number Generator   Parameters:      minRange (float) : The smallest possible number (default: 0)      maxRange (float) : The largest possible number (default: 1)   Returns: A random number between minRange and maxRange bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(length, maType)   Gets a Moving Average based on type (! MUST BE CALLED ON EVERY TICK TO BE ACCURATE, don't place in scopes)   Parameters:      length (simple int) : The MA period      maType (string) : The type of MA   Returns: A moving average with the given parameters barsAboveMA(lookback, ma)   Counts how many candles are above the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to check   Returns: The bar count of how many recent bars are above the MA barsBelowMA(lookback, ma)   Counts how many candles are below the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently (based on closing prices)   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many times price recently crossed the EMA (based on closing prices) getPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      lookback (int) : The lookback period to look back over      direction (int) : The color of the bar to count (1 = Green, -1 = Red)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)      bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bullish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bearish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar()   Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar()   Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls within the given time session barOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range   Parameters:      startTime (int) : The UNIX date timestamp to begin searching from      endTime (int) : the UNIX date timestamp to stop searching from   Returns: A boolean - true if the current bar falls within the given dates dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze   Parameters:      monday (bool) : Should the script analyze this day? (true/false)      tuesday (bool) : Should the script analyze this day? (true/false)      wednesday (bool) : Should the script analyze this day? (true/false)      thursday (bool) : Should the script analyze this day? (true/false)      friday (bool) : Should the script analyze this day? (true/false)      saturday (bool) : Should the script analyze this day? (true/false)      sunday (bool) : Should the script analyze this day? (true/false)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter(atrValue, maxSize)   Parameters:      atrValue (float)      maxSize (float) tradeCount()   Calculate total trade count   Returns: Total closed trade count isLong()   Check if we're currently in a long trade   Returns: True if our position size is positive isShort()   Check if we're currently in a short trade   Returns: True if our position size is negative isFlat()   Check if we're currentlyflat   Returns: True if our position size is zero wonTrade()   Check if this bar falls after a winning trade   Returns: True if we just won a trade lostTrade()   Check if this bar falls after a losing trade   Returns: True if we just lost a trade maxDrawdownRealized()   Gets the max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).   Returns: The max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized). totalPipReturn()   Gets the total amount of pips won/lost (as a whole number)   Returns: Total amount of pips won/lost (as a whole number) longWinCount()   Count how many winning long trades we've had   Returns: Long win count shortWinCount()   Count how many winning short trades we've had   Returns: Short win count longLossCount()   Count how many losing long trades we've had   Returns: Long loss count shortLossCount()   Count how many losing short trades we've had   Returns: Short loss count breakEvenCount(allowanceTicks)   Count how many break-even trades we've had   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even count longCount()   Count how many long trades we've taken   Returns: Long trade count shortCount()   Count how many short trades we've taken   Returns: Short trade count longWinPercent()   Calculate win rate of long trades   Returns: Long win rate (0-100) shortWinPercent()   Calculate win rate of short trades   Returns: Short win rate (0-100) breakEvenPercent(allowanceTicks)   Calculate break even rate of all trades   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even win rate (0-100) averageRR()   Calculate average risk:reward   Returns: Average winning trade divided by average losing trade unitsToLots(units)   (Forex) Convert the given unit count to lots (multiples of 100,000)   Parameters:      units (float) : The units to convert into lots   Returns: Units converted to nearest lot size (as float) getFxPositionSize(balance, risk, stopLossPips, fxRate, lots)   (Forex) Calculate fixed-fractional position size based on given parameters   Parameters:      balance (float) : The account balance      risk (float) : The % risk (whole number)      stopLossPips (float) : Pip distance to base risk on      fxRate (float) : The conversion currency rate (more info below in library documentation)      lots (bool) : Whether or not to return the position size in lots rather than units (true by default)   Returns: Units/lots to enter into "qty=" parameter of strategy entry function EXAMPLE USAGE: string conversionCurrencyPair = (strategy.account_currency == syminfo.currency ? syminfo.tickerid : strategy.account_currency + syminfo.currency) float fx_rate = request.security(conversionCurrencyPair, timeframe.period, close ) if (longCondition) strategy.entry("Long", strategy.long, qty=zen.getFxPositionSize(strategy.equity, 1, stopLossPipsWholeNumber, fx_rate, true)) skipTradeMonteCarlo(chance, debug)   Checks to see if trade should be skipped to emulate rudimentary Monte Carlo simulation   Parameters:      chance (float) : The chance to skip a trade (0-1 or 0-100, function will normalize to 0-1)      debug (bool) : Whether or not to display a label informing of the trade skip   Returns: True if the trade is skipped, false if it's not skipped (idea being to include this function in entry condition validation checks) fillCell(tableID, column, row, title, value, bgcolor, txtcolor, tooltip)   This updates the given table's cell with the given values   Parameters:      tableID (table) : The table ID to update      column (int) : The column to update      row (int) : The row to update      title (string) : The title of this cell      value (string) : The value of this cell      bgcolor (color) : The background color of this cell      txtcolor (color) : The text color of this cell      tooltip (string)   Returns: Nothing.
Biblioteca Pine Script®
por jordanswinden
Opening Range Gap + Std Dev [starclique]The ICT Opening Range Gap is a concept taught by Inner Circle Trader and is discussed in the videos: 'One Trading Setup For Life' and 2023 ICT Mentorship - Opening Range Gap Repricing Macro ORGs, or Opening Range Gaps, are gaps that form only on the Regular Trading Hours chart. The Regular Trading Hours gap occurs between 16:15 PM - 9:29 AM EST (UTC-4) These times are considered overnight trading, so it is useful to filter the PA (price action) formed there. The RTH option is only available for futures contracts and continuous futures from CME Group. To change your chart to RTH, first things first, make sure you’re looking at a futures contract for an asset class, then on the bottom right of your chart, you’ll see ETH (by default) - Click on that, and change it to RTH. Now your charts are filtering the price action that happened overnight. To draw out your gap, use the Close of the 4:14 PM candle and the open of the 9:30 AM candle. How is this concept useful? Well, It can be used in many ways. --- How To Use The ORG One of the ways you can use the opening range gap is simply as support and resistance If we extend out the ORG from the example above, we can see that there is a clean retest of the opening range gap high after breaking structure to the upside and showing acceptance outside of the gap after consolidating within it. The ORG High (4:14 Candle Close in this case) was used as support. We then see an expansion to the upside. Another way to implement the ORG is by using it as a draw on liquidity (magnet for price) In this example, if we looked to the left, there was a huge ORG to the downside, leaving a massive gap. The market will want to rebalance that gap during the regular trading hours. The market rallies higher, rejects, comes down to clear the current days ORG low, then closes. That is one example of how you can combine liquidity & ICT market structure concepts with Opening Range Gaps to create a story in the charts. Now let’s discuss standard deviations. --- Standard Deviations Standard Deviations are essentially projection levels for ranges / POIs (Point of Interests) By this I mean, if you have a range, and you would like to see where it could potentially expand to, you’d place your fibonacci retracement tool on and high and low of the range, then use extension levels to find specific price points where price might reject from. Since 0 and 1 are your Range High and Low respectively, your projection levels would be something like 1.5, 2, 2.5, and 3, for the extension from your 1 Fib Level, and -0.5, -1, -1.5, and -2 for your 0 Fib level. The -1 and 2 level produce a 1:1 projection of your range low and high, meaning, if you expect price to expand as much as it did from the range low to range high, then you can project a -1 and 2 on your Fib, and it would show you what ICT calls “symmetrical price” Now, how are standard deviations relevant here? Well, if you’ve been paying attention to ICT’s recent videos, you would’ve caught that he’s recently started using Standard Deviation levels on breakers. So my brain got going while watching his video on ORGs, and I decided to place the fib on the ORG high and low and see what it’d produce. The results were very interesting. Using this same example, if we place our fib on the ORG High and Low, and add some projection levels, we can see that we rejected right at the -2 Standard Deviation Level. --- You can see that I also marked out the EQ (Equilibrium, 50%, 0.5 of Fib) of the ORG. This is because we can use this level as a take profit level if we’re using an old ORG as our draw. In days like these, where the gap formed was within a consolidation, and it continued to consolidate within the ORG zone that we extended, we can use the EQ in the same way we’d use an EQ for a range. If it’s showing acceptance above the EQ, we are bullish, and expect the high of the ORG to be tapped, and vice versa. --- Using The Indicator Here’s where our indicator comes in play. To avoid having to do all this work of zooming in and marking out the close and open of the respective ORG candles, we created the Opening Range Gap + Standard Deviations Indicator, with the help of our dedicated Star Clique coder, a1tmaniac. With the ORG + STD DEV indicator, you will be able to view ORG’s and their projections on the ETH (Electronic Trading Hours) chart. --- Features Range Box - Change the color of your Opening Range Gap to your liking - Enable or disable the box from appearing using the checkbox Range Midline - Change the color of your Opening Range Gap Equilibrium - Enable or disable the midline from appearing using the checkbox Std. Dev - Add whichever standard deviation levels you’d like. - By default, the indicator comes with 0.5, 1, 1.5, and 2 standard deviation levels. - Ensure that you add a comma ( , ) in between each standard deviation level - Enable or disable the standard deviations from appearing using the opacity of the color (change to 0%) Labels / Offset - Adjust the offset of the label for the Standard Deviations - Enable or disable the Labels from appearing using the checkbox Time - Adjust the time used for the indicators range - If you’d like to use this for a Session or ICT Killzone instead, adjust the time - Adjust the timezone used for the time referenced - Options are UTC, US (UTC-4, New York Local Time) or UK (UTC+1, London Time) - By default, the indicator is set to US
Indicador Pine Script®
por fytte
9
Zazzamira 50-25-25 Trend System Alerts OnlyPublishing my trading system script. It consist of several conditions to happen in order to open a trade. Work best on ES/MES 5 minute timeframe. I like to use it with this settings: - UTC -6 (don't tick Exchange Timezone) and rest as default To enter a trade, the following conditions must be met: Entry 1: the opening range (8:30AM - 9:15AM UTC-6) must be defined and the price must close above or below the opening range on the 5-minute timeframe. This entry condition defines the trade direction (above = long / below = short). Once the opening range is defined, the Trend-Based Fib Extension is applied from the range high to the range low (and vice versa). Fib levels are required for Exit conditions. Entry 2: the 8 - 27 - 67 - 97 EMAs must be defined. If the EMAs value order is 8 > 27 > 67 > 97, long-only trades are allowed. If the EMAs value order is 8 < 27 < 67 < 97, short-only trades are allowed. This entry condition filters fake breakouts of Entry 1. Entry 3: no trades are allowed after 12:59 UTC-6 (2PM EST). Entry 4: if Entry 1, Entry 2, and Entry 3 conditions are valid and the price hasn't reached the 23.6% Fib line, an entry order can be set at the range high/long with 4 contracts. To exit a trade, the following conditions must be met: Exit 1 (Stop loss): set a trailing stop based on 2.1x ATR (14) from entry. Exit 2: take 50% profits at the 23.6% Fib and leave trailing stop untouched. Exit 3: if Exit 2 triggers, take 50% (25% of total entry) off at 61.8% Fib, leaving Exit 2 trailing stop values valid. Exit 4: exit the full position at the FIB 100% value. Exit 5: all trades must be closed at 3pm UTC-6 (4PM EST). So basically Take Profit are 50%-25%-25% of position. Code has been written by © Hiubris_Indicators who has been an amazing coder and gave me the possibility to make this script public so a really big shoutout to him. This indicator only works for alerts, please check version without alerts to backtest or tweaks. This indicator is meant to be used to automate the system via webhooks
Indicador Pine Script®
por philipbianchi
Zazzamira 50-25-25 Trend SystemPublishing my trading system script. It consist of several conditions to happen in order to open a trade. Work best on ES/MES 5 minute timeframe. I like to use it with this settings: - UTC -6 (don't tick Exchange Timezone) and rest as default To enter a trade, the following conditions must be met: Entry 1: the opening range (8:30AM - 9:15AM UTC-6) must be defined and the price must close above or below the opening range on the 5-minute timeframe. This entry condition defines the trade direction (above = long / below = short). Once the opening range is defined, the Trend-Based Fib Extension is applied from the range high to the range low (and vice versa). Fib levels are required for Exit conditions. Entry 2: the 8 - 27 - 67 - 97 EMAs must be defined. If the EMAs value order is 8 > 27 > 67 > 97, long-only trades are allowed. If the EMAs value order is 8 < 27 < 67 < 97, short-only trades are allowed. This entry condition filters fake breakouts of Entry 1. Entry 3: no trades are allowed after 12:59 UTC-6 (2PM EST). Entry 4: if Entry 1, Entry 2, and Entry 3 conditions are valid and the price hasn't reached the 23.6% Fib line, an entry order can be set at the range high/long with 4 contracts. To exit a trade, the following conditions must be met: Exit 1 (Stop loss): set a trailing stop based on 2.1x ATR (14) from entry. Exit 2: take 50% profits at the 23.6% Fib and leave trailing stop untouched. Exit 3: if Exit 2 triggers, take 50% (25% of total entry) off at 61.8% Fib, leaving Exit 2 trailing stop values valid. Exit 4: exit the full position at the FIB 100% value. Exit 5: all trades must be closed at 3pm UTC-6 (4PM EST). So basically Take Profit are 50%-25%-25% of position. Code has been written by © Hiubris_Indicators who has been an amazing coder and gave me the possibility to make this script public so a really big shoutout to him.
Estratégia Pine Script®
por philipbianchi
8
Fibonacci Bollinger Band ClusterThis indicator creates moving averages based on Fibonacci numbers (3-233, divided by 10 to average) sourced by high, low, and ohlc4 and plots lines based on these three. The Fib MA High line is either green or red (Fib High < Close), the Fib MA Low line is either lime or orange (Fib Low < Close), and the Fib MA OHLC4 line is constantly white. A cluster or series of Bollinger Bands is then created using the Fib MA OHLC4 line as the basis. Fibonacci-based deviations (1, 2, 3, 5, 8) are then used to create three upper and three lower Bollinger lines.
Indicador Pine Script®
por LeafAlgo
1
AbdulLibraryLibrary "AbdulLibrary" The library consists of three sections: Technical Analysis Functions - A collection of tools commonly used by day traders Trading Setup Filters Functions - A number of filters that help day traders to screen trading signals Candlestick Pattern Detection Functions - To detect different candlestick patterns that are used in day trading setups Note that this would have been possible without the help of @ZenAndTheArtOfTrading as I build-up this library after completing his pine script mastery course so big thanks to him The content of the library are:- fibLevels(preDayClose, preDayHigh, preDayLow) Calculates Daily Pivot Point and Fibonacci Key Levels   Parameters:      preDayClose : The previous day candle close      preDayHigh : The previous day candle high      preDayLow : The previous day candle low   Returns: Returns Daily Pivot Point and Fibonacci Key Levels as a tuple bullishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bullish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bullish move bearishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bearish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bearish move getCandleSize() Calculates the size of candle (high - low) in points   Returns: Returns candle size in points getCandleBodySize() Calculates the size of candle (close - open) in points   Returns: Returns candle body size in points getHighWickSize() Calculates the high wick size of candle in points   Returns: Returns The high wick size of candle in points getLowWickSize() Calculates the low wick size of candle in points   Returns: Returns The low wick size of candle in points getBodyPercentage() Calculates the candle body size as % of overall candle size   Returns: Returns The candle body size as % of overall candle size isSwingHigh(period) Checks if the price has created new swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the current candle or the previous candle is a swing high isSwingLow(period) Checks if the price has created new swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the current candle or the previous candle is a swing low isDojiSwingHigh(period) Checks if a doji is a swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the doji is a swing high isDojiSwingLow(period) Checks if a doji is a swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the doji is a swing low isBigBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has big body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is big isSmallBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has small body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is small isHammer(fibLevel, colorMatch) Checks if a candle is a hammer based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be green   Returns: Returns Boolean - True if the candle setup is hammer isShootingStar(fibLevel, colorMatch) Checks if a candle is a shooting star based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be red   Returns: Returns Boolean - True if the candle setup is star isBullEngCan(allowance, period) Check if a candle is a bullish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing low check   Returns: Boolean - True only if the candle is a bullish engulfing candle isBearEngCan(allowance, period) Check if a candle is a bearish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing high check   Returns: Boolean - True only if the candle is a bearish engulfing candle isBullDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bullish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is green   Returns: Boolean - True if the candle is a bullish doji isBearDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bearish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is red   Returns: Boolean - True if the candle is a bearish doji isBullOutBar() Check if a candle is a bullish outside bar   Returns: Boolean - True if the candle is a bullish outside bar isInsideBar() Check if a candle is an inside bar   Returns: Returns Boolean - True if a candle is an inside bar
Biblioteca Pine Script®
por Abdul_Saif
1
[MF] Auto Fibonacci LevelsDescription: Automatically draw Fibonacci Pivot levels based on the previous (day's, week's or month's) Range ( High-Low ). The HLC3 is used as the default Pivot level. Unlike the "Auto Fibonacci Levels", this variation does not update Levels on current day even if the price goes past the R3/S3 levels. Timeframes: 1D, 1W, 1M Range = (High - Low) - From previous Day, Week or month. FIB LEVELS: - Yellow = Pivot and Pivot Zone (HLC3 by default) - red = R1,S1 Levels 0.236 * Range - Green = R2,S2 Levels 0.368 * Range - Lime = R3,S3 Levels 0.618 * Range - Blue = R4,S4 Levels 0.786 * Range - Gray = R5,S5 Levels 1.000 * Range - Lime = R6,S6 Levels 1.236 * Range - Red = R7,S7 Levels 1.382 * Range - Blue = R8,S8 Levels 1.618 * Range - Green = R9,S9 Levels 2.000 * Range CLASSIC LEVELS: - Yellow = Pivot and Pivot Zone (HLC3) - Green = R1,S1 Levels (Pivot*2 - Low), (Pivot*2 - High) - Lime = R2,S2 Levels ( Pivot + Range), ( Pivot - Range) - Lime = R3,S3 Levels (High + 2*( Pivot - Low)), (Low - 2*(High - Pivot )) - Blue = R4,S4 Levels (High + 3*( Pivot - Low)), (Low - 3*(High - Pivot )) Refrences: - Auto Daily Fib Levels R3.0 by JustUncleL - Auto Fib by TheYangGuizi - Monthly Dynamic Range Levels (Fibonaci) V0 by RicardoSantos Modifications: - Added next FIB Levels. (changes during the current cycle) - Added FIB 0.236 Levels - Added Option to change the colors of the Fib Levels - Changed Default colors to the colors of Tradingview - Upgraded to Version4 Pinescript
Indicador Pine Script®
por MF_Crypto
14
Fibonacci LevelsThe 420 VWMA (Volume Weighted Moving Average) per period selected of the low price (Fib 0) and the high price (Fib 1). They are labeled in Color of the line they represent. The other Fib lines are calculated using common fib ratios as follows: longRange_fib2618 = highestHighperLongRange + (highestHighperLongRange - lowestLowperLongRange) * 1.618 longRange_fib1618 = highestHighperLongRange + (highestHighperLongRange - lowestLowperLongRange) * .618 longRange_fib786 = highestHighperLongRange - (highestHighperLongRange - lowestLowperLongRange) * 0.236 longRange_fib618 = highestHighperLongRange - (highestHighperLongRange - lowestLowperLongRange) * 0.382 longRange_fib50 = highestHighperLongRange - (highestHighperLongRange - lowestLowperLongRange) * 0.500 longRange_fib382 = highestHighperLongRange - (highestHighperLongRange - lowestLowperLongRange) * 0.618 longRange_fib236 = highestHighperLongRange - (highestHighperLongRange - lowestLowperLongRange) * 0.764 Those lines are drawn and labeled to right of chart The 2 heavy whites and the short range of the Fib1 (Top) and Fib0 (Bottom). Eyes on chart when it approaches one those two points. This is where I look for continuation or reversal patterns, especially near a Longterm Fib The Red, Green, Yellow and Blue are colored ratio lines that I am experimenting with and will later combine with a multiple time frames to show discernable patterns of potential near future movements. The prices interacts with the fib lines and each of the the colored ratio lines as you go from small to larger time frames. I will be publishing this soon to allow the community to improve on it.
Indicador Pine Script®
por BoneFunkenstein
7
Std Dev Channel [fmb]What it is A professional regression channel that combines standard deviation divisions, an extreme price envelope, and a trend quality gauge. It is designed for fast read-and-act decisions on any timeframe, with sensible presets and log-space math for instruments that trend exponentially. Why it’s different Most channels draw fixed ±1σ and ±2σ around a regression line. This tool adds: - Fibonacci-spaced σ divisions for precise scaling - An objective MaxEnvelope of actual extremes with optional 1.272 and 1.618 extensions - Pearson’s R labelling that classifies the trend as Strong Up, Moderate, Weak, or Strong Down - A log-space option so channels behave correctly on long trends and high beta charts How it works Base line - Linear regression of the last Length bars, drawn as a ray. - Optional colour change by regime using Pearson’s R. Divisions (StdDev or MaxEnvelope) - StdDev basis: σ of residuals around the regression line. - MaxEnvelope basis: distances from the base line to the farthest highs and lows in the lookback. - Divisions can be Fibonacci multiples (0.382, 0.618, 1.000, 1.272 by default) or uniform steps. Outer rails - ENV 1.0 touches the farthest highs and lows within the window. - Optional extensions at 1.272 and 1.618 highlight stretch and breakout zones. Trend quality (Pearson’s R) - R is computed on the same series and window. - Default thresholds: Strong when |R| ≥ 0.70, Weak when |R| < 0.40. - The label reads: R 0.XXX • Class, plotted near the most recent base value. Log-space math - When enabled, the model runs on ln(price) and converts the outputs back to price. - Safer on multi-year charts and large percentage trends. Presets - Swing: Length 125, StdDev basis, Fib divisions, ENV 1.0 and 1.272 on - Intraday: Length 240, StdDev basis, simple ±1 and ±2 style divisions, ENV off by default - Position: Length 200, StdDev basis, compact Fib set for higher timeframes You can turn preset overrides off to make every input respond instantly. Inputs you will actually use - Length, Source, Log-space ON or OFF - Basis: StdDev or MaxEnvelope - Divisions: Fib list or Step and Max multiple - Outer rails: show ENV 1.0, show 1.272, show 1.618 - Labels and sizes, extend left or right - Hide divisions or outer rails automatically when the regime is Weak Alerts included - Close crosses above or below ENV 1.0 - Close crosses above or below ENV 1.272 and 1.618 (if enabled) Practical playbook Trend following - In Strong Uptrend: buy pullbacks near 0.382 to 0.618 above the base with stops just beyond the next lower division. - In Strong Downtrend: sell bounces into 0.382 to 0.618 below the base with stops just beyond the next upper division. Mean reversion - When R is Moderate or Weak, fade moves that tag ENV 1.0 back toward the base. - If price closes through an ENV extension, treat it as potential regime change and stand down on fades. Breakouts - A close through ENV 1.0 with R rising toward Strong often precedes trend acceleration. - Use the next division or the 1.272 rail as the first target and trail on the base. Tips - Keep Length stable across symbols you compare. Consistency beats curve fitting. - Use log-space on multi-year equities and crypto. Use linear for short intraday work. - If you want a classic look, disable Fib and rails, set Step 1.0 and Max 2.0. Notes - The tool draws more lines when Fib divisions are active. If it feels busy, show divisions only and hide labels, or keep ENV 1.0 plus one extension. - Pearson’s R is descriptive, not predictive. Combine with price structure and volume for entries.
Indicador Pine Script®
por Fullymobile
5
Fibonacci Projection with Volume & Delta Profile (Zeiierman)█ Overview Fibonacci Projection with Volume & Delta Profile (Zeiierman) blends classic Fibonacci swing analysis with modern volume-flow reading to create a unified, projection-based market framework. The indicator automatically detects the latest swing high and swing low, builds a complete Fibonacci structure, and then projects future extension targets with clear visual pathways. What makes this tool unique is the integration of two volume-based systems directly into the Fibonacci structure. A Fib-aligned Volume Profile shows how bullish and bearish volume accumulated inside the swing range, while a separate Delta Profile reveals the imbalance of buy–sell pressure inside each Fibonacci interval. Together, these elements transform the standard Fibonacci tool into a multi-dimensional structural and volume-flow map. █ How It Works The indicator first detects the most recent swing high and swing low using the Period setting. That swing defines the Fibonacci range, from which the script draws retracement levels (0.236–0.786) and builds a forward projection path using the chosen Projection Level and a 1.272 extension. Along this path, it draws projection lines, target boxes, and percentage labels that show how far each projected leg extends relative to the previous one. Inside the same swing range, the script builds a Fib-based Volume Profile by splitting price into rows and assigning each bar’s volume as bullish (close > open) or bearish (close ≤ open). On top of that, it calculates a Volume Delta Profile between each pair of fib levels, showing whether buyers or sellers dominated that band and how strong that imbalance was. █ How to Use This tool helps traders quickly understand market structure and where the price may be heading next. The projection engine shows the most likely future targets, highlights strong or weak legs in the move, and updates automatically whenever a new swing forms. This ensures you always see the most relevant and up-to-date projection path. The Fib Volume Profile shows where volume supported the move and where it did not. Thick bullish buckets reveal zones where buyers stepped in aggressively, often becoming retestable support. Thick bearish buckets highlight zones of resistance or rejection, particularly useful if projected levels align with prior liquidity. The Delta Profile adds a second dimension to volume reading by showing where buy–sell pressure was truly imbalanced. A projected Fibonacci target that aligns with a strong bullish delta, for example, may suggest continuation. A projection into a band dominated by bearish delta may warn of reversal or hesitation. █ Settings Period – bars used to determine swing high/low Projection Level – chosen Fib ratio for projection path ----------------- Disclaimer The content provided in my scripts, indicators, ideas, algorithms, and systems is for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or a solicitation to buy or sell any financial instruments. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information. All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
Indicador Pine Script®
por Zeiierman
44
Fibonacci Retrace + 50 EMA Hariss 369This indicator combines 3 concepts: Fibonacci retracement zones 50 EMA trend filter Price interaction with specific Fib zones to generate Buy/Sell signals Let’s break everything down in simple language. 1. Fibonacci Retracement Logic The script finds: Most recent swing high Most recent swing low Using these two points, it draws Fibonacci levels: Fibonacci Levels Used Level Meaning Calculation 0% Swing Low recentLow 38.2% Light retracement high - (range × 0.382) 50% Mid retracement high - (range × 0.50) 61.8% Deep retracement high - (range × 0.618) 100% Swing High recentHigh 🔍 Why only these levels? Because trading signals are generated based ONLY on:38.2%, 50%,61.8% These 3 levels define the golden retracement zones. 2. Trend Filter — 50 EMA A powerful rule: Trend Up (bullish) ➡️ Price > 50 EMA Trend Down (bearish) ➡️ Price < 50 EMA This prevents signals against the main trend. 3. BUY Conditions (Retracement + EMA) A BUY signal appears when: Price is above the 50 EMA (trend is up) Price retraces into the BUY ZONE: 🔵 BUY ZONE = between 50% and 38.2% Fibonacci i.e.,close >= Fib50 AND close <= Fib38.2 This means: Market is trending up Price corrected to a healthy retracement level Buyers are stepping back in 📘 Why this zone? This is a moderate retracement (not too shallow, not too deep). Smart money often enters at 38.2%–50% in a strong trend. 📘 BUY Signal Appears With: Green “BUY” label Green arrow below the candle 4. SELL Conditions (Retracement + EMA) A SELL signal appears when: Price is below the 50 EMA (trend is down) Price retraces upward into the SELL ZONE: 🔴 SELL ZONE = between 50% and 61.8% Fibonacci i.e.,close <= Fib50 AND close >= Fib61.8 This means: Market is trending down Price made a pullback Sellers regain control in the golden zone 📘 Why this zone? 50–61.8 retracement is the ideal bearish pullback level. 📘 SELL Signal Appears With: Red “SELL” label Red arrow above the candle 5. STOP-LOSS (SL) RULES For BUY trades, Place SL below 61.8% level.SL = Fib 61.8% OR more safe:SL = swing low (Fib 0%) For SELL trades Place SL above 38.2% level.SL = Fib 38.2% OR conservative: SL = swing high (Fib 100%) 6. TAKE-PROFIT (TP) RULES Based on common Fibonacci extensions. BUY Trade TP Options TP Level Meaning TP1 Return to 38.2% Quick scalping target TP2 Return to swing high Full trend target TP3 Breakout above swing high Trend continuation Practical suggestion: TP1 = 1× risk TP2 = 2× risk TP3 = trailing stop SELL Trade TP Options TP Level Meaning TP1 Return to 61.8% Moderate bounce TP2 Return to swing low Trend target TP3 Break below swing low Trend continuation 7. Recommended Trading Plan (Simple) BUY PLAN Price > 50 EMA (uptrend) Enter at BUY signal in 38.2–50% zone SL at 61.8% TP at swing high or structure break SELL PLAN Price < 50 EMA (downtrend) Enter at SELL signal in 50–61.8% zone SL above 38.2% TP at swing low 🟩 Summary (Very Easy to Remember) 🔵 BUY Trend: above 50 EMA Zone: between 50% and 38.2% SL: below 61.8% TP: swing high 🔴 SELL Trend: below 50 EMA Zone: between 50% and 61.8% SL: above 38.2% TP: swing low
Indicador Pine Script®
por Hariss369
Auto Fibonacci RetraceNOTE: This script is for educational purposes only. This Pine Script v6 indicator automates the drawing of Fibonacci retracement levels on a TradingView chart based on detected pivot highs and lows. It's designed to identify the most recent swing points in a price trend and plot horizontal lines at standard Fibonacci ratios (0%, 23.6%, 38.2%, 50%, 61.8%, 78.6%, 100%), along with optional labels for each level. The script is useful for traders who want dynamic, hands-free Fib retracements that update as new pivots form, helping to spot potential support/resistance zones without manual intervention. Key Features Automatic Pivot Detection: Uses TradingView's built-in ta.pivothigh and ta.pivotlow functions to find recent swing highs and lows. The sensitivity is adjustable via user inputs for "Left Bars" and "Right Bars" (default: 5 each), which define how many bars are checked on either side to confirm a pivot. Trend Direction Awareness: Determines if the current swing is an uptrend (recent high after low) or downtrend (recent low after high) and orients the Fib levels accordingly—starting from the low in uptrends or high in downtrends. Dynamic Drawing: Plots dashed horizontal lines extending to the right of the chart for each Fib level. Colors are predefined for visual distinction (e.g., blue for 23.6%, orange for 61.8%). Lines and labels are cleared and redrawn only when a new pivot is detected or on initial load to prevent chart clutter. Customizable Labels: Optional labels show the percentage (e.g., "61.8%") and can be positioned on the "Left" (at the swing start) or "Right" (pinned to the current bar, updating dynamically). Labels use semi-transparent backgrounds for readability. Performance Optimizations: Uses arrays to manage lines and labels efficiently, with reverse-indexed loops for safe deletion. The max_bars_back=500 ensures it handles historical data without excessive computation. User Inputs: Left/Right Bars: Tune pivot detection (higher values for major trends, lower for shorter swings). Show Fib Levels/Labels: Toggle visibility. Label Position: "Left" or "Right" for placement flexibility. Usage Instructions Adding to Chart: Copy-paste into TradingView's Pine Editor, save as a new indicator, and add it to your chart via the "Indicators" menu. Customization: Adjust inputs in the indicator settings panel. For example, set Left/Right Bars to 10 for daily charts in strong trends. Best Practices: Use on trending markets (e.g., stocks, forex, crypto like BTC/USD); avoid choppy sideways action. Combine with other indicators (e.g., RSI for overbought/oversold confirmation) for better trade signals. Test on historical data—zoom out to see how it redraws on past swings. Limitations: Relies on pivot functions, so it may lag slightly (pivots confirm after "Right Bars"). Not a trading strategy—use for analysis only. No alerts built-in, but you can add alertcondition if extending it. Potential Enhancements: Add extensions (e.g., 161.8%), user-defined levels, or alerts on price touches via simple modifications. This script provides a clean, efficient way to visualize Fib retracements automatically, saving time compared to manual drawing. If you need further tweaks or integration into a full strategy, let me know!
Indicador Pine Script®
por wonderfulRiceafb80
Kootch EMA MapKootch EMA overlays the 200 EMA from M1, M5, M15, M30, H1, H4, and D1 on any chart so you always see where higher and lower-timeframe trend gravity actually is. It also builds an optional Fib channel between the most extreme MTF 200 EMAs (min/max), giving you clean intrachannel targets and confluence zones. What it does • Plots seven 200 EMAs (M1 → D1) simultaneously via MTF pulls • Color/weight hierarchy: thicker lines = higher timeframe (clear priority) • Right-edge TF tags (M1, M5, … D1) so you know exactly what you’re looking at • Optional Fib levels between min/max MTF 200 EMAs (0 → 1 band) for entries, adds, and take-profit scaling Why traders use it • Immediate read on trend alignment vs. chop across timeframes • Mean-reversion & continuation cues when price stretches from/returns to key EMAs • Level stacking: use M30/H1/H4/D1 as bias, trade entries around lower-TF reactions Inputs • EMA Length (default 200) • Label offset (push tags off the last bar) • Show Fib channel toggle + color control How I use it • Bias from D1/H4/H1; execution from M5/M15. • Fade or follow at Fib 0.382 / 0.618 inside the EMA envelope; scale out near Fib 1.0 into HTF EMAs. • Skip trades when EMAs are braided and distances are compressed. Notes • Works on any symbol/timeframe; all TF EMAs are requested explicitly. • This is a map, not a crystal ball: combine with your playbook (structure breaks, FVGs, liquidity, volume).
Indicador Pine Script®
por cjkootch
2