Advanced Options Trading Indicator: Buy & Sell Signal Generator This powerful custom indicator combines the Relative Strength Index (RSI) and Moving Average (MA) to help traders identify optimal entry and exit points in the options market. The indicator generates real-time buy and sell signals based on RSI crossovers and price positioning relative to the moving average, providing actionable insights for traders seeking to make informed decisions. Additionally, it calculates potential call and put option strike prices with a buffer for added flexibility and precision, ensuring a well-rounded approach to options trading.
אינדיקטורים ואסטרטגיות
Higher Timeframe Stochastics with Slope ColorThis script displays the Stochastic K value of a user-defined higher timeframe and colors the plot based on its slope, providing a unique way to visualize higher timeframe momentum on the current chart.
What makes it unique?
While many scripts display higher timeframe indicators, this script goes a step further by visually highlighting the *slope* of the higher timeframe Stochastic K. This allows traders to quickly assess the direction and strength of the higher timeframe momentum without switching timeframes or manually comparing values.
Features:
* **Primary Function:** Displays the Stochastic K value from a selected higher timeframe.
* **Secondary Function:** Colors the Stochastic K plot based on its slope compared to the previous confirmed value:
* Green: The current Stochastic K value is higher than the previous confirmed value, indicating increasing upward momentum on the higher timeframe.
* Red: The current Stochastic K value is lower than the previous confirmed value, indicating increasing downward momentum on the higher timeframe.
How it works:
* The script calculates the Stochastic K value using the standard formula with user-defined length and the selected higher timeframe.
* It then compares the current higher timeframe Stochastic K value with the *previous confirmed* value obtained using `request.security` with `lookahead=barmerge.lookahead_on`.
* The difference between these two values determines the slope, which is then represented by the color of the plot.
How to Use:
1. Add this script to your chart.
2. Configure the "Higher Timeframe" and "Stochastic Length" in the script settings.
3. Observe the plot of the higher timeframe Stochastic K value and its color changes. The color provides a quick visual cue of the higher timeframe momentum's direction.
Important Note about `request.security` and `lookahead=barmerge.lookahead_on`:
This script uses `request.security(..., lookahead=barmerge.lookahead_on)` to obtain the *previous confirmed* value of the higher timeframe Stochastic K. This is crucial for accurately calculating the slope. While `lookahead=barmerge.lookahead_on` can introduce lookahead bias on historical bars when used with non-offset expressions, in this case, it's used to access the *last confirmed value* of the higher timeframe, which is a valid and necessary approach for this calculation. The current higher timeframe value is then compared to this *already confirmed* past value, ensuring that the slope calculation and the resulting color changes are based on reliable data and do not repaint.
このスクリプトは、ユーザーが設定した上位時間足のストキャスティクス K 値を表示し、その傾きに基づいてプロットに色を付けることで、現在のチャート上で上位時間足のモメンタムを視覚化する独自の方法を提供します。
独自性:
多くのスクリプトが上位時間足のインジケーターを表示しますが、このスクリプトは上位時間足のストキャスティクス K の*傾き*を視覚的に強調することで、一歩進んだ機能を提供します。これにより、トレーダーは時間足を切り替えたり、手動で値を比較したりすることなく、上位時間足のモメンタムの方向と強さを素早く評価できます。
特徴:
* **主な機能:** 選択した上位時間足のストキャスティクス K 値を表示します。
* **補助的な機能:** 前回の確定値と比較した傾きに基づいて、ストキャスティクス K のプロットに色を付けます。
* 緑: 現在のストキャスティクス K 値が前回の確定値より高く、上位時間足で上昇モメンタムが増加していることを示します。
* 赤: 現在のストキャスティクス K 値が前回の確定値より低く、上位時間足で下降モメンタムが増加していることを示します。
仕組み:
* スクリプトは、ユーザー定義の期間と選択された上位時間足を使用して、標準的な計算式でストキャスティクス K 値を計算します。
* 次に、現在の高次時間枠のストキャスティクス K 値を、`request.security` と `lookahead=barmerge.lookahead_on` を使用して取得した*前回の確定値*と比較します。
* これら 2 つの値の差が傾きを決定し、プロットの色で表されます。
使い方:
1. このスクリプトをチャートに追加します。
2. スクリプトの設定で「上位時間枠」と「ストキャスティクスの期間」を設定します。
3. 上位時間足のストキャスティクス K 値のプロットとその色の変化を観察します。色は、上位時間足のモメンタムの方向を素早く視覚的に示します。
`request.security` と `lookahead=barmerge.lookahead_on` に関する重要な注意事項:
このスクリプトは、`request.security(..., lookahead=barmerge.lookahead_on)` を使用して、上位時間足のストキャスティクス K の*前回の確定値*を取得します。これは、傾きを正確に計算するために重要です。`lookahead=barmerge.lookahead_on` は、非オフセット式で使用すると過去のバーでルックアヘッドバイアスを引き起こす可能性がありますが、この場合、上位時間足の*最後の確定値*にアクセスするために使用されており、この計算には有効かつ必要なアプローチです。現在の高次時間枠の値は、この*既に確定した*過去の値と比較されるため、傾きの計算と結果として生じる色の変化は、信頼できるデータに基づいており、リペイントしないことが保証されます。
[blackat] L2 Bull and Bear Heaven LineOVERVIEW
The L2 Bull and Bear Heaven Line script is a custom indicator designed to visualize trend directions using Exponential Moving Average (EMA)-based lines and generate trade signals based on crossovers between those lines. It also incorporates an RSI-like feature to provide additional insight into overbought and oversold conditions.
FEATURES
Utilizes two EMAs: a longer-term "Heaven Line" (default 60 bars) and a shorter-term "Trading Line" (default 30 bars).
Generates buy/sell signals based on crossovers between the "Trading Line" and "Heaven Line".
Identifies potential turning points in the market, indicating shifts from bullish to bearish or vice versa.
Includes an "Operation Line" similar to RSI, aiding in detecting overbought/oversold levels.
HOW TO USE
Add the script to your TradingView chart.
Observe the crossovers between the "Trading Line" and "Heaven Line":
Buy signal when the "Trading Line" crosses above the "Heaven Line".
Sell signal when the "Trading Line" crosses below the "Heaven Line".
Monitor the "Operation Line" for additional confirmation:
Secondary sell signal when the "Operation Line" drops below 90% and there is downward price action.
Complementary buy signal when the "Operation Line" rises above 10% and there is upward price action.
Consider the identified trend direction and potential turning points to make informed trading decisions.
LIMITATIONS
The effectiveness of the signals depends on the chosen time frame and specific market conditions.
False signals may occur due to volatile price movements or rapid changes in market sentiment.
NOTES
This script combines traditional technical analysis tools like EMAs with an RSI-like approach to enhance decision-making processes. Users should backtest the strategy under various market scenarios before implementing it in live trading.
THANKS
Special thanks to the contributors whose work inspired parts of this script.
Trend Filter (2-pole) [BigBeluga]Trend Filter (2-pole)
The Trend Filter (2-pole) is an advanced trend-following indicator based on a two-pole filter, which smooths out market noise while effectively highlighting trends and their strength. It incorporates color gradients and support/resistance dots to enhance trend visualization and decision-making for traders.
SP500:
🔵What is a Two-Pole Filter?
A two-pole filter is a digital signal processing technique widely used in electronics, control systems, and time series data analysis to smooth data and reduce noise.
//@function Two-pole filter
//@param src (series float) Source data (e.g., price)
//@param length (float) Length of the filter (higher value means smoother output)
//@param damping (float) Damping factor for the filter
//@returns (series float) Filtered value
method two_pole_filter(float src, int length, float damping) =>
// Calculate filter coefficients
float omega = 2.0 * math.pi / length
float alpha = damping * omega
float beta = math.pow(omega, 2)
// Initialize the filter variables
var float f1 = na
var float f2 = na
// Update the filter
f1 := nz(f1 ) + alpha * (src - nz(f1 ))
f2 := nz(f2 ) + beta * (f1 - nz(f2 ))
f2
It operates using two cascaded smoothing stages (poles), allowing for a more refined and responsive output compared to simple moving averages or other basic filters.
Two-pole filters are particularly valued for their ability to maintain smooth transitions while reducing lag, making them ideal for applications where precision and responsiveness are critical.
In trading, this filter helps detect trends by smoothing price data while preserving significant directional changes.
🔵Key Features of the Indicator:
Gradient-Colored Trend Filter Line: The main filter line dynamically changes color based on trend strength and direction:
- Green: Strong uptrend.
- Red: Strong downtrend.
- Yellow: Indicates a transition phase, signaling potential trend shifts.
Support and Resistance Dots with Signals:
- Dots are plotted below the filter line during uptrends and above it during downtrends.
- These dots represent consecutive rising or falling conditions of the filter line, which traders can set in the settings (e.g., the number of consecutive rises or falls required).
- The dots often act as dynamic support or resistance levels, providing valuable guidance during trends.
- Trend Signals:
Customizable Sensitivity: The indicator allows traders to adjust the filter length, damping factor, and the threshold for rising/falling conditions, enabling it to adapt to different trading styles and timeframes.
Bar Color Option: The indicator can optionally color bars to match the gradient of the filter line, enhancing visual clarity of trends directly on the price chart.
🔵How It Works:
The Trend Filter (2-pole) smooths price data using a two-pole filter, which reduces noise and highlights the underlying trend.
The gradient coloring of the filter line helps traders visually assess the strength and direction of trends.
Rising and falling conditions of the filter line are tracked, and dots are plotted when consecutive conditions meet the threshold, acting as potential support or resistance levels during trends.
The yellow transition color signals periods of indecision, helping traders anticipate potential reversals or consolidations.
🔵Use Cases:
Identify and follow strong uptrends and downtrends with gradient-based visual cues.
Use the yellow transition color to anticipate trend shifts or consolidation zones.
Leverage the plotted dots as dynamic support and resistance levels to refine entry and exit strategies.
Combine with other indicators for confirmation of trends and reversals.
This indicator is perfect for traders who want a visually intuitive and highly customizable tool to spot trends, gauge their strength, and make informed trading decisions.
Highs & Lows RTH/OVN/IBs/D/W/M/YOverview
Plots the highs and lows of RTH, OVN/ETH, IBs of those sessions, previous Day, Week, Month, and Year.
Features
Allows the user to enable/disable plotting the high/low of each period.
Lines' length, offset, and colors can be customized
Labels' position, size, color, and style can be customized
Support
Questions, feedbacks, and requests are welcomed. Please feel free to use Comments or direct private message via TradingView.
Disclaimer
This stock chart indicator provided is for informational purposes only and should not be considered as financial or investment advice. The data and information presented in this indicator are obtained from sources believed to be reliable, but we do not warrant its completeness or accuracy.
Users should be aware that:
Any investment decisions made based on this indicator are at your own risk.
The creators and providers of this indicator disclaim all liability for any losses, damages, or other consequences resulting from its use. By using this stock chart indicator, you acknowledge and accept the inherent risks associated with trading and investing in financial markets.
Release Date: 2025-01-17
Release Version: v1 r1
Release Notes Date: 2025-01-17
Multi-Band Comparison Strategy (CRYPTO)Multi-Band Comparison Strategy (CRYPTO)
Optimized for Cryptocurrency Trading
This Pine Script strategy is built from the ground up for traders who want to take advantage of cryptocurrency volatility using a confluence of advanced statistical bands. The strategy layers Bollinger Bands, Quantile Bands, and a unique Power-Law Band to map out crucial support/resistance zones. It then focuses on a Trigger Line—the lower standard deviation band of the upper quantile—to pinpoint precise entry and exit signals.
Key Features
Bollinger Band Overlay
The upper Bollinger Band visually shifts to yellow when price exceeds it, turning black otherwise. This offers a straightforward way to gauge heightened momentum or potential market slowdowns.
Quantile & Power-Law Integration
The script calculates upper and lower quantile bands to assess probabilistic price extremes.
A Power-Law Band is also available to measure historically significant return levels, providing further insight into overbought or oversold conditions in fast-moving crypto markets.
Standard Deviation Trigger
The lower standard deviation band of the upper quantile acts as the strategy’s trigger. If price consistently holds above this line, the strategy interprets it as a strong bullish signal (“green” zone). Conversely, dipping below indicates a “red” zone, signaling potential reversals or exits.
Consecutive Bar Confirmation
To reduce choppy signals, you can fine-tune the number of consecutive bars required to confirm an entry or exit. This helps filter out noise and false breaks—critical in the often-volatile crypto realm.
Adaptive for Multiple Timeframes
Whether you’re scalping on a 5-minute chart or swing trading on daily candles, the strategy’s flexible confirmation and overlay options cater to different market conditions and trading styles.
Complete Plot Customization
Easily toggle visibility of each band or line—Bollinger, Quantile, Power-Law, and more.
Built-in Simple and Exponential Moving Averages can be enabled to further contextualize market trends.
Why It Excels at Crypto
Cryptocurrencies are known for rapid price swings, and this strategy addresses exactly that by combining multiple statistical methods. The quantile-based confirmation reduces noise, while Bollinger and Power-Law bands help highlight breakout regions in trending markets. Traders have reported that it works seamlessly across various coins and tokens, adapting its triggers to each asset’s unique volatility profile.
Give it a try on your favorite cryptocurrency pairs. With advanced data handling, crisp visual cues, and adjustable confirmation logic, the Multi-Band Comparison Strategy provides a robust framework to capture profitable moves and mitigate risk in the ever-evolving crypto space.
AMG Supply and Demand ZonesSupply and Demand Zones Indicator
This indicator identifies and visualizes supply and demand zones on the chart to help traders spot key areas of potential price reversals or continuations. The indicator uses historical price data to calculate zones based on high/low ranges and a customizable ATR-based fuzz factor.
Key Features:
Back Limit: Configurable look-back period to identify zones.
Zone Types: Options to display weak, untested, and turncoat zones.
Customizable Parameters: Adjust fuzz factor and visualization settings.
Usage:
Use this indicator to enhance your trading strategy by identifying key supply and demand areas where price is likely to react.
You can customize this further based on how you envision users benefiting from your indicator. Let me know if you'd like to add or adjust anything!
permutation█ OVERVIEW
This library provides functions for generating permutations of string or float arrays, using an iterative approach where pine has no recursion. It supports allowing/limiting duplicate elements and handles large result sets by segmenting them into manageable chunks within custom Data types. The most combinations will vary, but the highest is around 250,000 unique combinations. depending on input array values and output length. it will return nothing if the input count is too low.
█ CONCEPTS
This library addresses two key challenges in Pine Script:
• Recursion Depth Limits: Pine has limitations on recursion depth. This library uses an iterative, stack-based algorithm to generate permutations, avoiding recursive function calls that could exceed these limits.
• Array Size Limits: Pine arrays have size restrictions. This library manages large permutation sets by dividing them into smaller segments stored within a custom Data or DataFloat type, using maps for efficient access.
█ HOW TO USE
1 — Include the Library: Add this library to your script using:
import kaigouthro/permutation/1 as permute
2 — Call the generatePermutations Function:
stringPermutations = permute.generatePermutations(array.from("a", "b", "c"), 2, 1)
floatPermutations = permute.generatePermutations(array.from(1.0, 2.0, 3.0), 2, 1)
• set : The input array of strings or floats.
• size : The desired length of each permutation.
• maxDuplicates (optional): The maximum allowed repetitions of an element within a single permutation. Defaults to 1.
3 — Access the Results: The function returns a Data (for strings) or DataFloat (for floats) object. These objects contain:
• data : An array indicating which segments are present (useful for iterating).
• segments : A map where keys represent segment indices and values are the actual permutation data within that segment.
Example: Accessing Permutations
for in stringPermutations.segments
for in currentSegment.segments
// Access individual permutations within the segment.
permutation = segmennt.data
for item in permutation
// Use the permutation elements...
█ TYPES
• PermutationState / PermutationStateFloat : Internal types used by the iterative algorithm to track the state of permutation generation.
• Data / DataFloat : Custom types to store and manage the generated permutations in segments.
█ NOTES
* The library prioritizes handling potentially large permutation sets. 250,000 i about the highest achievable.
* The segmentation logic ensures that results are accessible even when the total number of permutations exceeds Pine's array size limits.
----
Library "permutation"
This library provides functions for generating permutations of user input arrays containing either strings or floats. It uses an iterative, stack-based approach to handle potentially large sets and avoid recursion limitation. The library supports limiting the number of duplicate elements allowed in each permutation. Results are stored in a custom Data or DataFloat type that uses maps to segment large permutation sets into manageable chunks, addressing Pine Script's array size limitations.
generatePermutations(set, size, maxDuplicates)
> Generates permutations of a given size from a set of strings or floats.
Parameters:
set (array) : (array or array) The set of strings or floats to generate permutations from.
size (int) : (int) The size of the permutations to generate.
maxDuplicates (int) : (int) The maximum number of times an element can be repeated in a permutation.
Returns: (Data or DataFloat) A Data object for strings or a DataFloat object for floats, containing the generated permutations.
stringPermutations = generatePermutations(array.from("a", "b", "c"), 2, 1)
floatPermutations = generatePermutations(array.from(1.0, 2.0, 3.0), 2, 1)
generatePermutations(set, size, maxDuplicates)
Parameters:
set (array)
size (int)
maxDuplicates (int)
PermutationState
PermutationState
Fields:
data (array) : (array) The current permutation being built.
index (series int) : (int) The current index being considered in the set.
depth (series int) : (int) The current depth of the permutation (number of elements).
counts (map) : (map) Map to track the count of each element in the current permutation (for duplicates).
PermutationStateFloat
PermutationStateFloat
Fields:
data (array) : (array) The current permutation being built.
index (series int) : (int) The current index being considered in the set.
depth (series int) : (int) The current depth of the permutation (number of elements).
counts (map) : (map) Map to track the count of each element in the current permutation (for duplicates).
Data
Data
Fields:
data (array) : (array) Array to indicate which segments are present.
segments (map) : (map) Map to store permutation segments. Each segment contains a subset of the generated permutations.
DataFloat
DataFloat
Fields:
data (array) : (array) Array to indicate which segments are present.
segments (map) : (map) Map to store permutation segments. Each segment contains a subset of the generated permutations.
random_values█ OVERVIEW
This library provides helper functions for generating random values of various types, including numbers, letters, words, booleans, and arrays. It simplifies the creation of random data within Pine Script™ for testing, simulations, or other applications.
█ HOW TO USE
Import the library into your script:
import kaigouthro/random_values/1 as rv
Then, use the functions provided:
// Get a random integer between 5 and 15
int randInt = rv.intVal(5, 15)
// Generate a random word with 8 characters
string randWord = rv.word(8)
// Create a boolean array with 5 elements
array randBoolArray = rv.boolArray(5)
// And other options! See below for details.
█ FEATURES
• num(float min, float max) : Returns a random float between *min* and *max*. (Internal helper function, not exported).
• letter() : Returns a random lowercase letter (a-z).
• word(int size = 0) : Returns a random word. *size* specifies the length (default: random length between 3 and 10).
• words(int size = 20) : Returns a string of random words separated by spaces, where *size* specifies the number of words.
• boolVal() : Returns a random boolean (true or false).
• floatVal(float min = 0, float max = 100, int precision = 2) : Returns a random float with specified *min*, *max*, and *precision*.
• intVal(int min = 1, int max = 100) : Returns a random integer between *min* and *max*.
• stringArray(int size = 0) : Returns an array of random words. *size* specifies the array length (default: random between 3 and 10).
• floatArray(int size = 0, float min = 0, float max = 100, int precision = 2) : Returns an array of random floats with specified parameters. *size* determines the array length.
• intArray(int size = 0, int min = 1, int max = 100) : Returns an array of random integers with specified parameters. *size* determines the array length.
• boolArray(int size = 0) : Returns an array of random booleans. *size* specifies the array length (default: random between 3 and 10).
█ NOTES
* This library uses the `kaigouthro/into/2` library for type conversions. Make sure it's available.
* Default values are provided for most function parameters, offering flexibility in usage.
█ LICENSE
This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
```
**Changes and Rationale:**
* **OVERVIEW:** Clearly states the library's purpose.
* **HOW TO USE:** Provides essential import and usage instructions with Pine Script™ examples.
* **FEATURES:** Details each function with its parameters, types, and descriptions. Emphasizes *size*, *min*, *max*, and *precision* as common input parameters using italics. Uses custom bulleted lists.
* **NOTES:** Includes important information about dependencies and defaults.
* **LICENSE:** Directly links to the license URL using the proper ` ` tag.
* **Formatting:** Uses full block and em space for section titles, consistent bolding, and improved spacing for readability. Removes unnecessary blank lines.
This format improves clarity, making the library documentation easy to understand for TradingView users. Remember to test the rendering on TradingView to catch any formatting issues.
Library "random_values"
A library containing Random value generating helper functions.
letter()
Random letter generator.
Returns: (string) A random lowercase letter.
word(size)
Random word generator.
Parameters:
size (int) : (int) The desired length of the word. If 0 or not provided, a random length between 3 and 10 is used.
Returns: (string) A random word.
words(size)
Random words generator.
Parameters:
size (int) : (int) The number of words to generate. If 0 or not provided, a random number between 3 and 10 is used.
Returns: (string) A string of random words separated by spaces.
boolVal()
Random boolean generator.
Returns: (bool) A random boolean value (true or false).
floatVal(min, max, precision)
Random float number generator.
Parameters:
min (float) : (float) The minimum float value. Defaults to 0.
max (float) : (float) The maximum float value. Defaults to 100.
precision (int) : (int) The number of decimal places. Defaults to 2.
Returns: (float) A random float number.
intVal(min, max)
Random integer number generator.
Parameters:
min (int) : (int) The minimum integer value. Defaults to 1.
max (int) : (int) The maximum integer value. Defaults to 100.
Returns: (int) A random integer number.
stringArray(size)
Random string array generator.
Parameters:
size (int) : (int) The desired size of the array. If 0 or not provided, a random size between 3 and 10 is used.
Returns: (array) An array of random words.
floatArray(size, min, max, precision)
Random float array generator.
Parameters:
size (int) : (int) The desired size of the array. If 0 or not provided, a random size between 3 and 10 is used.
min (float) : (float) The minimum float value. Defaults to 0.
max (float) : (float) The maximum float value. Defaults to 100.
precision (int) : (int) The number of decimal places. Defaults to 2.
Returns: (array) An array of random float numbers.
intArray(size, min, max)
Random integer array generator.
Parameters:
size (int) : (int) The desired size of the array. If 0 or not provided, a random size between 3 and 10 is used.
min (int) : (int) The minimum integer value. Defaults to 1.
max (int) : (int) The maximum integer value. Defaults to 100.
Returns: (array) An array of random integer numbers.
boolArray(size)
Random boolean array generator.
Parameters:
size (int) : (int) The desired size of the array. If 0 or not provided, a random size between 3 and 10 is used.
Returns: (array) An array of random boolean values.
MEMEQUANTMEMEQUANT
This script is a comprehensive and specialized tool designed for tracking trends and money flow within meme coins and DEX tokens. By combining various features such as trend lines, Fibonacci levels, and category-based indices, it helps traders make informed decisions in highly volatile markets.
Key Features:
1. Category-Based Indices:
• Tracks the performance of token categories like:
• AI Agent Tokens
• AI Tokens
• Animal Tokens
• Murad Picks
• Each category consists of leader tokens, which are selected based on their higher market cap and trading volume. These tokens act as benchmarks for their respective categories.
• Visualizes category indices in a line chart to identify trends and compare money flow between categories.
2. Fibonacci Correction Zones:
• Highlights key retracement levels (e.g., 60%, 70%, 80%).
• These levels are crucial for identifying potential reversal zones, commonly observed in meme coin trading patterns.
• Fully customizable to match individual trading strategies.
3. Trend Lines:
• Automatically detects major support and resistance levels.
• Separates long-term and short-term trend lines, allowing traders to focus on significant price movements.
4. Enhanced Info Table:
• Provides real-time insights, including:
• % Distance from All-Time High (ATH)
• Current Trading Volume
• 50-bar Average Volume
• Volume Change Percentage
• Displays information in an easy-to-read table on the chart.
5. Customizable Settings:
• Users can adjust transparency, colors, and ranges for Fibonacci zones, trend lines, and the table.
• Enables or disables individual features (e.g., Fibonacci, trend lines, table) based on preferences.
How It Works:
1. Tracking Money Flow Across Categories:
• The script calculates the market cap to volume ratio for each category of tokens to help identify the dominant trend.
• A higher ratio indicates greater liquidity and stability, while a lower ratio suggests higher volatility or price manipulation.
2. Identifying Retracement Patterns:
• Leverages common retracement behaviors (e.g., 70% correction levels) observed in meme coins to detect potential reversal zones.
• Combines this with trend line analysis for additional confirmation.
3. Leader Tokens as Indicators:
• Each category is represented by its leader tokens, which have historically higher liquidity and market cap. This allows the script to accurately reflect the overall trend in each category.
When to Use:
• Trend Analysis: To identify which category (e.g., AI Tokens or Animal Tokens) is leading the market.
• Reversal Zones: To spot potential support or resistance levels using Fibonacci zones.
• Money Flow: To understand how capital is moving across different token categories in real time.
Who Is This For?
This script is tailored for:
• Traders specializing in meme coins and DEX tokens.
• Those looking for an edge in trend-based trading by analyzing market cap, volume, and retracement levels.
• Anyone aiming to track money flow dynamics between different token categories.
Future Updates:
This is the initial version of the script. Future updates may include:
• Support for additional token categories and DEX data.
• More advanced pattern recognition and alerts for volume and price anomalies.
• Enhanced visualization for historical data trends.
With this tool, traders can combine money flow analysis with the 60-70% retracement strategy, turning it into a powerful assistant for navigating the fast-paced world of meme coins and DEX tokens.
This script is designed to provide meaningful insights and practical utility for traders, adhering to TradingView’s standards for originality, clarity, and user value.
ADX, RSI, & TSI utilized as ART [by KeremErtem]The "ADX, RSI, & TSI utilized as ART" script is an advanced technical analysis tool designed by Kerem Ertem to help traders identify trend direction, strength, and potential reversals. It integrates the Average Directional Index (ADX), Relative Strength Index (RSI), and True Strength Index (TSI) into a cohesive, user-friendly indicator known as ART (Adaptive Relative Trend) .
What it does:
Trend Detection: Utilizes ADX to identify the strength and direction of trends.
Momentum Analysis: Uses RSI to gauge the speed and change of price movements.
Signal Smoothing: Incorporates TSI to reduce noise and provide clearer signals.
How it works:
Input Settings: Customize the source (hlc3), signal period (l1), and lookback range (l2) to tailor the indicator to your trading strategy.
Angle Calculation (ACI): The script calculates the angle of price movements using a custom function, which combines the lowest and highest prices with moving averages to create a smoother representation of trend angles.
Weighted Average: The ACI function is applied to the source price to derive a weighted average, which serves as the foundation for further calculations.
RSI Integration: The script calculates the RSI based on the weighted average price and further refines it using the ACI function to enhance signal accuracy.
ADX Calculation: ADX values are computed and adjusted using the ACI function to provide a clearer indication of trend strength and direction.
ART Indicator: The combined results of the RSI and ADX calculations form the ART indicator, which is plotted alongside trend lines and bands for comprehensive trend analysis.
Bands and Trend Lines: The script plots upper, lower, and center bands based on standard deviation and moving averages, providing visual cues for potential support and resistance levels.
How to use it:
Customization: Adjust the signal period, lookback range, RSI length, and ADX settings to fit your trading preferences.
Interpretation: Green ART signal lines indicate bullish trends, while red lines indicate bearish trends. The trend line color changes from cyan to magenta based on the trend direction.
Bands: Use the upper and lower bands as potential entry and exit points, with the center line acting as a trend confirmation.
This script offers a comprehensive approach to trend and momentum analysis, making it a valuable tool for traders seeking to enhance their trading strategies with advanced technical indicators.
ICT Dealing RangeICT Dealing Range
This indicator identifies and plots ICT (Inner Circle Trader) Dealing Ranges - key institutional areas where smart money accumulates or distributes positions before significant moves.
What is a Dealing Range?
A Dealing Range is a significant price area where institutional traders accumulate or distribute their positions. These ranges form through a specific sequence of price movements that indicate institutional order flow:
Bullish Dealing Range Sequence:
1. Initial High (H)
2. Initial Low (L)
3. Higher High (HH)
4. Lower Low (LL)
5. Break above HH (confirmation)
Bearish Dealing Range Sequence:
1. Initial Low (L)
2. Initial High (H)
3. Lower Low (LL)
4. Higher High (HH)
5. Break below LL (confirmation)
My Trading Strategy
Entry Methods:
1. Range Extreme Retests:
- After range formation, wait for price to return to either extreme
- Long entries at range bottom with stops below
- Short entries at range top with stops above
2. Mid-Line Strategy:
- Use the mid-line as a pivot point for reversals
- Long entries on mid-line bounce with stops below
- Short entries on mid-line rejection with stops above
Stop Loss Placement:
- When entering at extremes: Place stops beyond the mid
- When entering at mid-line: Place stops beyond the opposing extreme
- Always respect the structure's boundaries
Take Profit Targets:
- Minimum 2:1 Risk-Reward ratio
- For extreme entries: Target the opposite extreme
- For mid-line entries: Target the nearest extreme
Risk Management
- Never enter without a clear invalidation point
- Maintain minimum 2:1 RR ratio
- Consider market structure and higher timeframe context
Indicator Features
- Auto-detection of dealing range patterns
- Color-coded boxes (green for bullish, red for bearish)
- Optional mid-line display
- Customizable colors and styles
- Adjustable pivot lookback periods
Notes
This tool is based on ICT concepts but should be used in conjunction with other forms of analysis. The dealing range provides a framework for understanding institutional order flow, but proper risk management and market context are essential for successful trading.
Remember: The best trades often come from clean retests of these ranges after their initial formation. Patience in waiting for proper setups is key to successful implementation.
Falcon Liquidity Grab StrategyHow to Use This Script for Commodities and Indices
Best Timeframes: Start with 15-minute charts but test on higher timeframes like 1 hour for indices.
Risk Settings: Adjust the stop_loss_points and take_profit_multiplier to match the volatility of the chosen instrument.
KJS-- Gost Pivot MAKJS Ghost Pivot Moving Average
This indicator calculates a "Ghost Pivot" by estimating where the monthly pivot level would be if the current candle's close represented the end of the month. The calculation uses:
• The current month's high and low from regular trading hours (RTH).
• The current candle's close, which includes both premarket and after-hours data.
It also smooths the ghost pivot using a customizable simple moving average (SMA).
Features:
• Plots the current month's high (blue) and low (yellow) based on RTH data.
• Calculates and plots a dynamic pivot (purple line) as the average of the monthly high, low, and current close (HLC3).
• Includes a customizable SMA length for smoother pivot tracking (default: 3).
This indicator helps traders anticipate potential monthly pivot levels in real-time while visualizing key support and resistance areas.
Timed Ranges [mktrader]The Timed Ranges indicator helps visualize price ranges that develop during specific time periods. It's particularly useful for analyzing market behavior in instruments like NASDAQ, S&P 500, and Dow Jones, which often show reactions to sweeps of previous ranges and form reversals.
### Key Features
- Visualizes time-based ranges with customizable lengths (30 minutes, 90 minutes, etc.)
- Tracks high/low range development within specified time periods
- Shows multiple cycles per day for pattern recognition
- Supports historical analysis across multiple days
### Parameters
#### Settings
- **First Cycle (HHMM-HHMM)**: Define the time range of your first cycle. The duration of this range determines the length of all subsequent cycles (e.g., "0930-1000" creates 30-minute cycles)
- **Number of Cycles per Day**: How many consecutive cycles to display after the first cycle (1-20)
- **Maximum Days to Display**: Number of historical days to show the ranges for (1-50)
- **Timezone**: Select the appropriate timezone for your analysis
#### Style
- **Box Transparency**: Adjust the transparency of the range boxes (0-100)
### Usage Example
To track 30-minute ranges starting at market open:
1. Set First Cycle to "0930-1000" (creates 30-minute cycles)
2. Set Number of Cycles to 5 (will show ranges until 11:30)
3. The indicator will display:
- Range development during each 30-minute period
- Visual progression of highs and lows
- Color-coded cycles for easy distinction
### Use Cases
- Identify potential reversal points after range sweeps
- Track regular time-based support and resistance levels
- Analyze market structure within specific time windows
- Monitor range expansions and contractions during key market hours
### Tips
- Use in conjunction with volume analysis for better confirmation
- Pay attention to breaks and sweeps of previous ranges
- Consider market opens and key session times when setting cycles
- Compare range sizes across different time periods for volatility analysis
[volfgang] Pivot Levels (Open, Close, High, Low)This script provides a clear and consistent way to track key price levels from Weekly and Daily bars, directly on your current chart interval.
The default colours are;
Today & This Week Open = White
Yesterday & Previous Week Open = Cream
Yesterday's High = Red
Yesterday's Low = Green
Weekly Pivots are 2px, and Daily Pivots are 1px.
Instead of requiring manual referencing of daily or weekly charts, these significant levels are automatically drawn and updated in real time, extending to the right as new bars form.
It adds value by helping traders quickly identify potential support/resistance zones and compare intraday price action with higher-timeframe pivots. This approach can aid in scalping, day trading, or swing trading strategies that rely on past price levels for trade entries, exits, or stop loss placement.
Daily Pivots Displayed Intraday
The script imports the previous day’s High, Low, Open, and Close and draws lines on the current chart, so you can see exactly where those levels lie on any intraday timeframe. You can easily change the colour of these lines in the menu.
Instead of switching between multiple charts for daily references, you can keep an intraday chart open and still watch how price behaves around these important daily pivots.
Weekly Pivots for Broader Context
In addition to daily levels, it also shows the previous week’s Open and Close. This feature helps traders who want to maintain a broader perspective and gauge the market’s weekly trend or bias while remaining on lower timeframes.
Automatic Line & Label Management
Each new trading day triggers a “session change” in the code, prompting the script to delete old lines and labels for daily levels. This keeps your chart from getting cluttered with outdated lines.
Weekly lines and labels follow the same approach, ensuring only the most recent weekly levels are highlighted.
Real-Time Extension
Lines are continuously extended to the right as new bars print, ensuring that you always have an updated view of your key price levels without any manual adjustments.
On the last bar, the script shifts to a time-based coordinate system for seamless visual extension.
Minimal Recalculation
This script uses security() calls in a carefully optimized way to reduce unnecessary recalculations and avoid repaint issues. By referencing open , close , etc., the lines remain fixed once the daily (or weekly) candle is confirmed.
Flexible Usage
You can apply this script to any symbol on TradingView. It’s especially beneficial for Forex pairs, indices, futures, or cryptocurrencies where you want to track significant past levels.
If you’re a scalper looking for areas of likely reaction, or a swing trader watching weekly opens for trend confirmation, these levels can be integral to your technical approach.
How to Use
Add to Chart: Click the “Add to Favorite Indicators” or “Apply to Chart” button once published.
Enable or Disable Previous Day Bars: Use the script’s input to toggle the display of previous day’s High, Low, Open, and Close lines if you only want weekly lines (or vice versa).
Customize Visuals: You can change line colors, width, and label text in the “Style” or “Inputs” tab. Adjust them to fit your preferred color scheme.
Interpretation:
Daily levels typically carry relevance for the next trading session. They can be used for intraday support/resistance, breakout checks, or gap fills.
Weekly levels help identify more prominent zones for bigger moves or for understanding overall sentiment from the prior week.
Conceptual Underpinnings
Support/Resistance: Past opens/closes often act as support or resistance because they represent important points of reference (where trading started or ended during a prior session).
Market Psychology: Many traders watch daily or weekly closes to gauge momentum and bias, which can become self-fulfilling as more participants join around those levels.
Improved Situational Awareness: By having these levels automatically drawn and updated, traders avoid missing critical areas where price may pivot.
This script is intentionally open-source to help traders study and personalize it.
By merging daily and weekly pivot concepts in a single script, it provides a convenient and efficient tool—rather than a simple mashup, it unifies two timeframes that are crucial in short-term and medium-term trading decisions.
Remember that these levels alone do not constitute a complete trading system; they are best used as part of a broader strategy involving risk management, additional technical signals, and market context.
SCE Price Action SuiteThis is an indicator designed to use past market data to mark key price action levels as well as provide a different kind of insight. There are 8 different features in the script that users can turn on and off. This description will go in depth on all 8 with chart examples.
#1 Absorption Zones
I defined Absorption Zones as follows.
//----------------------------------------------
//---------------Absorption---------------------
//----------------------------------------------
box absorptionBox = na
absorptionBar = ta.highest(bodySize, absorptionLkb)
bsab = ta.barssince(bool(ta.change(absorptionBar)))
if bsab == 0 and upBar and showAbsorption
absorptionBox := box.new(left = bar_index - 1, top = close, right = bar_index + az_strcuture, bottom = open, border_color = color.rgb(0, 80, 75), border_width = boxLineSize, bgcolor = color.rgb(0, 80, 75))
absorptionBox
else if bsab == 0 and downBar and showAbsorption
absorptionBox := box.new(left = bar_index - 1, top = close, right = bar_index + az_strcuture, bottom = open, border_color = color.rgb(105, 15, 15), border_width = boxLineSize, bgcolor = color.rgb(105, 15, 15))
absorptionBox
What this means is that absorption bars are defined as the bars with the largest bodies over a selected lookback period. Those large bodies represent areas where price may react. I was inspired by the concept of a Fair Value Gap for this concept. In that body price may enter to be a point of support or resistance, market participants get “absorbed” in the area so price can continue in whichever direction.
#2 Candle Wick Theory/Strategy
I defined Candle Wick Theory/Strategy as follows.
//----------------------------------------------
//---------------Candle Wick--------------------
//----------------------------------------------
highWick = upBar ? high - close : downBar ? high - open : na
lowWick = upBar ? open - low : downBar ? close - low : na
upWick = upBar ? close + highWick : downBar ? open + highWick : na
downWick = upBar ? open - lowWick : downBar ? close - lowWick : na
downDelivery = upBar and downBar and high > upWick and highWick > lowWick and totalSize > totalSize and barstate.isconfirmed and session.ismarket
upDelivery = downBar and upBar and low < downWick and highWick < lowWick and totalSize > totalSize and barstate.isconfirmed and session.ismarket
line lG = na
line lE = na
line lR = na
bodyMidpoint = math.abs(body) / 2
upWickMidpoint = math.abs(upWickSize) / 2
downWickkMidpoint = math.abs(downWickSize) / 2
if upDelivery and showCdTheory
cpE = chart.point.new(time, bar_index - 1, downWickkMidpoint)
cpE2 = chart.point.new(time, bar_index + bl, downWickkMidpoint)
cpG = chart.point.new(time, bar_index + bl, downWickkMidpoint * (1 + tp))
cpR = chart.point.new(time, bar_index + bl, downWickkMidpoint * (1 - sl))
cpG1 = chart.point.new(time, bar_index - 1, downWickkMidpoint * (1 + tp))
cpR1 = chart.point.new(time, bar_index - 1, downWickkMidpoint * (1 - sl))
lG := line.new(cpG1, cpG, xloc.bar_index, extend.none, color.green, line.style_solid, 1)
lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.white, line.style_solid, 1)
lR := line.new(cpR1, cpR, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
lR
else if downDelivery and showCdTheory
cpE = chart.point.new(time, bar_index - 1, upWickMidpoint)
cpE2 = chart.point.new(time, bar_index + bl, upWickMidpoint)
cpG = chart.point.new(time, bar_index + bl, upWickMidpoint * (1 - tp))
cpR = chart.point.new(time, bar_index + bl, upWickMidpoint * (1 + sl))
cpG1 = chart.point.new(time, bar_index - 1, upWickMidpoint * (1 - tp))
cpR1 = chart.point.new(time, bar_index - 1, upWickMidpoint * (1 + sl))
lG := line.new(cpG1, cpG, xloc.bar_index, extend.none, color.green, line.style_solid, 1)
lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.white, line.style_solid, 1)
lR := line.new(cpR1, cpR, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
lR
First I get the size of the wicks for the top and bottoms of the candles. This depends on if the bar is red or green. If the bar is green the wick is the high minus the close, if red the high minus the open, and so on. Next, the script defines the upper and lower bounds of the wicks for further comparison. If the candle is green, it's the open price minus the bottom wick. If the candle is red, it's the close price minus the bottom wick, and so on. Next we have the condition for when this strategy is present.
Down delivery:
Occurs when the previous candle is green, the current candle is red, and:
The high of the current candle is above the upper wick of the previous candle.
The size of the current candle's top wick is greater than its bottom wick.
The total size of the previous candle is greater than the total size of the current candle.
The current bar is confirmed (barstate.isconfirmed).
The session is during market hours (session.ismarket).
Up delivery:
Occurs when the previous candle is red, the current candle is green, and:
The low of the current candle is below the lower wick of the previous candle.
The size of the current candle's bottom wick is greater than its top wick.
The total size of the previous candle is greater than the total size of the current candle.
The current bar is confirmed.
The session is during market hours
Then risk is plotted from the percentage that users can input from an ideal entry spot.
#3 Candle Size Theory
I defined Candle Size Theory as follows.
//----------------------------------------------
//---------------Candle displacement------------
//----------------------------------------------
line lECD = na
notableDown = bodySize > bodySize * candle_size_sensitivity and downBar and session.ismarket and barstate.isconfirmed
notableUp = bodySize > bodySize * candle_size_sensitivity and upBar and session.ismarket and barstate.isconfirmed
if notableUp and showCdSizeTheory
cpE = chart.point.new(time, bar_index - 1, close)
cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)
lECD := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.rgb(0, 80, 75), line.style_solid, 3)
lECD
else if notableDown and showCdSizeTheory
cpE = chart.point.new(time, bar_index - 1, close)
cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)
lECD := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.rgb(105, 15, 15), line.style_solid, 3)
lECD
This plots candles that are “notable” or out of the ordinary. Candles that are larger than the last by a value users get to specify. These candles' highs or lows, if they are green or red, act as levels for support or resistance.
#4 Candle Structure Theory
I defined Candle Structure Theory as follows.
//----------------------------------------------
//---------------Structure----------------------
//----------------------------------------------
breakDownStructure = low < low and low < low and high > high and upBar and downBar and upBar and downBar and session.ismarket and barstate.isconfirmed
breakUpStructure = low > low and low > low and high < high and downBar and upBar and downBar and upBar and session.ismarket and barstate.isconfirmed
if breakUpStructure and showStructureTheory
cpE = chart.point.new(time, bar_index - 1, close)
cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)
lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.teal, line.style_solid, 3)
lE
else if breakDownStructure and showStructureTheory
cpE = chart.point.new(time, bar_index - 1, open)
cpE2 = chart.point.new(time, bar_index + bl_strcuture, open)
lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.red, line.style_solid, 3)
lE
It is a series of candles to create a notable event. 2 lower lows in a row, a lower high, then green bar, red bar, green bar is a structure for a breakdown. 2 higher lows in a row, a higher high, red bar, green bar, red bar for a break up.
#5 Candle Swing Structure Theory
I defined Candle Swing Structure Theory as follows.
//----------------------------------------------
//---------------Swing Structure----------------
//----------------------------------------------
line htb = na
line ltb = na
if totalSize * swing_struct_sense < totalSize and upBar and downBar and high > high and showSwingSturcture and session.ismarket and barstate.isconfirmed
cpS = chart.point.new(time, bar_index - 1, high)
cpE = chart.point.new(time, bar_index + bl_strcuture, high)
htb := line.new(cpS, cpE, xloc.bar_index, color = color.red, style = line.style_dashed)
htb
else if totalSize * swing_struct_sense < totalSize and downBar and upBar and low > low and showSwingSturcture and session.ismarket and barstate.isconfirmed
cpS = chart.point.new(time, bar_index - 1, low)
cpE = chart.point.new(time, bar_index + bl_strcuture, low)
ltb := line.new(cpS, cpE, xloc.bar_index, color = color.teal, style = line.style_dashed)
ltb
A bearish swing structure is defined as the last candle’s total size, times a scalar that the user can input, is less than the current candles. Like a size imbalance. The last bar must be green and this one red. The last high should also be less than this high. For a bullish swing structure the same size imbalance must be present, but we need a red bar then a green bar, and the last low higher than the current low.
#6 Fractal Boxes
I define the Fractal Boxes as follows
//----------------------------------------------
//---------------Fractal Boxes------------------
//----------------------------------------------
box b = na
int indexx = na
if bar_index % (n * 2) == 0 and session.ismarket and showBoxes
b := box.new(left = bar_index, top = topBox, right = bar_index + n, bottom = bottomBox, border_color = color.rgb(105, 15, 15), border_width = boxLineSize, bgcolor = na)
indexx := bar_index + 1
indexx
The idea of this strategy is that the market is fractal. It is considered impossible to be able to tell apart two different time frames from just the chart. So inside the chart there are many many breakouts and breakdowns happening as price bounces around. The boxes are there to give you the view from your timeframe if the market is in a range from a time frame that would be higher than it. Like if we are inside what a larger time frame candle’s range. If we break out or down from this, we might be able to trade it. Users can specify a lookback period and the box is that period’s, as an interval, high and low. I say as an interval because it is plotted every n * 2 bars. So we get a box, price moves, then a new box.
#7 Potential Move Width
I define the Potential Move Width as follows
//----------------------------------------------
//---------------Move width---------------------
//----------------------------------------------
velocity = V(n)
line lC = na
line l = na
line l2 = na
line l3 = na
line l4 = na
line l5 = na
line l6 = na
line l7 = na
line l8 = na
line lGFractal = na
line lRFractal = na
cp2 = chart.point.new(time, bar_index + n, close + velocity)
cp3 = chart.point.new(time, bar_index + n, close - velocity)
cp4 = chart.point.new(time, bar_index + n, close + velocity * 5)
cp5 = chart.point.new(time, bar_index + n, close - velocity * 5)
cp6 = chart.point.new(time, bar_index + n, close + velocity * 10)
cp7 = chart.point.new(time, bar_index + n, close - velocity * 10)
cp8 = chart.point.new(time, bar_index + n, close + velocity * 15)
cp9 = chart.point.new(time, bar_index + n, close - velocity * 15)
cpG = chart.point.new(time, bar_index + n, close + R)
cpR = chart.point.new(time, bar_index + n, close - R)
if ((bar_index + n) * 2 - bar_index) % n == 0 and session.ismarket and barstate.isconfirmed and showPredictionWidtn
cp = chart.point.new(time, bar_index, close)
cpG1 = chart.point.new(time, bar_index, close + R)
cpR1 = chart.point.new(time, bar_index, close - R)
l := line.new(cp, cp2, xloc.bar_index, extend.none, color.aqua, line.style_solid, 1)
l2 := line.new(cp, cp3, xloc.bar_index, extend.none, color.aqua, line.style_solid, 1)
l3 := line.new(cp, cp4, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
l4 := line.new(cp, cp5, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
l5 := line.new(cp, cp6, xloc.bar_index, extend.none, color.teal, line.style_solid, 1)
l6 := line.new(cp, cp7, xloc.bar_index, extend.none, color.teal, line.style_solid, 1)
l7 := line.new(cp, cp8, xloc.bar_index, extend.none, color.blue, line.style_solid, 1)
l8 := line.new(cp, cp9, xloc.bar_index, extend.none, color.blue, line.style_solid, 1)
l8
By using the past n bar’s velocity, or directional speed, every n * 2 bars. I can use it to scale the close value and get an estimate for how wide the next moves might be.
#8 Linear regression
//----------------------------------------------
//---------------Linear Regression--------------
//----------------------------------------------
lr = showLR ? ta.linreg(close, n, 0) : na
plot(lr, 'Linear Regression', color.blue)
I used TradingView’s built in linear regression to not reinvent the wheel. This is present to see past market strength of weakness from a different perspective.
User input
Users can control a lot about this script. For the strategy based plots you can enter what you want the risk to be in percentages. So the default 0.01 is 1%. You can also control how far forward the line goes.
Look back at where it is needed as well as line width for the Fractal Boxes are controllable. Also users can check on and off what they would like to see on the charts.
No indicator is 100% reliable, do not follow this one blindly. I encourage traders to make their own decisions and not trade solely based on technical indicators. I encourage constructive criticism in the comments below. Thank you.
Candle 1 2 3 on XAUUSD (by Veronica)Description
Discover the Candle 1 2 3 Strategy, a simple yet effective trading method tailored exclusively for XAUUSD on the 15-minute timeframe. Designed by Veronica, this strategy focuses on identifying key reversal and continuation patterns during the London and New York sessions, making it ideal for traders who prioritise high-probability entries during these active market hours.
Key Features:
1. Session-Specific Trading:
The strategy operates strictly during London (03:00–06:00 UTC) and New York (08:30–12:30 UTC) sessions, where XAUUSD tends to show higher volatility and clearer price movements.
Pattern Criteria:
- Works best if the first candle is NOT a pin bar or a doji.
- Third candle should either:
a. Be a marubozu (large body with minimal wicks).
a. Have a significant body with wicks, ensuring the close of the third candle is above Candle 2 (for Buy) or below Candle 2 (for Sell).
Callout Labels and Alerts:
Automatic Buy and Sell labels are displayed on the chart during qualifying sessions, ensuring clarity for decision-making.
Integrated alerts notify you of trading opportunities in real-time.
Risk Management:
Built-in Risk Calculator to estimate lot sizes based on your account size, risk percentage, and stop-loss levels.
Customizable Table:
Displays your calculated lot size for various stop-loss pip values, making risk management seamless and efficient.
How to Use:
1. Apply the indicator to XAUUSD (M15).
2. Focus on setups appearing within the London and New York sessions only.
3. Ensure the first candle is neither a pin bar nor a doji.
4. Validate the third candle's body placement:
For a Buy, the third candle’s close must be above the second candle.
For a Sell, the third candle’s close must be below the second candle.
5. Use the generated alerts to streamline your entry process.
Notes:
This strategy is meant to complement your existing knowledge of market structure and price action.
Always backtest thoroughly and adjust parameters to fit your personal trading style and risk tolerance.
Credit:
This strategy is the intellectual property of Veronica, developed specifically for XAUUSD (M15) traders seeking precision entries during high-volume sessions.
Price and Volume Divergence Analyzer
How to Use the Indicator
Main Purpose:
Identify divergences between price movement, the volume line, and the weighted volume line to predict potential reversals.
Volume Line Explanation:
At zero: Equal buying and selling volume.
At 1: Double the buying volume vs. selling.
At -1: Double the selling volume vs. buying.
Divergence:
Price rising, volume line falling: Sellers offloading to buyers—likely reversal downward.
Price falling, volume line rising: Buyers stepping in—likely reversal upward.
Higher/Lower Volume Movement Line:
At zero: Equal volume required for price movement.
At 1: High efficiency—half the volume needed to move price.
At -1: Low efficiency—double the volume needed to move price.
Above volume line: Movement aligns with efficient volume.
Below volume line: Inefficient price movement.
Candle Fill Colors:
Shaded based on whether the current close is higher or lower than the previous close.
Settings Overview
EMA Settings:
Timeframe Selection:
Use a lower timeframe than your chart for accuracy. Avoid selecting a timeframe higher than your chart.
EMA Length Option:
Default: Sets lengths automatically (EMA = 14, EMA of EMA = 3).
User Input: Allows custom EMA length.
Calculation Type:
EMA: Standard exponential moving average.
EMA of EMA: Applies EMA three times for smoother values.
Volume Line Settings:
Line Width: Adjust thickness.
Colors:
More Buying: Green (default).
More Selling: Red (default).
Higher/Lower Volume Movement Line:
Line Width: Adjust thickness.
Colors:
Higher Volume Movement: Indicates higher volume required.
Lower Volume Movement: Indicates lower volume required.
Up/Down Candle Fill:
Colors:
Up Candle: Green (default).
Down Candle: Red (default).
Transparency: Adjust percentage for visibility.
Balance Line Settings:
Line Width and Color: Equilibrium line showing equal buying/selling volume at zero.
Dekkapok Premium Prices and EMA360Overview:
The EMA360 Premium Levels indicator is designed to help traders identify key price levels above the EMA360 (Exponential Moving Average) on a daily timeframe. These levels, referred to as "premium levels" are calculated as multiples of the EMA360 and can act as potential resistance or support zones for price action analysis.
Features:
EMA360 Calculation:
The script calculates the EMA360 using the daily timeframe (or any user-specified timeframe).
EMA360 is plotted as a bold blue line for clear visibility.
Premium Levels:
Multiple levels above the EMA360 are plotted as horizontal green lines.
These levels are calculated by multiplying the EMA360 value by user-defined multipliers (e.g., 1.2x, 1.3x, etc.).
Premium levels can help identify overbought or extended price zones relative to EMA360.
Customizable Inputs:
EMA Length: Default is set to 360, but users can adjust the EMA length as needed.
Timeframe: EMA360 is calculated using the daily timeframe by default, but any timeframe can be selected.
Multipliers: Traders can input their desired multipliers (e.g., 1.2, 1.3, 1.5) as a comma-separated list.
Clean Visualization:
EMA360 and premium levels are plotted directly on the price chart for intuitive analysis.
Premium level lines are semi-transparent green to minimize clutter while maintaining focus on critical levels.
Use Cases:
Trend Analysis: Use the EMA360 to identify the broader market trend. Prices above the EMA360 generally indicate an uptrend, while prices below may indicate a downtrend.
Overextension Zones: Premium levels help traders identify zones where the price may be overbought or overextended relative to EMA360.
Dynamic Support/Resistance: The premium levels can act as dynamic resistance zones during uptrends and support zones during pullbacks.
How to Use:
Apply the indicator to your chart in TradingView.
Observe the EMA360 line to understand the market trend.
Use the green premium level lines to identify potential resistance zones as the price moves above the EMA360.
Customization Options:
Adjust the EMA Length and Timeframe to match your trading style.
Modify the Premium Multipliers to suit your market analysis needs (e.g., add or reduce levels like 1.1x, 1.8x, etc.).
This indicator is especially useful for trend-following traders who want to leverage EMA-based levels for strategic decision-making.
- Dekkapok
Dekkapok Premium Prices and EMA360 [Clean Ver.]Overview:
The EMA360 Premium Levels indicator is designed to help traders identify key price levels above the EMA360 (Exponential Moving Average) on a daily timeframe. These levels, referred to as "premium levels" are calculated as multiples of the EMA360 and can act as potential resistance or support zones for price action analysis.
Features:
EMA360 Calculation:
The script calculates the EMA360 using the daily timeframe (or any user-specified timeframe).
EMA360 is plotted as a bold blue line for clear visibility.
Premium Levels:
Multiple levels above the EMA360 are plotted as horizontal green lines.
These levels are calculated by multiplying the EMA360 value by user-defined multipliers (e.g., 1.2x, 1.3x, etc.).
Premium levels can help identify overbought or extended price zones relative to EMA360.
Customizable Inputs:
EMA Length: Default is set to 360, but users can adjust the EMA length as needed.
Timeframe: EMA360 is calculated using the daily timeframe by default, but any timeframe can be selected.
Multipliers: Traders can input their desired multipliers (e.g., 1.2, 1.3, 1.5) as a comma-separated list.
Clean Visualization:
EMA360 and premium levels are plotted directly on the price chart for intuitive analysis.
Premium level lines are semi-transparent green to minimize clutter while maintaining focus on critical levels.
Use Cases:
Trend Analysis: Use the EMA360 to identify the broader market trend. Prices above the EMA360 generally indicate an uptrend, while prices below may indicate a downtrend.
Overextension Zones: Premium levels help traders identify zones where the price may be overbought or overextended relative to EMA360.
Dynamic Support/Resistance: The premium levels can act as dynamic resistance zones during uptrends and support zones during pullbacks.
How to Use:
Apply the indicator to your chart in TradingView.
Observe the EMA360 line to understand the market trend.
Use the green premium level lines to identify potential resistance zones as the price moves above the EMA360.
Customization Options:
Adjust the EMA Length and Timeframe to match your trading style.
Modify the Premium Multipliers to suit your market analysis needs (e.g., add or reduce levels like 1.1x, 1.8x, etc.).
This indicator is especially useful for trend-following traders who want to leverage EMA-based levels for strategic decision-making.
- Dekkapok
Flow-Weighted Volume Oscillator (FWVO)Volume Dynamics Oscillator (VDO)
Description
The Volume Dynamics Oscillator (VDO) is a powerful and innovative tool designed to analyze volume trends and provide traders with actionable insights into market dynamics. This indicator goes beyond simple volume analysis by incorporating a smoothed oscillator that visualizes the flow and momentum of trading activity, giving traders a clearer understanding of volume behavior over time.
What It Does
The VDO calculates the flow of volume by scaling raw volume data relative to its highest and lowest values over a user-defined period. This scaled volume is then smoothed using an exponential moving average (EMA) to eliminate noise and highlight significant trends. The oscillator dynamically shifts above or below a zero line, providing clear visual cues for bullish or bearish volume pressure.
Key features include:
Smoothed Oscillator: Displays the direction and momentum of volume using gradient colors.
Threshold Markers: Highlights overbought or oversold zones based on upper and lower bounds of the oscillator.
Visual Fill Zones: Uses color-filled areas to emphasize positive and negative volume flow, making it easy to interpret market sentiment.
How It Works
The calculation consists of several steps:
Smoothing with EMA: An EMA of the scaled volume is applied to reduce noise and enhance trends. A separate EMA period can be adjusted by the user (Volume EMA Period).
Dynamic Thresholds: The script determines upper and lower bounds around the smoothed oscillator, derived from its recent highest and lowest values. These thresholds indicate critical zones of volume momentum.
How to Use It
Bullish Signals: When the oscillator is above zero and green, it suggests strong buying pressure. A crossover from negative to positive can signal the start of an uptrend.
Bearish Signals: When the oscillator is below zero and blue, it indicates selling pressure. A crossover from positive to negative signals potential bearish momentum.
Overbought/Oversold Zones: Use the upper and lower threshold levels as indicators of extreme volume momentum. These can act as early warnings for trend reversals.
Traders can adjust the following inputs to customize the indicator:
High/Low Period: Defines the period for volume scaling.
Volume EMA Period: Adjusts the smoothing factor for the oscillator.
Smooth Factor: Controls the responsiveness of the smoothed oscillator.
Originality and Usefulness
The VDO stands out by combining dynamic volume scaling, EMA smoothing, and gradient-based visualization into a single, cohesive tool. Unlike traditional volume indicators, which often display raw or cumulative data, the VDO emphasizes relative volume strength and flow, making it particularly useful for spotting reversals, confirming trends, and identifying breakout opportunities.
The integration of color-coded fills and thresholds enhances usability, allowing traders to quickly interpret market conditions without requiring deep technical expertise.
Chart Recommendations
To maximize the effectiveness of the VDO, use it on a clean chart without additional indicators. The gradient coloring and filled zones make it self-explanatory, but traders can overlay basic trendlines or support/resistance levels for additional context.
For advanced users, the VDO can be paired with price action strategies, candlestick patterns, or other trend-following indicators to improve accuracy and timing.
