Smart Trend Envelopebased on original and publishing to use the upper and lower values in a strategy
지표 및 전략
ATRs in Days📌 ATR in Days
This script tracks how price moves in relation to ATR over multiple days, providing a powerful volatility framework for traders.
🔹 Key Features:
✅ 4 ATRs in 5 Days – Measures if a stock has moved 4x its ATR within the last 5 days, identifying extreme volatility zones.
✅ Daily ATR Calculation – Tracks average true range over time to gauge market conditions.
✅ Clear Table Display – Real-time ATR readings for quick decision-making.
✅ Intraday & Swing Trading Compatible – Works across multiple timeframes for day traders & swing traders.
📊 How to Use:
Look for stocks that exceed 4 ATRs in 5 days to spot extended moves.
Use ATR as a reversion or continuation signal depending on market structure.
🚀 Perfect for traders looking to quantify volatility & structure trades effectively!
MACD Boundary PSA - CoffeeKillerMACD Boundary PSA - CoffeeKiller Indicator Guide
Welcome traders! This guide will walk you through the MACD Boundary PSA indicator, a powerful market analysis tool developed by CoffeeKiller that enhances the traditional MACD with advanced boundary detection and peak signaling features.
🔔 **Warning: This Indicator Has No Signal Line or MACD Line** 🔔 This indicator is my version of the MACD, that I use in conjunction with the Rev&Line indicator.
Core Concept: Enhanced MACD Analysis
The foundation of this indicator builds upon the classic Moving Average Convergence Divergence (MACD) indicator, adding boundary tracking and peak detection systems to provide clearer signals and market insights.
Histogram Bars: Market Momentum
- Positive Green Bars: Bullish momentum
- Negative Red Bars: Bearish momentum
- Color intensity varies based on momentum strength
- Special coloring for new high/low boundaries
Marker Lines: Dynamic Support/Resistance
- High Marker Line (Magenta): Tracks the highest point reached during a bullish phase
- Low Marker Line (Cyan): Tracks the lowest point reached during a bearish phase
- Acts as dynamic boundaries that help identify strength of current moves
Peak Detection System:
- Triangular markers identify significant local maxima and minima
- Background highlighting shows important momentum peaks
- Helps identify potential reversal points and momentum exhaustion
Core Components
1. MACD Calculation
- Customizable fast and slow moving averages
- Signal line smoothing options
- Flexible MA type selection (SMA or EMA)
- Custom source input options
2. Boundary Tracking System
- Automatic detection of highest values in bullish phases
- Automatic detection of lowest values in bearish phases
- Step-line visualization of boundaries
- Color-coded for easy identification
3. Peak Detection System
- Identification of local maxima and minima
- Background highlighting of significant peaks
- Triangle markers for peak visualization
- Zero-line cross detection for trend changes
4. Time Resolution Control
- Normal mode: calculations based on chart timeframe
- Custom resolution mode: calculations based on specified timeframe
Main Features
Time Resolution Settings
- Normal mode: calculations match your chart's timeframe
- Custom resolution mode: calculations based on specified timeframe
- Helps identify stronger signals from other timeframes
Visual Elements
- Color-coded histogram bars
- Dynamic marker lines for boundaries
- Peak triangles for significant turning points
- Background highlighting for peak identification
Signal Generation
- Zero-line crosses for trend change signals
- Boundary breaks for momentum strength
- Peak formation for potential reversals
- Color changes for momentum direction
Customization Options
- MA types and lengths
- Signal smoothing
- Color schemes
- Marker line visibility
- Peak background display options
Trading Applications
1. Trend Identification
- Histogram crossing above zero: bullish trend beginning
- Histogram crossing below zero: bearish trend beginning
- Histogram color: indicates momentum direction
- Consistent color intensity: trend strength
2. Reversal Detection
- Peak triangles after extended trend: potential exhaustion
- Background highlighting: significant reversal points
- Histogram approaching marker lines: potential trend change
- Color shifts from bright to muted: decreasing momentum
3. Momentum Analysis
- Histogram breaking above previous high boundary: accelerating bullish momentum
- Histogram breaking below previous low boundary: accelerating bearish momentum
- Special coloring (magenta/cyan): boundary breaks indicating strength
- Distance from zero line: overall momentum magnitude
4. Market Structure Assessment
- Consecutive higher peaks: strengthening bullish structure
- Consecutive lower troughs: strengthening bearish structure
- Peak comparisons: relative strength of momentum phases
- Boundary line steps: market structure levels
Optimization Guide
1. MACD Settings
- Fast Length: Shorter values (8-12) for responsiveness, longer values (20+) for smoother signals
- Slow Length: Shorter values (21-34) for more signals, longer values (72+) for major moves
- Default settings (22, 72, 9): balanced approach for most timeframes
- Consider using 8, 21, 5 for shorter timeframes and 34, 144, 5 for longer timeframes
2. MA Type Selection
- EMA: More responsive, follows price more closely
- SMA: Smoother, fewer false signals, potentially more lag
- Mix and match for oscillator and signal lines based on your preference
3. Time Resolution
- Match chart timeframe: for aligned analysis
- Use higher timeframe: for filtering signals
- Lower timeframe: for earlier entries but more noise
4. Color Customization
- Normal bullish/bearish colors: represent standard momentum
- High/low marker line colors: customize visibility
- Peak marker colors: adjust for your visual preference
- Consider chart background when selecting colors
Best Practices
1. Signal Confirmation
- Wait for zero-line crosses to confirm trend changes
- Look for peak formations to identify potential reversals
- Check for boundary breaks to confirm strong momentum
- Use custom timeframe option for higher timeframe confirmation
2. Timeframe Selection
- Lower timeframes: more signals, potential noise
- Higher timeframes: cleaner signals, less frequent
- Custom resolution: allows comparison across timeframes
- Consider using multiple timeframes for confirmation
3. Market Context
- Strong bullish phase: positive histogram breaking above marker line
- Strong bearish phase: negative histogram breaking below marker line
- Histogram approaching zero: potential trend change
- Peak formations: potential exhaustion points
4. Combining with Other Indicators
- Use with trend indicators for confirmation
- Pair with oscillators for overbought/oversold conditions
- Combine with volume analysis for validation
- Consider support/resistance levels with boundary lines
Advanced Trading Strategies
1. Boundary Break Strategy
- Enter long when histogram breaks above previous high marker line
- Enter short when histogram breaks below previous low marker line
- Use zero-line as initial stop-loss reference
- Take profits at formation of opposing peaks
2. Peak Trading Strategy
- Identify significant peaks with triangular markers
- Look for consecutive lower peaks in bullish phases for shorting opportunities
- Look for consecutive higher troughs in bearish phases for buying opportunities
- Use zero-line crosses as confirmation
3. Multi-Timeframe Strategy
- Use custom resolution for higher timeframe MACD trend
- Enter trades when both timeframes align
- Higher timeframe for trend direction
- Chart timeframe for precise entry
4. Histogram Color Strategy
- Enter long when histogram turns bright green (increasing momentum)
- Enter short when histogram turns bright red (increasing momentum)
- Exit when color intensity fades (decreasing momentum)
- Use marker lines as dynamic support/resistance
Practical Analysis Examples
Bullish Market Scenario
- Histogram crosses above zero line
- Green bars grow in height and intensity
- High marker line forms steps upward
- Peak triangles appear at local maxima
- Background highlights appear at significant momentum peaks
Bearish Market Scenario
- Histogram crosses below zero line
- Red bars grow in depth and intensity
- Low marker line forms steps downward
- Peak triangles appear at local minima
- Background highlights appear at significant momentum troughs
Consolidation Scenario
- Histogram oscillates around zero line
- Bar colors alternate frequently
- Marker lines remain relatively flat
- Few or no new peak highlights appear
- Histogram values remain small
Understanding Market Dynamics Through MACD Boundary PSA
At its core, this indicator provides a unique lens to visualize market momentum and boundaries:
1. Momentum Strength: The histogram height/depth shows the strength of current momentum, with color intensity providing additional context about acceleration or deceleration.
2. Dynamic Boundaries: The marker lines create a visual representation of the "high water marks" of momentum in both directions, helping to identify when markets are making new momentum extremes.
3. Exhaustion Signals: The peak detection system highlights moments where momentum has reached a local maximum or minimum, often precursors to reversals or consolidations.
4. Trend Confirmation: The histogram color and intensity provide instant feedback about the current trend direction and strength, with special colors highlighting particularly significant moves.
Remember:
- Combine signals from histogram, marker lines, and peak formations
- Use appropriate timeframe settings for your trading style
- Customize the indicator to match your visual preferences
- Consider market conditions and correlate with price action
This indicator works best when:
- Used as part of a comprehensive trading system
- Combined with proper risk management
- Applied with an understanding of current market conditions
- Signals are confirmed by price action and other indicators
**DISCLAIMER**: This indicator and its signals are intended solely for educational and informational purposes. They do not constitute financial advice. Trading involves significant risk of loss. Always conduct your own analysis and consult with financial professionals before making trading decisions.
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..
Hanstrading-buysignalbreakoutTrading method based on donchian channel method and breakout strategy.
Buy on big buy signal and sell the entire portfolio on big sell signal reversal. Buy more at pullback points.
Vice versa for bearish trading.
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).
Сессии 1 min (Лондон/Нью-Йорк + Close)London/NY Sessions + London Close
*Pine Script v5 - For TradingView*
EN: Visualizes trading sessions per hour:
- LON Open (08-20m) - Blue
- NY Open (28-40m) - Green
- LON Close (44-48m) - Purple
RU: Отображает торговые сессии внутри часа:
- ЛОН Open (08-20 мин) - Синий
- NY Open (28-40 мин) - Зеленый
- ЛОН Close (44-48 мин) - Фиолетовый
Features:
✔ Customizable timing
✔ Works on all timeframes
✔ Session labels
Особенности:
✔ Настройка времени
✔ Все таймфреймы
✔ Подписи сессий
Alert-ready: Use alertcondition()
Для алертов: alertcondition()
Для донатов сбербанк - 4276060043810228
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
HTSS v7.1 Advanced [Mum & Formasyon Analizli]karma bir giriş çıkış kodu deniyorum bkalım hayırlısı :)
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.
Multi-Timeframe Support Levels (Claude)Work features:
Analyzes three periods simultaneously (for example: 15min, 1h and 4h)
Filters false levels based on two criteria:
The minimum must be lower than N adjacent bars (set in "Number of bars for minimum")
Combines close levels (adjusted to "Proximity Percentage")
Draws horizontal lines in different colors for each period.
Updates levels when new data becomes available
Особенности работы:
Анализирует три периода одновременно (например: 15мин, 1ч и 4ч)
Фильтрует ложные уровни по двум критериям:
Минимум должен быть ниже N соседних баров (задается в "Число баров для минимума")
Объединяет близкие уровни (настраивается в "Процент близости")
Рисует горизонтальные линии разными цветами для каждого периода
M2 Global Liquidity Index (Candles) - Shifted 77 Days Forwardthis is 11 weeks delayed version of m2 supply chart in candle bars published by KevinSvenson_
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')
Opening Price Signal (Text-Based)Overview:
This simple yet powerful indicator quickly identifies the intraday trend direction by comparing the current price to the day’s opening price.
How it Works:
• Bullish Signal: Last price is at least +0.25 points above today’s open—suggests buying (Long).
• Bearish Signal: Last price is at least -0.25 points below today’s open—suggests selling (Short).
• Neutral: Price remains within ±0.25 points of today’s open—no trade recommended.
What’s Displayed:
• Open Price: Today’s opening price.
• Last Price: Current trading price.
• Signal: Difference between last price and today’s open.
• Sentiment: Clearly labeled as Bullish, Bearish, or Neutral.
• Action: Recommended trade direction (Long, Short, or None).
Recommended Timeframes:
• 5-Minute (ideal for precise intraday trading)
• 15-Minute (balanced clarity and noise reduction)
• 30-Minute (reduced noise, smoother signals)
Ideal Usage:
Perfect for day traders looking for a quick and clear gauge of intraday market sentiment. Use it to confirm momentum and trade confidently in the direction of the daily trend.
Happy trading! 📈✨
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers*
🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability.
### *🚀 Key Features:*
✅ *EMA Crossover Strategy* – Uses EMA to identify trend reversals.
✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions.
✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength.
✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups.
✅ *Buy & Sell Signals* – Clearly marked entries and exits for easy decision-making.
### *📈 How It Works:*
📌 *BUY Signal* – When the EMA crosses above , ATR confirms volatility, RSI is above 50, and Stochastic shows momentum.
📌 *SELL Signal* – When the EMA crosses below , ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum.
🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC ONLY!
📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades.
🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
Custom TABI Model with Layers(Top and Bottom Indicator) TABI RSI Heatmap with FOMO Layers is an original visualization model inspired by the teachings of James from InvestAnswers, who first introduced the concept of color-layered RSI as a way to spot market conditions and behavioral dynamics.
This script builds on that idea and adds several advanced layers:
A 10-color RSI zone system ranging from cool blues (oversold) to extreme reds (euphoria).
A smoothed RSI line with custom color transitions based on user-defined levels.
Blow-off top detection logic to catch euphoric spikes in RSI.
A real-time FOMO awareness table that tracks how recently the last top occurred.
It’s designed to help traders better visualize sentiment pressure in a clean, color-coded layout. Whether you're swing trading or investing long-term, this tool helps you avoid emotional decisions driven by herd mentality.
🔍 How to Use:
Add the indicator to your chart.
Adjust RSI color thresholds to suit your asset’s volatility.
Watch the top-right table for alerts on potential FOMO periods after euphoric moves.
💬 Feedback is welcome — this tool was created for community use and refinement.
📌 This script is open-source. All code and logic is provided for educational purposes.
SPY QQQ DayTrade Final - 5 Bars CooldownFocusing on trading SPY and QQQ
Users should look at into 3/5 mins chart, please do not go to less than 3 mins chart
It it use for the day trade instead of swing trade
This should be very easy to use and understand
Please common below if you have any questions
TJR Strategy Ultimate ProAll done — your TJR Strategy Ultimate indicator is now fully coded and live in the canvas.
This version includes:
Liquidity sweeps
OB and FVG zones
Session filter
RSI + multi-timeframe bias
Alerts + webhook formatting
Auto-drawing Entry / SL / TP boxes
Dashboard panel
Previous session highs/lows & equal highs/lows
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers*
🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability.
### *🚀 Key Features:*
✅ *EMA Crossover Strategy* – Uses * TWO EMA* to identify trend reversals.
✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions.
✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength.
✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups.
✅ *Buy & Sell Signals By arrow* – Clearly marked entries and exits for easy decision-making.
### *📈 How It Works:*
📌 *BUY Signal* – When the *EMA to EMA crosses up*, ATR confirms volatility, RSI is above 50, and Stochastic shows momentum.
📌 *SELL Signal* – When the *EMA to ema crosses down*, ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum.
🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC only!
📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades.
🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
Malama's Candle SniperMalama's Candle Sniper - Indicator Description
Purpose
"Malama's Candle Sniper" is a powerful TradingView indicator designed to help traders identify key candlestick patterns that signal potential reversals or continuations in price action. Whether you're looking to catch the start of a bullish uptrend or spot a bearish downturn before it happens, this tool simplifies the process by automatically detecting and labeling a wide range of classic candlestick formations. It solves a common problem for traders: the time-consuming task of manually scanning charts for reliable patterns, making it easier to focus on decision-making and strategy execution.
How It Works
The indicator uses predefined logic to analyze candlestick data—open, high, low, and close prices—across multiple bars to detect specific patterns. It’s split into two categories: bullish patterns (e.g., Bullish Engulfing, Morning Star, Hammer) that suggest upward momentum, and bearish patterns (e.g., Bearish Engulfing, Three Black Crows, Hanging Man) that hint at downward pressure. Each pattern is coded with conditions based on price relationships, such as the size of candle bodies, wicks, or gaps between bars. When a pattern forms, the indicator places a clear label directly on your chart, color-coded green for bullish and red for bearish, so you can spot opportunities at a glance.
The script ensures accuracy by only triggering a label when a pattern transitions from "not present" to "detected," avoiding clutter from repetitive signals. This focus on precision makes it a reliable companion for timing entries and exits.
How to Use It
Adding to TradingView: Open TradingView, click "Indicators" at the top, search for "Malama's Candle Sniper," and add it to your chart. Since it’s an overlay indicator, it works directly on your price candles without cluttering a separate panel.
Configuring Settings: There are no adjustable inputs by default, making it beginner-friendly—just apply it and start trading! For pros, you can dive into the script to tweak pattern definitions (e.g., adjusting wick-to-body ratios) if you prefer custom sensitivity.
Interpreting Signals: Look for green labels above candles for bullish setups—these suggest potential buying opportunities. Red labels below candles indicate bearish setups, signaling possible sell or short positions. Pair these signals with your existing strategy, like support/resistance levels or trend direction, for confirmation.
Beginner Tip: Start with a daily or 4-hour chart to practice spotting patterns in less noisy conditions before moving to shorter timeframes.
Pro Tip: Combine with volume analysis or a trend indicator (like a moving average) to filter out weaker signals and boost reliability.
Originality
What makes "Malama's Candle Sniper" stand out is its comprehensive coverage and user-friendly design. While many indicators focus on just one or two candlestick patterns, this script packs over 20 patterns—both bullish and bearish—into a single tool, from common ones like the Hammer to rarer setups like the Abandoned Baby or Three Line Strike. The clean, color-coded labeling system also sets it apart, offering instant visual clarity without overwhelming your chart. Unlike generic pattern scanners, it’s built to minimize false positives by only highlighting newly formed patterns, giving traders a sharper edge in fast-moving markets. Whether you’re a newbie learning the ropes or a seasoned trader refining your edge, this indicator delivers a unique blend of simplicity, depth, and precision.
VVIDA & VPDAanalysing trend with deep entry or Sonic R entry to get the best position for a trade with trends confirmed by the VVIDA color.
Red VVIDA line is BEARISH, should only SHORT.
Green VVIDA line is BULLISH, should only LONG.
Stoploss, above VVIDA line for SHORT. Below VVIDA for long.
Still working for Target lines.
M.G.O Receptor RSIThis indicator adds to the traditional RSI two fields that make overprices areas of accumulation and distribution.
It is used together with the M.G.O (Matrix ON Charts) methodology as a signal receiver for the trader to make the decision to buy or sell after periodic wave analysis on the main chart.
Borrow Fee & Squeeze TrackerSqueeze tracker.
This script helps identify potential short squeeze setups by detecting two key indicators: unusual volume and significant price changes.
The script combines both volume and price changes to give a more reliable indication of potential squeeze opportunities. When both criteria are met, it signals that there may be unusual market activity. The script also allows you to set up automatic alerts when both the volume and price change exceed thresholds, so you can react quickly to potential opportunities without constantly monitoring the charts.
Once added, you can set an alert:
Click on the Alert button
In the "Condition" dropdown, select the Squeeze Alert that was created.
Set the alert options
Now, when the script detects both a volume spike and a price change spike, it will trigger an alert based on your settings.
Enjoy!