Get started

Chart patterns

Gold Scalping Basic+This script is the "Basic+ Gold Scalping Strategy," specifically designed for scalping XAUUSD on the 5-minute chart. It combines smart indicator filters with price action logic to help traders identify high-probability entries and exits. The strategy is based on market structure, trend bias, and momentum confirmation, making it ideal for short-term traders who want clarity in fast-moving gold markets. Key Features: Trend-based entry signals using price action Indicator filters to avoid false setups Works best in volatile conditions Optimized for 5M timeframe Includes visual signals for buy/sell zones
Pine Script® indicator
by malilalit21
Volume-Powered S/R TraderThis advanced TradingView indicator combines volume analysis, dynamic support/resistance levels, and technical indicators to identify high-probability trading opportunities. It focuses on detecting institutional-level activity through volume spikes at key price levels. Key Components Volume Analysis Engine Tracks volume spikes (150%+ of 20-period average) Color-coded volume bars: Green: Bullish volume spike (high volume + bullish candle) Red: Bearish volume spike (high volume + bearish candle) Dynamic Support/Resistance System Auto-detects swing points using pivot high/low Maintains rolling arrays of: Support Levels (green semi-transparent lines) Resistance Levels (red semi-transparent lines) Displays only the 5 most recent levels for clarity Trend Analysis 50-period EMA trend filter RSI momentum indicator (14-period) Trend direction classification: Bullish: EMA rising Bearish: EMA falling
Pine Script® indicator
by haseebsh2871
Multi EMA + VWAP LevelsThis script combines the power of Exponential Moving Averages (EMAs) and VWAPs to give you a clear view of market trends, momentum, and institutional value zones — all in one simple visual layout. 📈 What It Includes: ✅ 4 customizable EMAs: EMA 20 (Green) – Short-term trend EMA 50 (Orange) – Mid-term support/resistance EMA 150 (Red) – Longer trend confirmation EMA 200 (White) – Institutional level trend direction ✅ 3 VWAPs with toggle control: Daily VWAP (Purple) – Intraday institutional average Weekly VWAP (Teal) – Swing-trader reference Monthly VWAP (Fuchsia) – Macro value zone 🎯 How to Use: Follow the trend with EMAs — when aligned, trend strength is confirmed. Use VWAPs as dynamic support/resistance and value areas. Avoid chasing price — wait for retests near EMAs or VWAP zones. Combine this with price action or volume signals for precision entries. 💡 Ideal For: Day traders Swing traders Anyone looking to identify key dynamic levels for better entries/exits
Pine Script® indicator
by OliveOne
Mickey's BBMickey's BB – Smart Reversal Detector with SL Tracking 🔁 This indicator combines the power of Bollinger Bands with engulfing candle patterns to identify high-probability reversal points. ✅ Buy Signal: Triggered when a red candle touches the lower Bollinger Band and is engulfed by a green candle within the next few candles. ✅ Sell Signal: Triggered when a green candle touches the upper Bollinger Band and is engulfed by a red candle within the next few candles. ✅ Smart Lookahead: Scans up to X candles ahead (user-defined) to confirm engulfing reversals — reducing noise in sideways markets. ✅ Dynamic Stop-Loss & Target: Automatically plots SL/TP levels based on user-defined % thresholds. ✅ SL HIT Labels: Highlights exactly when a stop-loss is breached, giving clear visual feedback on trade failures. ✅ Adaptive Market Filter: Signals are only shown when Bollinger Band width exceeds a minimum threshold — filtering out weak/noise signals in low volatility. 🔍 Ideal for reversal traders, scalpers, and those who love combining price action with volatility-based setups. 🛠️ Customizable Parameters: SMA Period & Std Dev Multiplier (for BB) SL/Target % levels Engulf Lookahead range Minimum BB width to filter signals 🎯 Build it into your strategy, set alerts, or just use it visually to time your entries and exits with clarity.
Pine Script® indicator
by MihitThakkar
4
PunkAlgo Oscillator [1.0]//@version=5 indicator(title='PunkAlgo Oscillator ', shorttitle='Punk Oscillator') n1 = input(4, 'Channel Length') n2 = input(15, 'Average Length') obLevel1 = input(88, 'Over Bought Level 1') obLevel2 = input(81, 'Over Bought Level 2') osLevel1 = input(-83, 'Over Sold Level 1') osLevel2 = input(-76, 'Over Sold Level 2') ap = hlc3 esa = ta.ema(ap, n1) d = ta.ema(math.abs(ap - esa), n1) ci = (ap - esa) / (0.015 * d) tci = ta.ema(ci, n2) wt1 = tci wt2 = ta.sma(wt1, 4) var indbot=0 var indtop=0 if wt1 > wt2 and wt1 < wt2 indbot := bar_index if wt1 < wt2 and wt1 > wt2 indtop := bar_index bott = bar_index - indbot topp = bar_index - indtop // Histogram lookbackPeriod = input(35, "Lookback Period") // Calculate the percentage change in price for each bar priceChange = close - close priceChangePercentage = priceChange / close * 100 // Calculate the average volume over the lookback period averageVolume = ta.ema(volume, lookbackPeriod) // Initialize the counters for upward and downward trends upwardTrends = 0 downwardTrends = 0 // Iterate over the lookback period and count the number of upward and downward trends for i = 1 to lookbackPeriod if priceChangePercentage > 0 upwardTrends := upwardTrends + 1 else if priceChangePercentage < 0 downwardTrends := downwardTrends + 1 // Calculate the probabilities of upward, downward, and neutral trends totalTrends = upwardTrends + downwardTrends probabilityUpward = math.round(upwardTrends / totalTrends, 2) * 100 probabilityDownward = math.round(downwardTrends / totalTrends, 2) * 100 // Determine the probability trend based on the probabilities probabilityTrend = "" if probabilityUpward > probabilityDownward probabilityTrend := "Upward" else if probabilityUpward < probabilityDownward probabilityTrend := "Downward" // Calculate the oscillator value based on the difference between upward and downward trends oscillatorValue = probabilityUpward - probabilityDownward // Determine the histogram color based on the difference between the oscillator value and zero line histogramColor = oscillatorValue >= 0 ? (oscillatorValue < oscillatorValue ? color.new(#089981, 50) : color.new(#089981, 50)) : (oscillatorValue < oscillatorValue ? color.new(#f23645, 50) : color.new(#f23645, 50)) // Smoothning the Histogram smooth_hist = input.bool(true, "Smoothen Histogram", inline="smooth_hist") smoothning_scale = input.int(defval=3, title="", minval=1, maxval=10, step=1, inline="smooth_hist") smooth_len = smoothning_scale * 2 smooth_hist_val = smooth_hist ? ta.ema(oscillatorValue, smooth_len) : oscillatorValue // Plot the histogram plot(smooth_hist_val, color=histogramColor, style=plot.style_area, linewidth=1, title="Probability Histogram") // Histogram plot(0, color=color.new(#787b86, 100)) top1 = plot(obLevel1, color=color.new(#4caf4f, 100)) top2 = plot(osLevel1, color=color.new(#ff5252, 100)) bottom1 = plot(obLevel2, color=color.new(#4caf4f, 100)) bottom2 = plot(osLevel2, color=color.new(#ff5252, 100)) fill(plot1=top1, plot2=bottom1, color=wt2 > 0 and (wt1 - wt2) > 0 ? #089981 : wt2 > 0 or (wt1 - wt2) > 0 ?color.new(#363a45, 60) : color.new(#363a45, 70)) fill(plot1=top2, plot2=bottom2, color=wt2 < 0 and (wt1 - wt2) < 0 ? #f23645 : wt2 < 0 or (wt1 - wt2) < 0 ? color.new(#363a45, 60) : color.new(#363a45, 70)) plot1 = plot(wt1, color=wt1 > wt2 ? color.new(color.green, 0) : color.gray ,title="Signal") plot2 = plot(wt2, color=color.new(#ff5252, 100),title="Signal Dots") fill(plot1=plot1, plot2=plot2, color=wt1 > wt2 ? color.rgb(8, 153, 129, 80) : color.rgb(120, 123, 134, 80),title="Signal Shadow") plot(ta.cross(wt1, wt2) ? wt2 : na, color=color.new(color.black, 0), style=plot.style_circles, linewidth=3,title="Dot Shadows") plot(ta.cross(wt1, wt2) ? wt2 : na, color=wt2 - wt1 > 0 ? color.gray : color.green , style=plot.style_circles, linewidth=2) // Divergences Module tsi1 = wt1 tsi2 = ta.sma(wt2, 4) long = n1 short = n2 signal22 = n2 price = hlc3 src2 = hlc3 src = hlc3 input_src = tsi1 // Divergences Options up = ta.rma(math.max(ta.change(src), 0), short) down = ta.rma(-math.min(ta.change(src), 0), short) lbR = input(title='Divergence Pivot Lookback Right', defval=1) lbL = input(title='Divergence Pivot Lookback Left', defval=5) rangeUpper = input(title='Max of Lookback Range', defval=100) rangeLower = input(title='Min of Lookback Range', defval=2) plotBull = input(title='Plot Bullish', defval=true) plotHiddenBull = input(title='Plot Hidden Bullish', defval=false) plotBear = input(title='Plot Bearish', defval=true) plotHiddenBear = input(title='Plot Hidden Bearish', defval=false) bearColor = color.new(#f23645, 10) bullColor = color.new(#2157f3, 10) hiddenBullColor = color.new(color.aqua, 0) hiddenBearColor = color.new(color.orange, 0) textColor = color.new(color.white, 0) noneColor = color.new(color.white, 100) osc = tsi1 plFound = na(ta.pivotlow(osc, lbL, lbR)) ? false : true phFound = na(ta.pivothigh(osc, lbL, lbR)) ? false : true _inRange(cond) => bars = ta.barssince(cond == true) rangeLower <= bars and bars <= rangeUpper //------------------------------------------------------------------------------ // Regular Bullish // Osc: Higher Low oscHL = osc > ta.valuewhen(plFound, osc , 1) and _inRange(plFound ) // Price: Lower Low priceLL = low < ta.valuewhen(plFound, low , 1) bullCond = plotBull and priceLL and oscHL and plFound plot(plFound ? osc : na, offset=-lbR, title='Regular Bullish', linewidth=1, color=bullCond ? bullColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Hidden Bullish // Osc: Lower Low oscLL = osc < ta.valuewhen(plFound, osc , 1) and _inRange(plFound ) // Price: Higher Low priceHL = low > ta.valuewhen(plFound, low , 1) hiddenBullCond = plotHiddenBull and priceHL and oscLL and plFound plot(plFound ? osc : na, offset=-lbR, title='Hidden Bullish', linewidth=1, color=hiddenBullCond ? hiddenBullColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Regular Bearish // Osc: Lower High oscLH = osc < ta.valuewhen(phFound, osc , 1) and _inRange(phFound ) // Price: Higher High priceHH = high > ta.valuewhen(phFound, high , 1) bearCond = plotBear and priceHH and oscLH and phFound plot(phFound ? osc : na, offset=-lbR, title='Regular Bearish', linewidth=1, color=bearCond ? bearColor : noneColor, transp=0) //------------------------------------------------------------------------------ // Hidden Bearish // Osc: Higher High oscHH = osc > ta.valuewhen(phFound, osc , 1) and _inRange(phFound ) // Price: Lower High priceLH = high < ta.valuewhen(phFound, high , 1) hiddenBearCond = plotHiddenBear and priceLH and oscHH and phFound plot(phFound ? osc : na, offset=-lbR, title='Hidden Bearish', linewidth=1, color=hiddenBearCond ? hiddenBearColor : noneColor, transp=0) // Signals Module string TT_HARSI = 'Period for the RSI calculations used to generate the' + 'candles. This seperate from the RSI plot/histogram length.' string TT_PBIAS = 'Smoothing feature for the OPEN of the HARSI candles.' + ' Increases bias toward the prior open value which can' + ' help provide better visualisation of trend strength.' + ' ** By changing the Open values, High and Low can also' + ' be distorted - however Close will remain unchanged.' string TT_SMRSI = 'This option smoothes the RSI in a manner similar to HA' + ' open, but uses the realtime rsi rather than the prior' + ' close value.' string TT_STOCH = 'Uses the RSI generated by the above settings, and as such' + ' will be affected by the smoothing option.' string TT_STFIT = 'Adjusts the vertical scaling of the stochastic, can help' + ' to prevent distortion of other data in the channel.' + ' Has no impact cross conditions.' //////////////////////////////////////////////////////////////////////////////// // // // ====== INPUTS ====== // // // //////////////////////////////////////////////////////////////////////////////// // -- Candle config string GROUP_CAND = 'Config » HARSI Candles' i_lenHARSI = input.int(10, 'Length', group=GROUP_CAND, minval=1, tooltip=TT_HARSI) i_smoothing = input.int(5, 'Open Smoothing', group=GROUP_CAND, minval=1, maxval=100, tooltip=TT_PBIAS) string INLINE_COL = 'Colour Pallette' i_colUp = input.color(color.teal, 'Colour Pallette  ', group=GROUP_CAND, inline=INLINE_COL) i_colDown = input.color(color.red, ' ', group=GROUP_CAND, inline=INLINE_COL) i_colWick = input.color(color.gray, ' ', group=GROUP_CAND, inline=INLINE_COL) // -- RSI plot config string GROUP_PLOT = 'Config » RSI Plot' i_source = input.source(ohlc4, 'Source', group=GROUP_PLOT) i_lenRSI = input.int(7, 'Length', group=GROUP_PLOT, minval=1) i_mode = input.bool(true, 'Smoothed Mode RSI?', group=GROUP_PLOT, tooltip=TT_SMRSI) i_showPlot = input.bool(true, 'Show RSI Plot?', group=GROUP_PLOT) i_showHist = input.bool(true, 'Show RSI Histogram?', group=GROUP_PLOT) // -- Channel OB/OS config string GROUP_CHAN = 'Config » OB/OS Boundaries' i_upper = input.int(50, 'OB', group=GROUP_CHAN, inline='OB', minval=1, maxval=50) i_upperx = input.int(30, 'OB Extreme', group=GROUP_CHAN, inline='OB', minval=1, maxval=50) i_lower = input.int(-50, 'OS', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1) i_lowerx = input.int(-30, 'OS Extreme', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1) // Settins // WaveTrend wwttShow = input(false, title='Show WaveTrend') wwttBuyShow = input(true, title='Show Buy dots') wwttGoldShow = input(true, title='Show Gold dots') wwttSellShow = input(true, title='Show Sell dots') wwttDivShow = input(true, title='Show Div. dots') vwapShow = input(true, title='Show Fast wwtt') wwttChannelLen = input(9, title='wwtt Channel Length') wwttAverageLen = input(12, title='wwtt Average Length') wwttMASource = input(hlc3, title='wwtt MA Source') wwttMALen = input(3, title='wwtt MA Length') // WaveTrend Overbought & Oversold lines OOBBLevel = input(53, title='wwtt Overbought Level 1') OOBBLevel2 = input(60, title='wwtt Overbought Level 2') OOBBLevel3 = input(100, title='wwtt Overbought Level 3') oosLevel = input(-53, title='wwtt Oversold Level 1') oosLevel2 = input(-60, title='wwtt Oversold Level 2') oosLevel3 = input(-75, title='wwtt Oversold Level 3') // Divergence wwtt wwttShowDiv = input(true, title='Show wwtt Regular Divergences') wwttShowHiddenDiv = input(false, title='Show wwtt Hidden Divergences') showHiddenDiv_nl = input(true, title='Not apply OB/OS Limits on Hidden Divergences') wwttDivOOBBLevel = input(45, title='wwtt Bearish Divergence min') wwttDivoosLevel = input(-65, title='wwtt Bullish Divergence min') // Divergence extra range wwttDivOOBBLevel_addshow = input(true, title='Show 2nd wwtt Regular Divergences') wwttDivOOBBLevel_add = input(15, title='wwtt 2nd Bearish Divergence') wwttDivoosLevel_add = input(-40, title='wwtt 2nd Bullish Divergence 15 min') // RSI+MFI rsiMFIShow = input(true, title='Show MFI') rsiMFIperiod = input(60, title='MFI Period') rsiMFIMultiplier = input.float(150, title='MFI Area multiplier') rsiMFIPosY = input(2.5, title='MFI Area Y Pos') // RSI rsiShow = input(false, title='Show RSI') rsiSRC = input(close, title='RSI Source') rsiLen = input(14, title='RSI Length') rsiOversold = input.int(30, title='RSI Oversold', minval=29, maxval=100) rsiOverbought = input.int(60, title='RSI Overbought', minval=0, maxval=60) // Divergence RSI rsiShowDiv = input(false, title='Show RSI Regular Divergences') rsiShowHiddenDiv = input(false, title='Show RSI Hidden Divergences') rsiDivOOBBLevel = input(60, title='RSI Bearish Divergence min') rsiDivoosLevel = input(30, title='RSI Bullish Divergence min') // Colors colorRed = #ff0000 colorPurple = #e600e6 colorGreen = #3fff00 colorOrange = #e2a400 colorYellow = #ffe500 colorWhite = #ffffff colorPink = #ff00f0 colorBluelight = #31c0ff colorwwtt1 = #49536195 colorwwtt2 = #7b9fd596 colorwwtt2_ = #131722 colormacdwwtt1a = #4caf58 colormacdwwtt1b = #af4c4c colormacdwwtt1c = #7ee57e colormacdwwtt1d = #ff3535 colormacdwwtt2a = #305630 colormacdwwtt2b = #310101 colormacdwwtt2c = #132213 colormacdwwtt2d = #770000 //////////////////////////////////////////////////////////////////////////////// // // // ====== FUNCTIONS ====== // // // //////////////////////////////////////////////////////////////////////////////// // FUNCTIONS // zero median rsi helper function, just subtracts 50. f_zrsi(_source, _length) => ta.rsi(_source, _length) - 50 // zero median stoch helper function, subtracts 50 and includes % scaling f_zstoch(_source, _length, _smooth, _scale) => float _zstoch = ta.stoch(_source, _source, _source, _length) - 50 float _smoothed = ta.sma(_zstoch, _smooth) float _scaled = _smoothed / 100 * _scale _scaled // mode selectable rsi function for standard, or smoothed output f_rsi(_source, _length, _mode) => // get base rsi float _zrsi = f_zrsi(_source, _length) // smoothing in a manner similar to HA open, but rather using the realtime // rsi in place of the prior close value. var float _smoothed = na _smoothed := na(_smoothed ) ? _zrsi : (_smoothed + _zrsi) / 2 // return the requested mode _mode ? _smoothed : _zrsi // RSI Heikin-Ashi generation function f_rsiHeikinAshi(_length) => // get close rsi float _closeRSI = f_zrsi(close, _length) // emulate "open" simply by taking the previous close rsi value float _openRSI = nz(_closeRSI , _closeRSI) // the high and low are tricky, because unlike "high" and "low" by // themselves, the RSI results can overlap each other. So first we just go // ahead and get the raw results for high and low, and then.. float _highRSI_raw = f_zrsi(high, _length) float _lowRSI_raw = f_zrsi(low, _length) // ..make sure we use the highest for high, and lowest for low float _highRSI = math.max(_highRSI_raw, _lowRSI_raw) float _lowRSI = math.min(_highRSI_raw, _lowRSI_raw) // ha calculation for close float _close = (_openRSI + _highRSI + _lowRSI + _closeRSI) / 4 // ha calculation for open, standard, and smoothed/lagged var float _open = na _open := na(_open ) ? (_openRSI + _closeRSI) / 2 : (_open * i_smoothing + _close ) / (i_smoothing + 1) // ha high and low min-max selections float _high = math.max(_highRSI, math.max(_open, _close)) float _low = math.min(_lowRSI, math.min(_open, _close)) // return the OHLC values // Divergences f_top_fractal(src) => src < src and src < src and src > src and src > src f_bot_fractal(src) => src > src and src > src and src < src and src < src f_fractalize(src) => f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0 f_findDivs(src, topLimit, botLimit, useLimits) => fractalTop = f_fractalize(src) > 0 and (useLimits ? src >= topLimit : true) ? src : na fractalBot = f_fractalize(src) < 0 and (useLimits ? src <= botLimit : true) ? src : na highPrev = ta.valuewhen(fractalTop, src , 0) highPrice = ta.valuewhen(fractalTop, high , 0) lowPrev = ta.valuewhen(fractalBot, src , 0) lowPrice = ta.valuewhen(fractalBot, low , 0) bearSignal = fractalTop and high > highPrice and src < highPrev bullSignal = fractalBot and low < lowPrice and src > lowPrev bearDivHidden = fractalTop and high < highPrice and src > highPrev bullDivHidden = fractalBot and low > lowPrice and src < lowPrev // RSI+MFI f_rsimfi(_period, _multiplier, _tf) => request.security(syminfo.tickerid, _tf, ta.sma((close - open) / (high - low) * _multiplier, _period) - rsiMFIPosY) // WaveTrend f_wavetrend(src, chlen, avg, malen, tf) => tfsrc = request.security(syminfo.tickerid, tf, src) esa = ta.ema(tfsrc, chlen) de = ta.ema(math.abs(tfsrc - esa), chlen) ci = (tfsrc - esa) / (0.015 * de) wwtt1 = request.security(syminfo.tickerid, tf, ta.ema(ci, avg)) wwtt2 = request.security(syminfo.tickerid, tf, ta.sma(wwtt1, malen)) wwttVwap = wwtt1 - wwtt2 wwttOversold = wwtt2 <= oosLevel wwttOverbought = wwtt2 >= OOBBLevel wwttCross = ta.cross(wwtt1, wwtt2) wwttCrossUp = wwtt2 - wwtt1 <= 0 wwttCrossDown = wwtt2 - wwtt1 >= 0 wwttCrosslast = ta.cross(wwtt1 , wwtt2 ) wwttCrossUplast = wwtt2 - wwtt1 <= 0 wwttCrossDownlast = wwtt2 - wwtt1 >= 0 // MACD f_macd(src, fastlen, slowlen, sigsmooth, tf) => fast_ma = request.security(syminfo.tickerid, tf, ta.ema(src, fastlen)) slow_ma = request.security(syminfo.tickerid, tf, ta.ema(src, slowlen)) macd = fast_ma - slow_ma signal = request.security(syminfo.tickerid, tf, ta.sma(macd, sigsmooth)) hist = macd - signal // Get higher timeframe candle f_getTFCandle(_tf) => _open = request.security(ticker.heikinashi(syminfo.tickerid), _tf, open, barmerge.gaps_off, barmerge.lookahead_on) _close = request.security(ticker.heikinashi(syminfo.tickerid), _tf, close, barmerge.gaps_off, barmerge.lookahead_on) _high = request.security(ticker.heikinashi(syminfo.tickerid), _tf, high, barmerge.gaps_off, barmerge.lookahead_on) _low = request.security(ticker.heikinashi(syminfo.tickerid), _tf, low, barmerge.gaps_off, barmerge.lookahead_on) hl2 = (_high + _low) / 2.0 newBar = ta.change(_open) candleBodyDir = _close > _open //////////////////////////////////////////////////////////////////////////////// // // // ====== SERIES, LINES and LABELS ====== // // // //////////////////////////////////////////////////////////////////////////////// // CALCULATE INDICATORS { // RSI rsi = ta.rsi(rsiSRC, rsiLen) rsiColor = rsi <= rsiOversold ? colorGreen : rsi >= rsiOverbought ? colorRed : colorPurple // Calculates WaveTrend = f_wavetrend(wwttMASource, wwttChannelLen, wwttAverageLen, wwttMALen, timeframe.period) // wwtt Divergences = f_findDivs(wwtt2, wwttDivOOBBLevel, wwttDivoosLevel, true) = f_findDivs(wwtt2, wwttDivOOBBLevel_add, wwttDivoosLevel_add, true) = f_findDivs(wwtt2, 0, 0, false) wwttBearDivHidden_ = showHiddenDiv_nl ? wwttBearDivHidden_nl : wwttBearDivHidden wwttBullDivHidden_ = showHiddenDiv_nl ? wwttBullDivHidden_nl : wwttBullDivHidden wwttBearDivColor = wwttShowDiv and wwttBearDiv or wwttShowHiddenDiv and wwttBearDivHidden_ ? colorRed : na wwttBullDivColor = wwttShowDiv and wwttBullDiv or wwttShowHiddenDiv and wwttBullDivHidden_ ? colorGreen : na wwttBearDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBearDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBearDivHidden_add ? #9a0202 : na wwttBullDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBullDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBullDivHidden_add ? #1b5e20 : na // RSI Divergences = f_findDivs(rsi, rsiDivOOBBLevel, rsiDivoosLevel, true) = f_findDivs(rsi, 0, 0, false) rsiBearDivHidden_ = showHiddenDiv_nl ? rsiBearDivHidden_nl : rsiBearDivHidden rsiBullDivHidden_ = showHiddenDiv_nl ? rsiBullDivHidden_nl : rsiBullDivHidden rsiBearDivColor = rsiShowDiv and rsiBearDiv or rsiShowHiddenDiv and rsiBearDivHidden_ ? colorRed : na rsiBullDivColor = rsiShowDiv and rsiBullDiv or rsiShowHiddenDiv and rsiBullDivHidden_ ? colorGreen : na // Buy signal. buySignal = wwttCross and wwttCrossUp and wwttOversold buySignalDiv = wwttShowDiv and wwttBullDiv or wwttShowDiv and wwttBullDiv_add or rsiShowDiv and rsiBullDiv buySignalDiv_color = wwttBullDiv ? colorGreen : wwttBullDiv_add ? color.new(colorGreen, 60) : rsiShowDiv ? colorGreen : na // Sell signal sellSignal = wwttCross and wwttCrossDown and wwttOverbought sellSignalDiv = wwttShowDiv and wwttBearDiv or wwttShowDiv and wwttBearDiv_add or rsiShowDiv and rsiBearDiv sellSignalDiv_color = wwttBearDiv ? colorRed : wwttBearDiv_add ? color.new(colorRed, 60) : rsiBearDiv ? colorRed : na // standard, or ha smoothed rsi for the line plot and/or histogram float RSI = f_rsi(i_source, i_lenRSI, i_mode) // get OHLC values to use in the plotcandle() = f_rsiHeikinAshi(i_lenHARSI) // shadow, invisible color colShadow = color.rgb(0, 0, 0, 100) color colNone = color.rgb(0, 0, 0, 100) // rsi color //color colRSI = RSI >=30 ? color.red : color.gray color colRSI = RSI < -31 ? color.lime : RSI > 31 ? color.red : color.gray cross_up = RSI > 30 cross_down = RSI < -30 // candle body colouring color bodyColour = C > O ? i_colUp : i_colDown color wickColour = i_colWick //////////////////////////////////////////////////////////////////////////////// // // // ====== DRAWING and PLOTTING ====== // // // //////////////////////////////////////////////////////////////////////////////// plotchar(cross_down and wwttBuyShow and buySignal ? -107 : na, title='Buy circle', char='·', color=color.new(colorGreen, 10), location=location.absolute, size=size.small) plotchar(cross_up and wwttSellShow and sellSignal ? 105 : na, title='Sell circle', char='·', color=color.new(colorRed, 10), location=location.absolute, size=size.small) plotchar(cross_down and wwttDivShow and buySignalDiv and wwttBuyShow and buySignal ? -106 : na, title='Divergence buy circle', char='▲', color=buySignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10) plotchar(cross_up and wwttDivShow and sellSignalDiv and wwttSellShow and sellSignal ? 106 : na, title='Divergence sell circle', char='▼', color=sellSignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10) //Alerts alertcondition((cross_down and wwttBuyShow and buySignal and wwttDivShow and buySignalDiv) or (cross_up and wwttSellShow and sellSignal and wwttDivShow and sellSignalDiv), title='Buy/Sell Signal', message='Buy/Sell Signal')
Pine Script® indicator
by slvkmr82
ICT Strategy Full Bot - Sweep + BOS + FVG + FibStrategy Summary – ICT-Based Precision Trading This strategy follows a Smart Money Concept (ICT) approach, focusing on: Liquidity sweeps at key daily and 4H swing highs/lows or FVG zones Reversals confirmed by a strong impulse and structure break (BOS/ChoCH) on the 15-minute chart Precise entries using confluence between a Fair Value Gap (FVG) and the 50% Fibonacci retracement Tight risk management with Stop Loss under the liquidity sweep Two Take Profit options: next HTF swing or a valid FVG in the opposing leg Break-even automation after internal structure confirms the move Perfect for traders who want a rule-based, high-probability entry system rooted in institutional price action theory.
Pine Script® indicator
by luckyAntelope65956
Supply & Demand Zones _____________________________________________________________________ Supply and Demand Zones This indicator displays valid Supply and Demand zones on any chart and timeframe, using dynamically updating visuals. Users can see the moment that zones become validated, used, and then invalidated during live sessions. It is sleek, lightweight, and offers a feature-rich settings panel that allows customization of how each element appears and functions. Zones can enhance the probability of successful trades by locating areas that are most likely to contain resting orders of Supply or Demand, which are needed for price reversals. Disclaimer ____________________ Like all indicators, this can be a valuable tool when incorporated into a comprehensive, risk-based trading system. Supply and Demand is not the same thing as Support and Resistance. Trading based on price hitting a zone without understanding which zones are of higher quality and which are of lower quality (only discernible with a trained human eye) will yield poor results. Supply and Demand works well as a system and even better when added to an existing one. However, like all effective trading techniques, it requires diligent study, practice, and repetition to become proficient. This is an indicator for use with Supply and Demand concepts, not a replacement for learning them. Features ____________________ Once a valid candle sequence is confirmed, a box will appear that displays the zone over the precise zone range. At 50% zone penetration, a zone becomes used , and at 100% it becomes invalidated . Each of these zone classifications changes the behavior of the zone on the chart immediately. The settings panel offers custom colors for Supply , Demand , Used , and Invalidated zone types. Borders : The subtle border colors can be changed or hidden. Boxes or Bases : Advanced users can opt to hide zone boxes and instead display small, subtle tags over base candle groups. This allows for more customizable selection over what is displayed and how. Max Zones and Hide Invalidated : There are limitations on how many objects TradingView allows at once. Because of this, once zones go from used to invalidated , they are hidden (deleted) by default. This allows the zones index to be allocated to display more valid , usable zones instead. If a user prefers to keep invalidated zones visible, they can be enabled; however, this will result in showing more recent zones for fewer historical zones. All zones share one pool, so if you allow fifty max zones, forty-five might be supply while five might be demand on a big sell-off trend. You will always see the most recent zones, regardless of type or status. It’s up to you how much clutter you want on your screen and how much improved load time you want - but once loaded, zone creation and function are always instantaneous. Load Time ____________________ Load time refers to the time it takes from when you switch tickers or timeframes before the zones are displayed initially. There is zero lag in the dynamic function and minimal load time, regardless of settings. However, if you are a fine-tuner or multi-screener, the number of Max Zones displayed is the only major variable affecting load time. I run everything at Max when I develop. When I trade, I run mine at 25 max zones because I change timeframes often and want a very quick display of zones when I do. I have invalidated hidden, and simply enable it if I want to check an old zone. This gives me more zones than I need and reduces the load time to right where I like it. Thresholds ____________________ It is recommended to leave these as the default. Base Body Threshold : Determines the maximum ratio of a candle’s body to wick before invalidation. Default (50% or 0.5). A higher number loosens thresholds, resulting in more zones being displayed. Unrequire 2nd FT if LO is Strong & Strength Multiplier : The standard logic sequence requires two Follow-Through candles. Under some strong price movement, Leg-Out candles can make an explosive directional move from a base, making a convincing argument for supply and demand perfectly at work, if not for a single Follow-Through candle instead of two. By enabling this feature, you can tell the script to ignore second Follow-Through candles, if and only if, the Leg-Out candle's range is (Strength) X the base range. exceeds the range of the Base by a factor of X (Strength). ie: At 5x, this would require a Leg-Out range to be 500% the range of the Base. If enabled and the Leg-Out is not strong enough, the default logic kicks in, and a second follow-through candle will validate the zone as per usual. This loosens thresholds overall and should result in more zones. Recommended Usage ____________________ Form a thesis using your primary trend trading system (eg: Elliott Wave, Structure Reversal, TheStrat, et al) to identify locations of a pullback for a long or short entry. Identify a pullback area using your system, then use this indicator to find a high-quality zone on your chosen timeframe. Once located, draw your own channel over the indicator's zone box. Start on 1m, check for zones, 2m, 3m, and so on. When you see a zone you like, recreate it; thus, when finished, you can see every timeframe’s highest-quality zones that you created, regardless of what timeframe you switch to. Tip: Be selective To make the process faster, save a channel design in settings for “Demand” and one for “Supply”, then you can quickly get through this process in less than a minute with practice. Optional: Use additional methods (eg: Fibonacci retracements, Elliott Wave Theory, Anchored VWAPs) to find congruent confirmation. Version 1.0 ____________________ No known bugs remain from the closed beta. In Development ____________________ Powerful combination zones occur when standard zone sequences are extended with additional levels of demand or supply by adding more conditionals to the state machine logic. Got this mostly working in a dev version and it adds minimal extra resources. Set aside to polish a clean standard 1.0 for release first, but now displaying these extended zones is my top priority for next version. MTF support is essentially working in a dev copy, but adds resources. Not sure if it is in the spirit of price action being the primary focus of a chart for serious traders, rather than indicators. If there is demand for it, I'll consider it. Additional Threshold Settings Thanks! ____________________ Thank you for your interest in my work. This was a personal passion project of mine, and I was delighted it turned out better than I hoped, so I decided to share it. If you have any comments, bugs, or suggestions, please leave them here, or you can find me on Twitter or Discord. @ ContrarianIRL Open-source developer for over 25 years
Pine Script® indicator
by ContrarianIRL
2
ICT Order Blocks v2 (Debug)Josh has a very large PP xD Understanding Order Blocks (OBs) - The ICT Perspective This document delves into the concept of Order Blocks (OBs) from the perspective of the ICT methodology. It outlines what OBs are, their significance in trading, and how the "ICT Order Blocks v2 (Refined)" indicator functions to identify and visualize these critical price levels. By understanding OBs, traders can better navigate market movements and make informed decisions based on institutional trading behavior. What is an Order Block (OB)? Within ICT methodology, an Order Block represents a specific price candle where significant buying or selling interest from institutions (Smart Money) is believed to have occurred. They are potential areas where price might return and react. Bullish Order Block: Typically the last down-closing candle before a strong, impulsive upward move (displacement). It suggests institutions may have absorbed selling pressure and initiated long positions here. Bearish Order Block: Typically the last up-closing candle before a strong, impulsive downward move (displacement). It suggests institutions may have distributed long positions or initiated short positions here. Why are OBs Significant (ICT View)? Institutional Footprint: They mark potential zones of large order execution. Support/Resistance: Unmitigated OBs can act as sensitive price levels where reactions are expected. Bullish OBs may provide support; Bearish OBs may provide resistance. Origin of Moves: They often mark the origin point of significant price swings. Liquidity Engineering: Institutions might drive price back to OBs to mitigate earlier positions or to engineer liquidity before continuing a move. Common Refinements ICT often emphasizes higher probability OBs that are associated with: Displacement: The move away from the OB is sharp and decisive. Fair Value Gaps (FVGs): An FVG forming immediately after the OB strengthens its validity. OB Mitigation: This refers to price returning to the level of the Order Block after its formation. Price might react at the edge (proximal line) or the 50% level (mean threshold) of the OB. An OB is often considered fully mitigated or invalidated if price trades decisively through its entire range, especially with a candle body closing beyond it. How the "ICT Order Blocks v2 (Refined)" Indicator Works This indicator automates the detection and visualization of the most recent unmitigated Order Block of each type (Bullish/Bearish), incorporating optional filters. Detection: It looks at the relationship between the candle two bars ago ( ), the previous candle ( ), and potentially the current candle ( ). Bullish OB: Identifies if candle was a down-close (close < open ) AND candle broke above the high of candle (high > high ). Bearish OB: Identifies if candle was an up-close (close > open ) AND candle broke below the low of candle (low < low ). Accuracy Filters (Optional Inputs): These filters help identify potentially higher-probability OBs: Require Fair Value Gap (FVG)?: If enabled, the indicator checks if an FVG formed immediately after the OB candle ( ). Specifically, it looks for a gap between candle and candle (low > high for Bullish OB confirmation, high < low for Bearish). Require Strong Close Breakout?: If enabled, it requires the breakout candle ( ) to close beyond the range of the OB candle ( ). (close > high for Bullish, close < low for Bearish). This suggests stronger confirmation. Storing the Most Recent OB: When an OB is detected and passes any enabled filters, its details (high, low, formation bar index) are stored. Crucially, this indicator only tracks the single most recent valid unmitigated OB of each type (one Bullish, one Bearish) using var variables. If a newer valid OB forms, it replaces the previously stored one. Drawing Boxes: If a valid Bullish OB is being tracked (and Show Bullish OBs is enabled), it draws a box (box.new) using the high and low of the identified OB candle ( ). The same process applies to Bearish OBs (Show Bearish OBs enabled). The boxes automatically extend to the right (extend.right) and their right edge is updated on each new bar (box.set_right) until they are mitigated. Labels ("Bull OB" / "Bear OB") are displayed inside the boxes. Mitigation & Box Deletion: The indicator checks if the current closing price (close ) has moved entirely beyond the range of the tracked OB. Mitigation Rule Used: A Bullish OB is considered mitigated if close < bull_ob_low. A Bearish OB is considered mitigated if close > bear_ob_high. Once an OB is marked as mitigated, the indicator stops tracking it and its corresponding box is automatically deleted (box.delete) from the chart. This indicator provides a dynamic visualization of the most recent, potentially significant Order Blocks that meet the specified criteria, helping traders identify key areas of interest based on ICT principles.
Pine Script® indicator
by joshuaburton096
Ichimoku Cloud Auto TF🧠 Timeframe Breakdown for Ichimoku Cloud Auto TF Each timeframe in this indicator is carefully calibrated to reflect meaningful Ichimoku behavior relative to its scale. Here's how each one is structured and what it's best used for: ⏱️ 1 Minute (1m) Tenkan / Kijun / Span B: 5 / 15 / 45 Use: Scalping fast price action. Logic: Quick reaction to short-term momentum. Best for highly active traders or bots. ⏱️ 2 Minutes (2m) Tenkan / Kijun / Span B: 6 / 18 / 54 Use: Slightly smoother than 1m, still ideal for scalping with a little more stability. ⏱️ 5 Minutes (5m) Tenkan / Kijun / Span B: 8 / 24 / 72 Use: Intraday setups, quick trend capture. Logic: Balanced between reactivity and noise reduction. ⏱️ 15 Minutes (15m) Tenkan / Kijun / Span B: 9 / 27 / 81 Use: Short-term swing and intraday entries with higher reliability. ⏱️ 30 Minutes (30m) Tenkan / Kijun / Span B: 10 / 30 / 90 Use: Intra-swing entries or confirmation of 5m/15m signals. 🕐 1 Hour (1H) Tenkan / Kijun / Span B: 12 / 36 / 108 Use: Ideal for swing trading setups. Logic: Anchored to Daily reference (1H × 24 ≈ 1D). 🕐 2 Hours (2H) Tenkan / Kijun / Span B: 14 / 42 / 126 Use: High-precision swing setups with better context. 🕒 3 Hours (3H) Tenkan / Kijun / Span B: 15 / 45 / 135 Use: Great compromise between short and mid-term vision. 🕓 4 Hours (4H) Tenkan / Kijun / Span B: 18 / 52 / 156 Use: Position traders & intraday swing confirmation. Logic: Designed to echo the structure of 1D Ichimoku but on smaller scale. 📅 1 Day (1D) Tenkan / Kijun / Span B: 9 / 26 / 52 Use: Classic Ichimoku settings. Logic: Standard used globally for technical analysis. Suitable for swing and position trading. 📆 1 Week (1W) Tenkan / Kijun / Span B: 12 / 24 / 120 Use: Long-term position trading & institutional swing confirmation. Logic: Expanded ratios for broader perspective and noise filtering. 🗓️ 1 Month (1M) Tenkan / Kijun / Span B: 6 / 12 / 24 Use: Macro-level trend visualization and investment planning. Logic: Condensed but stable structure to handle longer data cycles. 📌 Summary This indicator adapts Ichimoku settings dynamically to your chart's timeframe, maintaining logical ratios between Tenkan, Kijun, and Span B. This ensures each timeframe remains responsive yet meaningful for its respective market context.
Pine Script® indicator
by DanyBedard2309
Engulfing Candle Pattern (Strict)Indicator Name : Engulfing Candle Pattern (Strict) Purpose : The Engulfing Candle Pattern Indicator is designed to identify and visually mark bullish and bearish engulfing patterns on a price chart. These patterns are powerful reversal signals in technical analysis, often used by traders to spot potential trend changes. The indicator ensures strict adherence to the definition of engulfing patterns, making it reliable for identifying high-probability setups. What It Does : Identifies Engulfing Patterns : The indicator scans the price data for candles that meet the criteria of either a bullish engulfing or bearish engulfing pattern . A bullish engulfing occurs when a green (bullish) candle fully engulfs the body and wicks of the previous red (bearish) candle and closes above its high. A bearish engulfing occurs when a red (bearish) candle fully engulfs the body and wicks of the previous green (bullish) candle and closes below its low. Marks Patterns Visually : Bullish engulfing patterns are marked with a green upward triangle below the candle. Bearish engulfing patterns are marked with a red downward triangle above the candle. Optional labels ("Bullish" or "Bearish") provide additional context. Highlights Candles : Engulfing candles are highlighted with semi-transparent colors: Green for bullish engulfing. Red for bearish engulfing. Ensures Strict Conditions : The current candle must fully cover the entire body and wicks of the previous candle. The current candle must close above the previous candle's high (for bullish) or below the previous candle's low (for bearish).
Pine Script® indicator
by gomaa199910
Cross MA Alert 1HThe Moving Average Crossover Indicator is a technical analysis tool designed to identify potential trend changes and trading signals based on the intersection of two moving averages. It typically involves a shorter-period moving average (e.g., 3-day) and a longer-period moving average (e.g., 25-day). When the shorter moving average crosses above the longer moving average, it generates a bullish signal, suggesting a potential upward trend or buying opportunity. Conversely, when the shorter moving average crosses below the longer moving average, it produces a bearish signal, indicating a possible downward trend or selling opportunity. This indicator is widely used by traders to capture momentum shifts and filter out market noise, making it effective for both trend-following and reversal strategies
Pine Script® indicator
by Lowerh
Oracle Prediction Futur // (\_/) // ( •.•) // (")_(") Indicator Description: Oracle Prediction Futur The Oracle Prediction Futur is a sophisticated technical indicator designed for traders and analysts looking to gain insights into market trends through the analysis of price movements. This Pine Script™ code integrates innovative elements to enhance the trading experience and is governed by the Mozilla Public License 2.0. Key Features: Normalization of Closing Prices: The indicator normalizes closing prices over a defined lookback period (100 periods) to provide a percentage-based representation of the current price relative to its historical range. This helps in identifying potential price extremes. Peak and Trough Detection: It identifies and plots peak tops and bottom troughs based on normalized closing values. Peak tops are marked with vibrant magenta circles, while peak bottoms are indicated by soothing cyan circles, helping traders visually spot significant turning points in the price action. Dynamic Background Gradient: The indicator features a visually appealing gradient background that represents market sentiment. The background color transitions between bear and bull colors based on the position of the normalized close within the 0-100 range. This provides an immediate visual cue about the strength or weakness of the market. Horizontal Reference Lines: The indicator includes horizontal lines at key levels (9.51 and 92.5) for quick reference, which can help to gauge areas of potential support or resistance. User-Friendly Visuals: The combination of background colors, dynamic plots, and clear labeling offers a user-friendly visual representation, making it easier to interpret market conditions at a glance. Overlay Options: As an overlay-free indicator, it maintains clarity on the price chart while providing insightful trends and forecasts. Practical Application: Traders can utilize the Oracle Prediction Futur indicator to identify potential entry and exit points in their trading strategies. By observing the peaks, troughs, and background color shifts, users can better understand market momentum and price action. How to Use: Deploy this indicator on your trading platform, and analyze the peaks and troughs along with the normalized close line and background gradient to inform your trading decisions. Look for alignment between price action and the signaling provided by the indicator for optimized trading results.
Pine Script® indicator
by fr33domz
ADR Nivele Horizontale dhe EMAThe user provided a Pine Script code for an indicator called "ADR Nivele Horizontale dhe EMA". The task is to explain how this code works. Hmm, first, I need to understand what this indicator does. The title mentions ADR levels and EMA, so it's probably combining horizontal lines based on Average Daily Range and some Exponential Moving Averages. Looking at the code, the first part is the indicator declaration with version 6. The settings include an ADR period, levels above and below the mid, and line style. Then there's a section for calculations. They request daily high and low to compute the daily range. The ADR is the SMA of the daily range over the specified period. The mid is the average of daily high and low. The adr_val is half of ADR, maybe to create symmetrical levels around the mid. Next, they create arrays for lines and labels above and below the mid. The loops go from 1 to levels_above/below, calculate each level, draw lines and labels. The mid line is also drawn with a different color. Then, there are several EMAs plotted: 13, 50, 200, 400, 600, 800, each with different colorsWait, but in Pine Script, when you use arrays to store lines and labels, you have to manage them properly to avoid repainting or memory issues. The code uses array.concat to add new lines and labels each bar. However, since this code is running on each bar, the for loops might be creating multiple lines each time, leading to too many objects. Oh right, but they use var to initialize the arrays, so they are only initialized once. Wait, no. The var keyword initializes the variable once, but in each iteration, they are concatenating new lines. Wait, no: the for loops are inside the main script, which runs on each bar. So every time a new bar is processed, the loops will run again, adding new lines and labels. That's a problem because each bar would create new lines, leading to an ever-increasing number of lines, which could hit the maximum limit (max_lines_count is set to 20, but maybe they have more bars). Oh, the indicator has max_lines_count=20, but the code might be creating multiple lines per bar. So maybe the code isn't handling the line management correctly. For example, if levels_above is 2, then each bar would create 2 new lines above and 2 below, plus the mid line. Over 20 bars, that's way over 20 lines. So this could cause the indicator to stop drawing after 20 lines. The user might not have realized that the lines are being recreated every bar, leading to a buildup. But perhaps the original code intended to have the lines update each bar, extending to the current bar. Let's see: in line.new, they use bar_index as the starting x1 and bar_index as x2. So each line is drawn from the previous bar's index to the current one. But since this is done on every bar, each line is only one bar long. Wait, no. Because on each new bar, the code creates a new line from the previous bar's index (bar_index , which is now the bar before the current one) to the current bar_index. So each line is just a segment from the previous bar to the current bar. But when the next bar comes, a new line is created again. So the result is that each level line is a series of one-bar-length segments, which might not be intended. The user probably wants continuous lines that extend from the left to the right, not just per bar. So this approach is incorrect. The correct way would be to have a line that starts at the first bar of the calculation and extends to the right, updating each bar. But the current code creates a new line each bar, leading to multiple short lines instead of one continuous line. That's a mistake. So the main issue here is that the code is generating a new line segment for each bar, which is not efficient and would quickly hit the line limit. To fix this, instead of creating a new line every bar, they should create the line once and then update its position each bar. But in Pine Script, you can't directly update a line after it's created; instead, you need to track the line ID and use line.set_xy() to extend it. However, the current code uses array.concat to add new lines each bar, which isn't the right approach. Therefore, the code as written will create multiple short lines instead of continuous horizontal lines. The correct approach for horizontal levels that extend to the right is to create the line once, starting at a certain bar and extending indefinitely, or to update the line's end point each new bar. But in Pine Script, you can't extend lines infinitely; you have to manage them each bar. Alternatively, using the 'line.extend' style might help, but I think the original code's logic is flawed here. Additionally, the EMA part is straightforward: plotting multiple EMAs with different periods. That part should work as expected. So the explanation should mention that the ADR levels are calculated based on the daily high and low, then the code attempts to draw horizontal lines above and below the mid-point. However, the way the lines are drawn may lead to multiple short segments instead of continuous lines, potentially causing performance issues or hitting the maximum line count. The EMAs are plotted correctly with various periods..
Pine Script® indicator
by AldiPlaku
Quantum Price SignalQuantum Price Signal This indicator combines square root price analysis with advanced technical filters to identify high-probability trading opportunities. Designed for practical use in real market conditions, it provides both visual signals and a comprehensive dashboard to enhance trading decisions. Core Technology: The Quantum Price Signal uses mathematical relationships based on square root price levels to identify key zones where price tends to react. These levels have proven to be powerful areas for reversals and continuations across multiple timeframes. Detailed Usage Guide: Signal Interpretation: Green Triangle (Buy): Appears below candles at potential support levels. Look for these at market bottoms and pullbacks in uptrends Red Triangle (Sell): Appears above candles at potential resistance levels. Most effective at market tops and rallies in downtrends Dashboard Elements: Buy/Sell Signal Quality: Shows relative strength of potential setups Higher values indicate stronger signals with better probability Use as comparative measure between different signals Market Noise: Indicates market choppiness/volatility Lower readings suggest cleaner price action and more reliable signals Higher readings indicate choppy conditions requiring wider stops Trend Direction: Overall market bias Align trades with this direction for highest probability Counter-trend trades require stronger signal quality Near Square Root Level: Confirms price at significant mathematical level "Yes" reading significantly strengthens any signal These mathematical levels often act as strong support/resistance Current Signal: Active trading recommendation Shows most recent valid signal type Use to quickly identify the indicator's bias Practical Trading Applications: Swing Trading Strategy: Look for signals at key support/resistance levels Confirm with trend direction on dashboard Enter on close of signal candle Place stops beyond recent swing points Target next significant level or 1:2 risk-reward Trend-Following Method: Only take signals in direction of "Trend Direction" Wait for pullbacks to Square Root levels Require "Yes" for Near Square Root Level reading Enter when signal appears at these levels Trail stops using prior swing points Reversal Detection: Watch for signals against prevailing trend Must have "Near Square Root Level" showing "Yes" Confirm with pattern like engulfing or hammer Look for divergence in momentum indicators Use tighter stops as these are higher risk trades Multiple Timeframe Approach: Identify trend on higher timeframe Look for signals on lower timeframe Only take signals that align with higher timeframe trend Add to position on additional signals in same direction Exit when signal appears in opposite direction Volume Confirmation Enhancement: Check volume on signal candles Stronger signals should have above-average volume Low volume signals have higher failure rate Volume increase on breakouts confirms strength Volume decline near levels suggests potential failure This indicator works best when combined with proper risk management and sound technical analysis principles. Use it as a decision support tool rather than an automated system, and always consider the broader market context when making trading decisions.RetryClaude can make mistakes. Please double-check responses.
Pine Script® indicator
by Qthreat
1