[blackcat] L2 Ehlers Autocorrelation Periodogram V2OVERVIEW
The Ehlers Autocorrelation Periodogram is a sophisticated technical analysis tool that identifies market cycles and their dominant frequencies using autocorrelation and spectral analysis techniques.
BACKGROUND
Developed by John F. Ehlers and detailed in his book "Cycle Analytics for Traders" (2013), this indicator combines autocorrelation functions with discrete Fourier transforms to extract cyclic information from price data.
FUNCTION
The indicator works through these key steps:
Calculates autocorrelation using minimum three-bar averaging
Applies discrete Fourier transform to extract cyclic information
Uses center-of-gravity algorithm to determine dominant cycle
ADVANTAGES
• Rapid response within half-cycle periods
• Accurate relative cyclic power estimation over time
• Correlation constraints between -1 and +1 eliminate amplitude compensation needs
• High resolution independent of windowing functions
HOW TO USE
Add the indicator to your chart
Adjust AvgLength input parameter:
• Default: 3 bars
• Higher values increase smoothing
• Lower values increase sensitivity
Interpret the results:
• Colored bars represent spectral power
• Red to yellow spectrum indicates cycle strength
• White line shows dominant cycle period
INTERPRETATION
• Strong colors indicate significant cyclic activity
• Sharp color transitions suggest potential cycle changes
• Dominant cycle line helps identify primary market rhythm
LIMITATIONS
• Requires sufficient historical data
• Performance may vary in non-cyclical markets
• Results depend on proper parameter settings
NOTES
• Uses highpass and super smoother filtering techniques
• Spectral estimates are normalized between 0 and 1
• Color intensity varies based on spectral power
THANKS
This implementation is based on Ehlers' original work and has been adapted for TradingView's Pine Script platform.
Komut dosyalarını "如何用wind搜索股票的发行价和份数" için ara
StonkGame Major Market Open/ClosePlots vertical lines for Tokyo, London, and New York session opens and closes — auto-adjusted to your chart's timezone.
Open lines = lighter, dashed style.
Close lines = solid, full-color style.
Helps identify key liquidity windows, session-driven volatility, and clean market structure — without chart clutter.
Fully customizable colors and line styles for a professional, minimal look.
RSI and CCICombined RSI and CCI Indicator for MetaTrader
The Combined RSI and CCI Indicator is a powerful hybrid momentum oscillator designed to merge the strengths of two popular indicators—the Relative Strength Index (RSI) and the Commodity Channel Index (CCI)—into a single, visually intuitive chart window. This tool enhances traders’ ability to identify overbought and oversold conditions, divergences, trend strength, and potential reversal zones with improved precision.
Purpose
By integrating RSI and CCI, this indicator helps filter out false signals that often occur when using each tool independently. It is especially useful for swing trading, trend confirmation, and spotting high-probability entry/exit zones. This dual-oscillator approach combines RSI’s relative momentum insights with CCI’s deviation-based analysis to produce a more reliable signal structure.
Key Features
Dual Oscillator Display: Plots both RSI and CCI on the same subwindow for easy comparison and correlation analysis.
Customizable Parameters:
RSI Period and Level (default: 14)
CCI Period and Typical Price Type (default: 20, TP)
Overbought/Oversold Levels for both indicators
Color-Coded Zones:
Background highlights when both RSI and CCI enter overbought/oversold territory, signaling high potential reversal zones.
Combined Signal Logic (Optional Feature):
Buy Signal: RSI < 30 and CCI < -100
Sell Signal: RSI > 70 and CCI > 100
These can be visualized as arrows or plotted as signal markers.
Trend Filter Overlay (Optional):
Can be combined with a moving average or price action filter to confirm trend direction before accepting signals.
Divergence Detection (Advanced Option):
Optional plotting of bullish or bearish divergence where both indicators diverge from price action.
Multi-Timeframe Compatibility:
Allows the use of higher timeframe RSI/CCI values to confirm signals on lower timeframes.
Benefits
Improved Signal Accuracy: Using both RSI and CCI together helps avoid false breakouts and whipsaws.
More Informed Decision-Making: Correlating momentum (RSI) with deviation (CCI) provides a well-rounded picture of market behavior.
Efficient Charting: Saves screen space and cognitive load by combining two indicators into one clean panel.
Scalable Strategy Integration: Can be used in discretionary trading or coded into automated strategies/alerts.
Use Case Example
In a ranging market, the indicator highlights zones where both RSI and CCI are oversold, alerting traders to potential bounce opportunities.
In trending markets, it confirms trend strength when RSI and CCI are both aligned with trend direction.
When RSI is diverging from price but CCI isn’t, it can be a clue of weakening momentum, helping traders scale out or avoid traps.
This combined indicator offers a versatile, high-performance toolset for traders looking to elevate their technical analysis by leveraging multiple momentum perspectives simultaneously.
Timed Reversion Markers (Custom Session Alerts)This script plots vertical histogram markers at specific intraday time points defined by the user. It is designed for traders who follow time-based reversion or breakout setups tied to predictable market behavior at key clock times, such as institutional opening moves, midday reversals, or end-of-day volatility.
Unlike traditional price-action indicators, this tool focuses purely on time-based triggers, a technique often used in time cycle analysis, market internals, and volume-timing strategies.
The indicator includes eight fully customizable time inputs, allowing users to mark any intraday minute with precision using a decimal hour format (for example, 9.55 for 9:55 AM). Each input is automatically converted into hour and minute format, and a visual histogram marker is plotted once per day at that exact time.
Example use cases:
Mark institutional session opens (e.g., 9:30, 10:00, 15:30)
Time-based mean reversion or volatility windows
Backtest recurring time-based reactions
Highlight algorithmic spike zones
The vertical plots serve as non-intrusive, high-contrast visual markers for scalping setups, session analysis, and decision-making checkpoints. All markers are displayed at the top of the chart without interfering with price candles.
Advanced OHLC ExporterThis Pine Script indicator provides one-click export of candlestick data (OHLC + Volume) from any TradingView chart. It displays the current candle's values in a clean table while ensuring all visible historical data is available for export in CSV format.
Key Features
📊 Visual Data Display
Real-time OHLC table in the top-right corner.
Color-coded values for quick analysis (green=high, red=low).
Volume shown in standardized formatting.
Data Export Ready
All plotted values appear in TradingView's Data Window.
Right-click → "Export Data" to save:
Open, High, Low, Close (OHLC) prices
Trading volume
Timestamps for each candle
⚙️ Customizable Output
Works on any timeframe (1m to 1M)
Compatible with: Forex, Stocks, Crypto, Futures
How Traders Use This
Technical Analysts - Export clean datasets for external analysis.
Backtesters - Quickly gather historical price data for strategy development.
Researchers - Study candlestick patterns with precise numerical data.
Session Coloring Bar with ICT Macro [dani]The Session Coloring Bar is customizable Pine Script indicator designed to visually enhance your charts by applying unique colors to specific trading sessions or timeframes. This tool allows traders to easily identify and differentiate between macro sessions (e.g., 24-hour cycles) and custom-defined sessions (e.g., Session A, Session B), making it ideal for analyzing market activity during specific periods.
In the context of trading, the term "ICT Macro" , as discussed by Michael J. Huddleston (ICT), refers to specific timeframes or "windows" where market behavior often follows predictable patterns. Traders typically focus on the last 10 minutes of an hour and the first 10 minutes of the next hour (e.g., 0150-0210 , 0050-0110 , or 0950-1010 ) to identify key price movements, liquidity shifts, or market inefficiencies.
This script highlights these macro timeframes, enabling traders to visually analyze price action during these critical periods. Use this tool to support your strategy, but always combine it with your own analysis and risk management.
With this indicator, you can:
Highlight Macro Sessions : Automatically color bars based on predefined 24-hour macro sessions.
Customize Session Settings : Define up to three custom sessions (A & B) with individual start/end times, visibility toggles, and unique bar colors.
Timeframe Filtering : Hide session coloring above a specified timeframe to avoid clutter on higher timeframes.
Personal Notes : Add comments to each session for better organization and quick reference.
Dynamic Color Logic : Bars are colored based on their direction (up, down, or neutral) within the active session.
How to Use:
Enable/Disable Sessions :
Use the Show Coloring toggle to enable or disable session coloring for Macro, Session A, Session B, or Session C.
Set Session Times :
Define the start and end times for each session in the format HHMM-HHMM (e.g., 1600-0930 for an overnight session).
Choose Colors :
Assign unique colors for upward (Bar Up) and downward (Bar Down) bars within each session.
Adjust Timeframe Visibility :
Use the Hide above this TF input to specify the maximum timeframe where session coloring will be visible.
Add Notes :
Use the Comment field to add personal notes or labels for each session.
Example Use Cases:
Overnight Sessions :
Highlight overnight trading hours (e.g., 1600-0930) to analyze price action during low liquidity periods.
Asian/European/US Sessions : Define separate sessions for major trading regions to track regional market behavior.
Macro Analysis : Use the predefined 24-hour macro sessions to study hourly price movements across a full trading day.
Disclaimer:
The Session Coloring Bar is not a trading signal generator and does not predict market direction or provide buy/sell signals. Instead, it is a visualization tool designed to help you identify and analyze specific trading sessions or timeframes on your chart. By highlighting key sessions and their corresponding price movements, this indicator enables you to focus on periods of interest and make more informed trading decisions.
Thank you for choosing this indicator! I hope it becomes a valuable part of your trading toolkit. Remember, trading is a journey, and having the right tools can make all the difference. Whether you're a seasoned trader or just starting out, this indicator is designed to help you stay organized and focused on what matters most—price action. Happy trading, and may your charts be ever in your favor! 😊
Daily ProtractorDaily Protractor Indicator
Overview
The Daily Protractor is a visually intuitive tool designed for traders who want to analyze price action through angular measurements on a 5-minute chart. By overlaying a protractor on the chart, this indicator helps identify potential support, resistance, and trend directions based on angular relationships from the first 5-minute candle of each day. It’s particularly useful for intraday traders looking to incorporate geometric analysis into their strategies for spot or strike charts.
Key Features
Dynamic Protractor Overlay: Draws a protractor centered on the low of the first 5-minute candle of each day, with customizable radius in both bars (horizontal) and price units (vertical).
Angular Measurements: Displays angles in 5-degree increments, covering a full 360° circle or a 105° to -105° (91° to 269°) half-circle, depending on user preference.
Customizable Display:
Adjust the number of days to display protractors (up to 5 days).
Customize line colors for different angle ranges (0° to 180°, 180° to 360°, and 0° specifically).
Modify line thickness, label size, and label colors for better visibility.
Center Point Highlight: Marks the center of each protractor with a labeled point for easy reference.
Efficient Design:
Optimized with max_lines_count, max_labels_count, and max_bars_back to ensure smooth performance on TradingView.
How It Works
The indicator identifies the first 5-minute candle of each day and uses its low price as the center point for a protractor. It then draws lines at 5-degree intervals, radiating from the center, with each line representing an angle from 0° to 360°. Labels at the end of each line display the angle in degrees, with negative values shown for angles between 195° and 345° (e.g., 270° is displayed as -90°). The protractor’s radius can be adjusted in both time (bars) and price units, allowing traders to scale the tool to their chart’s characteristics.
Usage Instructions
Add to Chart:
Apply the indicator to a 5-minute chart of your chosen instrument (e.g., spot or strike charts).
Interpret the Protractor:
Use the angular lines to identify potential price levels or trend directions.
The 0° line (horizontal) can act as a reference for horizontal support/resistance.
Angles between 0° and 180° (upper half) and 180° and 360° (lower half) are color-coded for quick identification.
Customize Settings:
Toggle the Show 105° to -105° option to display a half-circle (91° to 269°) instead of a full 360° protractor.
Adjust the Radius in Bars and Radius in Price Units to scale the protractor to your chart.
Set the Maximum Days to Display to control how many daily protractors are shown.
Modify line thickness, colors, and label settings to suit your visual preferences.
Customization Options
Protractor Settings:
Show 105° to -105° (91° to 269°): Toggle between a full circle or a half-circle protractor.
Radius in Bars: Set the horizontal span of the protractor (default: 75 bars).
Radius in Price Units: Set the vertical span in price units (default: 1000.0).
Maximum Days to Display: Limit the number of protractors shown (default: 5 days).
Line Settings:
Line Thickness: Adjust the thickness of the protractor lines (1 or 2).
Line Color (0° to 180°): Color for the upper half (default: light blue).
Line Color (180° to 360°): Color for the lower half (default: light red).
Line Color (0°): Color for the 0° line (default: black).
Label Settings:
Label Size: Choose between small, normal, or large labels.
Label Color (0° to 180°): Color for labels in the upper half (default: red).
Label Color (180° to 360°): Color for labels in the lower half (default: green).
Notes
The indicator was designed with the help of Grok3 for use on 5-minute charts only, as it relies on the first 5-minute candle of the day to set the protractor’s center.
For best results, adjust the radius settings to match the volatility and price scale of your instrument. However, where the price is in single digits it is advised to switch off the labels or I would suggest not to use the same.
The protractor can be used alongside other technical tools to confirm trends, reversals, or key price levels.
Limitations: This cannot be used on instruments that trade for more than 75 candles with a timeframe of 5 minutes as the angles would not cover the entire trading window. I am working coming up with a script to address this limitation.
Feedback
I’d love to hear your thoughts! If you find the Daily Protractor helpful or have suggestions for improvements, please leave a comment or reach out. Happy trading!
ZRK 30m This TradingView indicator draws alternating 30-minute boxes aligned precisely to real clock times (e.g., 10:00, 10:30, 11:00), helping traders visually segment intraday price action. It highlights every other 30-minute block with customizable colors, line styles, and opacity, allowing users to clearly differentiate between trading intervals. The boxes automatically adjust based on the chart’s timeframe, maintaining accuracy on 1-minute to 60-minute charts. Optional time labels can also be displayed for additional context. This tool is useful for identifying patterns, measuring volatility, or applying breakout strategies based on defined, consistent time windows across global trading sessions.
Trendline Breaks with Multi Fibonacci Supertrend StrategyTMFS Strategy: Advanced Trendline Breakouts with Multi-Fibonacci Supertrend
Elevate your algorithmic trading with institutional-grade signal confluence
Strategy Genesis & Evolution
This advanced trading system represents the culmination of a personal research journey, evolving from my custom " Multi Fibonacci Supertrend with Signals " indicator into a comprehensive trading strategy. Built upon the exceptional trendline detection methodology pioneered by LuxAlgo in their " Trendlines with Breaks " indicator, I've engineered a systematic framework that integrates multiple technical factors into a cohesive trading system.
Core Fibonacci Principles
At the heart of this strategy lies the Fibonacci sequence application to volatility measurement:
// Fibonacci-based factors for multiple Supertrend calculations
factor1 = input.float(0.618, 'Factor 1 (Weak/Fibonacci)', minval = 0.01, step = 0.01)
factor2 = input.float(1.618, 'Factor 2 (Medium/Golden Ratio)', minval = 0.01, step = 0.01)
factor3 = input.float(2.618, 'Factor 3 (Strong/Extended Fib)', minval = 0.01, step = 0.01)
These precise Fibonacci ratios create a dynamic volatility envelope that adapts to changing market conditions while maintaining mathematical harmony with natural price movements.
Dynamic Trendline Detection
The strategy incorporates LuxAlgo's pioneering approach to trendline detection:
// Pivotal swing detection (inspired by LuxAlgo)
pivot_high = ta.pivothigh(swing_length, swing_length)
pivot_low = ta.pivotlow(swing_length, swing_length)
// Dynamic slope calculation using ATR
slope = atr_value / swing_length * atr_multiplier
// Update trendlines based on pivot detection
if bool(pivot_high)
upper_slope := slope
upper_trendline := pivot_high
else
upper_trendline := nz(upper_trendline) - nz(upper_slope)
This adaptive trendline approach automatically identifies key structural market boundaries, adjusting in real-time to evolving chart patterns.
Breakout State Management
The strategy implements sophisticated state tracking for breakout detection:
// Track breakouts with state variables
var int upper_breakout_state = 0
var int lower_breakout_state = 0
// Update breakout state when price crosses trendlines
upper_breakout_state := bool(pivot_high) ? 0 : close > upper_trendline ? 1 : upper_breakout_state
lower_breakout_state := bool(pivot_low) ? 0 : close < lower_trendline ? 1 : lower_breakout_state
// Detect new breakouts (state transitions)
bool new_upper_breakout = upper_breakout_state > upper_breakout_state
bool new_lower_breakout = lower_breakout_state > lower_breakout_state
This state-based approach enables precise identification of the exact moment when price breaks through a significant trendline.
Multi-Factor Signal Confluence
Entry signals require confirmation from multiple technical factors:
// Define entry conditions with multi-factor confluence
long_entry_condition = enable_long_positions and
upper_breakout_state > upper_breakout_state and // New trendline breakout
di_plus > di_minus and // Bullish DMI confirmation
close > smoothed_trend // Price above Supertrend envelope
// Execute trades only with full confirmation
if long_entry_condition
strategy.entry('L', strategy.long, comment = "LONG")
This strict requirement for confluence significantly reduces false signals and improves the quality of trade entries.
Advanced Risk Management
The strategy includes sophisticated risk controls with multiple methodologies:
// Calculate stop loss based on selected method
get_long_stop_loss_price(base_price) =>
switch stop_loss_method
'PERC' => base_price * (1 - long_stop_loss_percent)
'ATR' => base_price - long_stop_loss_atr_multiplier * entry_atr
'RR' => base_price - (get_long_take_profit_price() - base_price) / long_risk_reward_ratio
=> na
// Implement trailing functionality
strategy.exit(
id = 'Long Take Profit / Stop Loss',
from_entry = 'L',
qty_percent = take_profit_quantity_percent,
limit = trailing_take_profit_enabled ? na : long_take_profit_price,
stop = long_stop_loss_price,
trail_price = trailing_take_profit_enabled ? long_take_profit_price : na,
trail_offset = trailing_take_profit_enabled ? long_trailing_tp_step_ticks : na,
comment = "TP/SL Triggered"
)
This flexible approach adapts to varying market conditions while providing comprehensive downside protection.
Performance Characteristics
Rigorous backtesting demonstrates exceptional capital appreciation potential with impressive risk-adjusted metrics:
Remarkable total return profile (1,517%+)
Strong Sortino ratio (3.691) indicating superior downside risk control
Profit factor of 1.924 across all trades (2.153 for long positions)
Win rate exceeding 35% with balanced distribution across varied market conditions
Institutional Considerations
The strategy architecture addresses execution complexities faced by institutional participants with temporal filtering and date-range capabilities:
// Time Filter settings with flexible timezone support
import jason5480/time_filters/5 as time_filter
src_timezone = input.string(defval = 'Exchange', title = 'Source Timezone')
dst_timezone = input.string(defval = 'Exchange', title = 'Destination Timezone')
// Date range filtering for precise execution windows
use_from_date = input.bool(defval = true, title = 'Enable Start Date')
from_date = input.time(defval = timestamp('01 Jan 2022 00:00'), title = 'Start Date')
// Validate trading permission based on temporal constraints
date_filter_approved = time_filter.is_in_date_range(
use_from_date, from_date, use_to_date, to_date, src_timezone, dst_timezone
)
These capabilities enable precise execution timing and market session optimization critical for larger market participants.
Acknowledgments
Special thanks to LuxAlgo for the pioneering work on trendline detection and breakout identification that inspired elements of this strategy. Their innovative approach to technical analysis provided a valuable foundation upon which I could build my Fibonacci-based methodology.
This strategy is shared under the same Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license as LuxAlgo's original work.
Past performance is not indicative of future results. Conduct thorough analysis before implementing any algorithmic strategy.
Hourly Volatility Explorer📊 Hourly Volatility Explorer: Master The Market's Pulse
Unlock the hidden rhythms of price action with this sophisticated volatility analysis tool. The Hourly Volatility Explorer reveals the most potent trading hours across multiple time zones, giving you a strategic edge in timing your trades.
🌟 Key Features:
⏰ Multi-Timezone Analysis
• GMT (UTC+0)
• EST (UTC-5) - New York
• BST (UTC+1) - London
• JST (UTC+9) - Tokyo
• AEST (UTC+10) - Sydney
Perfect for tracking major market sessions and their overlaps!
📈 Dynamic Visualization
• Color-gradient hourly bars for instant pattern recognition
• Real-time volatility comparison
• Interactive data table with comprehensive statistics
• Automatic highlighting of peak volatility periods
🎯 Strategic Applications:
Day Trading:
• Identify optimal trading windows
• Avoid low-liquidity periods
• Capitalize on session overlaps
• Fine-tune entry/exit timing
Risk Management:
• Set appropriate stop losses based on hourly volatility
• Adjust position sizes for different market hours
• Optimize risk-reward ratios
• Plan around high-impact hours
Global Market Analysis:
• Track volatility across all major sessions
• Spot institutional trading patterns
• Identify quiet vs. active periods
• Monitor 24/7 market dynamics
💡 Perfect For:
• Forex traders navigating global sessions
• Crypto traders in 24/7 markets
• Day traders optimizing execution times
• Algorithmic traders fine-tuning strategies
• Risk managers calibrating exposure
📊 Advanced Features:
• Rolling 3-month analysis for reliable patterns
• Precise pip movement calculations
• Sample size tracking for statistical validity
• Real-time current hour comparison
• Color-coded visual system for instant insights
⚡ Pro Trading Tips:
• Use during major session overlaps for maximum opportunity
• Compare patterns across different instruments
• Combine with volume analysis for deeper insights
• Track seasonal variations in hourly patterns
• Build trading schedules around peak hours
🎓 Educational Value:
• Understand market microstructure
• Learn global market dynamics
• Master timezone relationships
• Develop timing intuition
🛠️ Customization:
• Adjustable lookback period
• Flexible pip multiplier
• Multiple timezone options
• Visual preference settings
Whether you're scalping the 1-minute chart or managing longer-term positions, the Hourly Volatility Explorer provides the precise timing intelligence needed for today's global markets.
Transform your trading schedule from guesswork to science. Know exactly when markets move, why they move, and how to position yourself for maximum opportunity.
#TechnicalAnalysis #Trading #Volatility #MarketTiming #DayTrading #Forex #Crypto #TradingView #PineScript #MarketAnalysis #TradingStrategy #RiskManagement #GlobalMarkets #FinancialMarkets #TradingTools #MarketStructure #PriceAction #Scalping #SwingTrading #AlgoTrading
real_time_candlesIntroduction
The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold.
This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches.
Key Features
The library supports two primary candle generation approaches:
Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars.
Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe.
Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data.
Configuration Requirements
For optimal performance with this library:
Set max_bars_back = 5000 in your script settings
When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500
These settings ensure that you will be able to draw correctly and will avoid any runtime errors.
Usage Examples
Basic Chart-Time Candle Visualization
// Create real-time candles for RSI
float rsi = ta.rsi(close, 14)
Candle rsi_candle = candle_series(rsi, CandleType.candlestick)
// Plot the candles using Pine's built-in function
plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close,
"RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color)
Multiple Access Patterns
The library provides three ways to access candle data, accommodating different programming styles:
// 1. Array-based access for collection operations
Candle candles = candle_array(source)
// 2. Object-oriented access for single entity manipulation
Candle candle = candle_series(source)
float value = candle.source(Source.HLC3)
// 3. Tuple-based access for functional programming styles
= candle_tuple(source)
Custom Timeframe Examples
// Create 20-second candles with EMA overlay
plot_ctf_candles(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 20,
timezone = -5,
tied_open = true,
ema_period = 9,
enable_ema = true
)
// Create tick-based candles (new candle every 15 ticks)
plot_ctf_tick_candles(
source = close,
candle_type = CandleType.heikin_ashi,
number_of_ticks = 15,
timezone = -5,
tied_open = true
)
Advanced Usage with Custom Visualization
// Get custom timeframe candles without automatic plotting
CandleCTF my_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 30
)
// Apply custom logic to the candles
float ema_values = my_candles.ctf_ema(14)
// Draw candles and EMA using time-based coordinates
my_candles.draw_ctf_candles_time()
ema_values.draw_ctf_line_time(line_color = #FF6D00)
Library Components
Data Types
Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties
CandleCTF: Extended candle structure with additional time metadata for custom timeframes
TickData: Structure for individual price updates with time deltas
Enumerations
CandleType: Specifies visualization style (candlestick or Heikin-Ashi)
Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.)
SampleType: Sets sampling method (Time-based or Tick-based)
Core Functions
get_tick(): Captures current price as a tick data point
candle_array(): Creates an array of candles from price updates
candle_series(): Provides a single candle based on latest data
candle_tuple(): Returns OHLC values as a tuple
ctf_candles_array(): Creates custom timeframe candles without rendering
Visualization Functions
source(): Extracts specific price components from candles
candle_ctf_to_float(): Converts candle data to float arrays
ctf_ema(): Calculates exponential moving averages for candle arrays
draw_ctf_candles_time(): Renders candles using time coordinates
draw_ctf_candles_index(): Renders candles using bar index coordinates
draw_ctf_line_time(): Renders lines using time coordinates
draw_ctf_line_index(): Renders lines using bar index coordinates
Technical Implementation Notes
This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes:
Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas
Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+
Temporal synchronization: Manages two time domains (chart time and custom timeframe)
The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe.
Limitations
Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data
Real-time visualization is only available during live chart updates
Maximum history is constrained by Pine Script's array size limits
Applications
Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time
Volume analysis: Create custom volume profiles independent of chart timeframe
Scalping strategies: Identify short-term patterns with precisely defined time windows
Volatility measurement: Track price movement characteristics within bars
Custom signal generation: Create entry/exit signals based on custom timeframe patterns
Conclusion
The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities.
Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script.
Implementation Details & Advanced Guide
Core Implementation Concepts
The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams.
Tick Processing System
The foundation of the library is the get_tick() function, which captures price updates as they occur:
export get_tick(series float source = close, series float na_replace = na)=>
varip float price = na
varip int series_index = -1
varip int old_time = 0
varip int new_time = na
varip float time_delta = 0
// ...
This function:
Samples the current price
Calculates time elapsed since last update
Maintains a sequential index to track updates
The resulting TickData structure serves as the fundamental building block for all candle generation.
State Management Architecture
The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model.
For chart-time candles, the core state transition logic is:
// Real-time update of current candle
candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color)
candles.set(0, candle_data)
// When a new bar starts, preserve the previous candle
if clear_state
candles.insert(1, candle_data)
price.clear()
// Reset state for new candle
Open := Close
price.push(Open)
series_index += 1
This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data.
Custom Timeframe Implementation
The custom timeframe system manages its own time boundaries independent of chart bars:
bool clear_state = switch settings.sample_type
SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks
SampleType.Time => cumulative_time_delta >= settings.number_of_seconds
This dual-clock system synchronizes two time domains:
Pine's execution clock (bar-by-bar processing)
The custom timeframe clock (tick or time-based)
The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps.
Advanced Usage Techniques
1. Creating Custom Indicators with Real-Time Candles
To develop indicators that process real-time data within the current bar:
// Get real-time candles for your data
Candle rsi_candles = candle_array(ta.rsi(close, 14))
// Calculate indicator values based on candle properties
float signal = ta.ema(rsi_candles.first().source(Source.Close), 9)
// Detect patterns that occur within the bar
bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close
2. Working with Custom Timeframes and Plotting
For maximum flexibility when visualizing custom timeframe data:
// Create custom timeframe candles
CandleCTF volume_candles = ctf_candles_array(
source = volume,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 60
)
// Convert specific candle properties to float arrays
float volume_closes = volume_candles.candle_ctf_to_float(Source.Close)
// Calculate derived values
float volume_ema = volume_candles.ctf_ema(14)
// Create custom visualization
volume_candles.draw_ctf_candles_time()
volume_ema.draw_ctf_line_time(line_color = color.orange)
3. Creating Hybrid Timeframe Analysis
One powerful application is comparing indicators across multiple timeframes:
// Standard chart timeframe RSI
float chart_rsi = ta.rsi(close, 14)
// Custom 5-second timeframe RSI
CandleCTF ctf_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 5
)
float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close)
float fast_rsi = fast_rsi_array.first()
// Generate signals based on divergence between timeframes
bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1)
Final Notes
This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms.
The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application.
------------------------
Library "real_time_candles"
A comprehensive library for creating real-time candles with customizable timeframes and sampling methods.
Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization.
Allows for tick-based or time-based sampling with moving average overlay capabilities.
get_tick(source, na_replace)
Captures the current price as a tick data point
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
na_replace (float) : Optional - Value to use when source is na
Returns: TickData structure containing price, time since last update, and sequential index
candle_array(source, candle_type, sync_start, bullish_color, bearish_color)
Creates an array of candles based on price updates
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of Candle objects ordered with most recent at index 0
candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides a single candle based on the latest price data
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: A single Candle object representing the current state
candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides candle data as a tuple of OHLC values
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Tuple representing current candle values
method source(self, source, na_replace)
Extracts a specific price component from a Candle
Namespace types: Candle
Parameters:
self (Candle)
source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
na_replace (float) : Optional - Value to use when source value is na
Returns: The requested price value from the candle
method source(self, source)
Extracts a specific price component from a CandleCTF
Namespace types: CandleCTF
Parameters:
self (CandleCTF)
source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
Returns: The requested price value from the candle as a varip
method candle_ctf_to_float(self, source)
Converts a specific price component from each CandleCTF to a float array
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
Returns: Array of float values extracted from the candles, ordered with most recent at index 0
method ctf_ema(self, ema_period)
Calculates an Exponential Moving Average for a CandleCTF array
Namespace types: array
Parameters:
self (array)
ema_period (simple float) : Period for the EMA calculation
Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0
method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar time coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using time-based x-coordinates
method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar index coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using index-based x-coordinates
method draw_ctf_line_time(self, source, line_size, line_color)
Renders a line representing a price component from the candles using time coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_time(self, line_size, line_color)
Renders a line from a varip float array using time coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_index(self, source, line_size, line_color)
Renders a line representing a price component from the candles using index coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
method draw_ctf_line_index(self, line_size, line_color)
Renders a line from a varip float array using index coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots tick-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots tick-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots time-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots time-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)
Unified function for plotting candles with comprehensive options
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Optional - Type of candle chart to display
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
ema_period (simple float) : Optional - Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
enable_ema (bool) : Optional - Whether to display the EMA overlay
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with optional EMA overlay
ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)
Creates an array of custom timeframe candles without rendering them
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)
sample_type (simple SampleType) : Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of CandleCTF objects ordered with most recent at index 0
Candle
Structure representing a complete candle with price data and display properties
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
candle_color (series color) : Color to use when rendering the candle
ready (series bool) : Boolean indicating if candle data is valid and ready for use
TickData
Structure for storing individual price updates
Fields:
price (series float) : The price value at this tick
time_delta (series float) : Time elapsed since the previous tick in milliseconds
series_index (series int) : Sequential index identifying this tick
CandleCTF
Structure representing a custom timeframe candle with additional time metadata
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
open_time (series int) : Timestamp marking when the candle was opened (in Unix time)
time_delta (series float) : Duration of the candle in milliseconds
candle_color (series color) : Color to use when rendering the candle
UT Bot Alerts – Time Filtered with ExitsThis indicator combines several technical approaches to generate precise entry and exit signals, while incorporating time filters that ensure signals are sent only during desired time windows and with defined cooldown periods. It is based on the original idea by QuantNomad.
Main Components:
ATR-based Trailing Stop:
Using the Average True Range (ATR) and an adjustable multiplier ("Key Value"), a dynamic trailing stop is calculated that adapts to the current price. This trailing stop forms the basis for the signal generation.
EMA-based Entry Signals:
A very short exponential moving average (EMA, period 1) is used in combination with the trailing stop to identify clear buy (long) and sell (short) signals via crossovers. An additional buffer zone helps reduce false signals.
Persistent Trade State:
The current state (long, short, or neutral) is maintained so that the system remains in the trend until a new signal is generated.
Linear Regression as Reference:
A linear regression line computed over a defined period serves as a reference for determining exit levels.
Exit Signals with Delay:
Exit signals are generated when the price deviates from the linear regression line by a defined percentage (Exit Signal Deviation) and the condition persists for at least a specified number of bars (Exit Signal Delay). Only one exit signal is issued per trade to avoid excessive exits.
Time Filters and Cooldown:
Session Filter: A user-defined session (e.g., "2200-0500") can disable signals during specified periods.
Cooldown Period: After a signal is triggered, a cooldown phase (in minutes) can be set during which no new signals are sent.
Visual Display and Alerts:
Entry Signals: Buy and sell signals are displayed as labels (green for long, red for short).
Exit Signals: Exit signals appear as triangles, with the exit long signal text displayed in white.
Reference Lines:
The upper exit level (Exit Short Level) is drawn as a solid line in turquoise (color.aqua).
The lower exit level (Exit Long Level) is drawn as a solid line in yellow.
Additionally, the ATR trailing stop and the linear regression line are clearly plotted on the chart.
Alerts can be configured for all signal types.
In Summary:
The indicator delivers precise entry signals based on an ATR trailing stop and a short EMA, supplemented by dynamic exit levels determined via linear regression. With integrated time filters (session and cooldown) and a flexible exit mechanism, this indicator offers controlled trade management—ideal for traders who wish to receive signals only during desired time periods.
Original Author: QuantNomad
[3Commas] Turtle StrategyTurtle Strategy
🔷 What it does: This indicator implements a modernized version of the Turtle Trading Strategy, designed for trend-following and automated trading with webhook integration. It identifies breakout opportunities using Donchian channels, providing entry and exit signals.
Channel 1: Detects short-term breakouts using the highest highs and lowest lows over a set period (default 20).
Channel 2: Acts as a confirmation filter by applying an offset to the same period, reducing false signals.
Exit Channel: Functions as a dynamic stop-loss (wait for candle close), adjusting based on market structure (default 10 periods).
Additionally, traders can enable a fixed Take Profit level, ensuring a systematic approach to profit-taking.
🔷 Who is it for:
Trend Traders: Those looking to capture long-term market moves.
Bot Users: Traders seeking to automate entries and exits with bot integration.
Rule-Based Traders: Operators who prefer a structured, systematic trading approach.
🔷 How does it work: The strategy generates buy and sell signals using a dual-channel confirmation system.
Long Entry: A buy signal is generated when the close price crosses above the previous high of Channel 1 and is confirmed by Channel 2.
Short Entry: A sell signal occurs when the close price falls below the previous low of Channel 1, with confirmation from Channel 2.
Exit Management: The Exit Channel acts as a trailing stop, dynamically adjusting to price movements. To exit the trade, wait for a full bar close.
Optional Take Profit (%): Closes trades at a predefined %.
🔷 Why it’s unique:
Modern Adaptation: Updates the classic Turtle Trading Strategy, with the possibility of using a second channel with an offset to filter the signals.
Dynamic Risk Management: Utilizes a trailing Exit Channel to help protect gains as trades move favorably.
Bot Integration: Automates trade execution through direct JSON signal communication with your DCA Bots.
🔷 Considerations Before Using the Indicator:
Market & Timeframe: Best suited for trending markets; higher timeframes (e.g., H4, D1) are recommended to minimize noise.
Sideways Markets: In choppy conditions, breakouts may lead to false signals—consider using additional filters.
Backtesting & Demo Testing: It is crucial to thoroughly backtest the strategy and run it on a demo account before risking real capital.
Parameter Adjustments: Ensure that commissions, slippage, and position sizes are set accurately to reflect real trading conditions.
🔷 STRATEGY PROPERTIES
Symbol: BINANCE:ETHUSDT (Spot).
Timeframe: 4h.
Test Period: All historical data available.
Initial Capital: 10000 USDT.
Order Size per Trade: 1% of Capital, you can use a higher value e.g. 5%, be cautious that the Max Drawdown does not exceed 10%, as it would indicate a very risky trading approach.
Commission: Binance commission 0.1%, adjust according to the exchange being used, lower numbers will generate unrealistic results. By using low values e.g. 5%, it allows us to adapt over time and check the functioning of the strategy.
Slippage: 5 ticks, for pairs with low liquidity or very large orders, this number should be increased as the order may not be filled at the desired level.
Margin for Long and Short Positions: 100%.
Indicator Settings: Default Configuration.
Period Channel 1: 20.
Period Channel 2: 20.
Period Channel 2 Offset: 20.
Period Exit: 10.
Take Profit %: Disable.
Strategy: Long & Short.
🔷 STRATEGY RESULTS
⚠️Remember, past results do not guarantee future performance.
Net Profit: +516.87 USDT (+5.17%).
Max Drawdown: -100.28 USDT (-0.95%).
Total Closed Trades: 281.
Percent Profitable: 40.21%.
Profit Factor: 1.704.
Average Trade: +1.84 USDT (+1.80%).
Average # Bars in Trades: 29.
🔷 How to Use It:
🔸 Adjust Settings:
Select your asset and timeframe suited for trend trading.
Adjust the periods for Channel 1, Channel 2, and the Exit Channel to align with the asset’s historical behavior. You can visualize these channels by going to the Style tab and enabling them.
For example, if you set Channel 2 to 40 with an offset of 40, signals will take longer to appear but will aim for a more defined trend.
Experiment with different values, a possible exit configuration is using 20 as well. Compare the results and adjust accordingly.
Enable the Take Profit (%) option if needed.
🔸Results Review:
It is important to check the Max Drawdown. This value should ideally not exceed 10% of your capital. Consider adjusting the trade size to ensure this threshold is not surpassed.
Remember to include the correct values for commission and slippage according to the symbol and exchange where you are conducting the tests. Otherwise, the results will not be realistic.
If you are satisfied with the results, you may consider automating your trades. However, it is strongly recommended to use a small amount of capital or a demo account to test proper execution before committing real funds.
🔸Create alerts to trigger the DCA Bot:
Verify Messages: Ensure the message matches the one specified by the DCA Bot.
Multi-Pair Configuration: For multi-pair setups, enable the option to add the symbol in the correct format.
Signal Settings: Enable the option to receive long or short signals (Entry | TP | SL), copy and paste the messages for the DCA Bots configured.
Alert Setup:
When creating an alert, set the condition to the indicator and choose "alert() function call only".
Enter any desired Alert Name.
Open the Notifications tab, enable Webhook URL, and paste the Webhook URL.
For more details, refer to the section: "How to use TradingView Custom Signals".
Finalize Alerts: Click Create, you're done! Alerts will now be sent automatically in the correct format.
🔷 INDICATOR SETTINGS
Period Channel 1: Period of highs and lows to trigger signals
Period Channel 2: Period of highs and lows to filter signals
Offset: Move Channel 2 to the right x bars to try to filter out the favorable signals.
Period Exit: It is the period of the Donchian channel that is used as trailing for the exits.
Strategy: Order Type direction in which trades are executed.
Take Profit %: When activated, the entered value will be used as the Take Profit in percentage from the entry price level.
Use Custom Test Period: When enabled signals only works in the selected time window. If disabled it will use all historical data available on the chart.
Test Start and End: Once the Custom Test Period is enabled, here you select the start and end date that you want to analyze.
Check Messages: Check Messages: Enable this option to review the messages that will be sent to the bot.
Entry | TP | SL: Enable this options to send Buy Entry, Take Profit (TP), and Stop Loss (SL) signals.
Deal Entry and Deal Exit: Copy and paste the message for the deal start signal and close order at Market Price of the DCA Bot. This is the message that will be sent with the alert to the Bot, you must verify that it is the same as the bot so that it can process properly.
DCA Bot Multi-Pair: You must activate it if you want to use the signals in a DCA Bot Multi-pair in the text box you must enter (using the correct format) the symbol in which you are creating the alert, you can check the format of each symbol when you create the bot.
👨🏻💻💭 We hope this tool helps enhance your trading. Your feedback is invaluable, so feel free to share any suggestions for improvements or new features you'd like to see implemented.
__
The information and publications within the 3Commas TradingView account are not meant to be and do not constitute financial, investment, trading, or other types of advice or recommendations supplied or endorsed by 3Commas and any of the parties acting on behalf of 3Commas, including its employees, contractors, ambassadors, etc.
AntoQQE - BarsThis script is a variation on the QQE (Quantitative Qualitative Estimation) concept applied to RSI. It calculates a smoothed RSI line, then determines a “Dynamic Average Range” around that line. By tracking the RSI’s movement relative to these upper (shortBand) and lower (longBand) levels, it determines when price momentum shifts enough to suggest a possible trend flip. The script plots color-coded candles based on these momentum conditions:
• RSI Calculation and Smoothing
An RSI value is obtained over a specified period, then smoothed by an EMA. This smoothed RSI serves as the core measure of momentum.
• Dynamic Average Range (DAR)
The script computes the volatility of the smoothed RSI using two EMAs of its bar-to-bar movements. It multiplies this volatility factor by a QQE multiplier to create upper and lower bands that adapt to changes in RSI volatility.
• Trend Flips
When the smoothed RSI crosses above or below its previous band level (shortBand or longBand), the script interprets this as a shift in momentum and sets a trend state accordingly (long or short).
• Candle Coloring
Finally, the script colors each candle according to how far the smoothed RSI is from a neutral baseline of 50:
Candles turn green when the RSI is sufficiently above 50, suggesting bullish momentum.
Candles turn red when the RSI is sufficiently below 50, indicating bearish momentum.
Candles turn orange when they are near the 50 level, reflecting a more neutral or transitional phase.
Traders can use these colored candles to quickly see when the RSI’s momentum has moved into overbought/oversold zones—or is shifting between bullish and bearish conditions—without needing to consult a separate oscillator window. The adaptive nature of the band calculations can help in spotting significant shifts in market sentiment and volatility.
ICT SB Time (Lee B)A minimal and clean indicator that simply plots the ICT Silver Bullet time windows for you on the chart with vertical lines.
It also has the option to show other important times, like 00:00, 8:30, and 9:30. Toggles in settings let you change line color, turn any of them off temporarily, and can limit their visibility to only the lower timeframes for less clutter.
I hope you find this indicator useful... and happy trading!
Lee B
[3Commas] HA & MAHA & MA
🔷What it does: This tool is designed to test a trend-following strategy using Heikin Ashi candles and moving averages. It enters trades after pullbacks, aiming to let profits run once the risk-to-reward ratio reaches 1:1 while securing the position.
🔷Who is it for: It is ideal for traders looking to compare final results using fixed versus dynamic take profits by adjusting parameters and trade direction—a concept applicable to most trading strategies.
🔷How does it work: We use moving averages to define the market trend, then wait for opposite Heikin Ashi candles to form against it. Once these candles reverse in favor of the trend, we enter the trade, using the last swing created by the pullback as the stop loss. By applying the breakeven ratio, we protect the trade and let it run, using the slower moving average as a trailing stop.
A buy signal is generated when:
The previous candle is bearish (ha_bear ), indicating a pullback.
The fast moving average (ma1) is above the slow moving average (ma2), confirming an uptrend.
The current candle is bullish (ha_bull), showing trend continuation.
The Heikin Ashi close is above the fast moving average (ma1), reinforcing the bullish bias.
The real price close is above the open (close > open), ensuring bullish momentum in actual price data.
The signal is confirmed on the closed candle (barstate.isconfirmed) to avoid premature signals.
dir is undefined (na(dir)), preventing repeated signals in the same direction.
A sell signal is generated when:
The previous candle is bullish (ha_bull ), indicating a temporary upward move before a potential reversal.
The fast moving average (ma1) is below the slow moving average (ma2), confirming a downtrend.
The current candle is bearish (ha_bear), showing trend continuation to the downside.
The Heikin Ashi close is below the fast moving average (ma1), reinforcing bearish pressure.
The real price close is below the open (close < open), confirming bearish momentum in actual price data.
The signal is confirmed after the candle closes (barstate.isconfirmed), avoiding premature entries.
dir is undefined (na(dir)), preventing consecutive signals in the same direction.
In simple terms, this setup looks for trend continuation after a pullback, confirming entries with both Heikin Ashi and real price action, supported by moving average alignment to avoid false signals.
If the price reaches a 1:1 risk-to-reward ratio, the stop will be moved to the entry point. However, if the slow moving average surpasses this level, it will become the new exit point, acting as a trailing stop
🔷Why It’s Unique
Easily visualizes the benefits of using risk-to-reward ratios when trading instead of fixed percentages.
Provides a simple and straightforward approach to trading, embracing the "keep it simple" concept.
Offers clear visualization of DCA Bot entry and exit points based on user preferences.
Includes an option to review the message format before sending signals to bots, with compatibility for multi-pair and futures contract pairs.
🔷 Considerations Before Using the Indicator
⚠️Very important: The indicator must be used on charts with real price data, such as Japanese candlesticks, line charts, etc. Do not use it on Heikin Ashi charts, as this may lead to unrealistic results.
🔸Since this is a trend-following strategy, use it on timeframes above 4 hours, where market noise is reduced and trends are clearer. Also, carefully review the statistics before using it, focusing on pairs that tend to have long periods of well-defined trends.
🔸Disadvantages:
False Signals in Ranges: Consolidating markets can generate unreliable signals.
Lagging Indicator: Being based on moving averages, it may react late to sudden price movements.
🔸Advantages:
Trend Focused: Simplifies the identification of trending markets.
Noise Reduction: Uses Heikin Ashi candles to identify trend continuation after pullbacks.
Broad Applicability: Suitable for forex, crypto, stocks, and commodities.
🔸The strategy provides a systematic way to analyze markets but does not guarantee successful outcomes. Use it as an additional tool rather than relying solely on an automated system.
Trading results depend on various factors, including market conditions, trader discipline, and risk management. Past performance does not ensure future success, so always approach the market cautiously.
🔸Risk Management: Define stop-loss levels, position sizes, and profit targets before entering any trade. Be prepared for potential losses and ensure your approach aligns with your overall trading plan.
🔷 STRATEGY PROPERTIES
Symbol: BINANCE:BTCUSDT (Spot).
Timeframe: 4h.
Test Period: All historical data available.
Initial Capital: 10000 USDT.
Order Size per Trade: 1% of Capital, you can use a higher value e.g. 5%, be cautious that the Max Drawdown does not exceed 10%, as it would indicate a very risky trading approach.
Commission: Binance commission 0.1%, adjust according to the exchange being used, lower numbers will generate unrealistic results. By using low values e.g. 5%, it allows us to adapt over time and check the functioning of the strategy.
Slippage: 5 ticks, for pairs with low liquidity or very large orders, this number should be increased as the order may not be filled at the desired level.
Margin for Long and Short Positions: 100%.
Indicator Settings: Default Configuration.
MA1 Length: 9.
MA2 Length: 18.
MA Calculations: EMA.
Take Profit Ratio: Disable. Ratio 1:4.
Breakeven Ratio: Enable, Ratio 1:1.
Strategy: Long & Short.
🔷 STRATEGY RESULTS
⚠️Remember, past results do not guarantee future performance.
Net Profit: +324.88 USDT (+3.25%).
Max Drawdown: -81.18 USDT (-0.78%).
Total Closed Trades: 672.
Percent Profitable: 35.57%.
Profit Factor: 1.347.
Average Trade: +0.48 USDT (+0.48%).
Average # Bars in Trades: 13.
🔷 HOW TO USE
🔸 Adjust Settings:
The default values—MA1 (9) and MA2 (18) with EMA calculation—generally work well. However, you can increase these values, such as 20 and 40, to better identify stronger trends.
🔸 Choose a Symbol that Typically Trends:
Select an asset that tends to form clear trends. Keep in mind that the Strategy Tester results may show poor performance for certain assets, making them less suitable for sending signals to bots.
🔸 Experiment with Ratios:
Test different take profit and breakeven ratios to compare various scenarios—especially to observe how the strategy performs when only the trade is protected.
🔸This is an example of how protecting the trade works: once the price moves in favor of the position with a 1:1 risk-to-reward ratio, the stop loss is moved to the entry price. If the Slow MA surpasses this level, it will act as a trailing stop, aiming to follow the trend and maximize potential gains.
🔸In contrast, in this example, for the same trade, if we set a take profit at a 1:3 risk-to-reward ratio—which is generally considered a good risk-reward relationship—we can see how a significant portion of the upward move is left on the table.
🔸Results Review:
It is important to check the Max Drawdown. This value should ideally not exceed 10% of your capital. Consider adjusting the trade size to ensure this threshold is not surpassed.
Remember to include the correct values for commission and slippage according to the symbol and exchange where you are conducting the tests. Otherwise, the results will not be realistic.
If you are satisfied with the results, you may consider automating your trades. However, it is strongly recommended to use a small amount of capital or a demo account to test proper execution before committing real funds.
🔸Create alerts to trigger the DCA Bot:
Verify Messages: Ensure the message matches the one specified by the DCA Bot.
Multi-Pair Configuration: For multi-pair setups, enable the option to add the symbol in the correct format.
Signal Settings: Enable whether you want to receive long or short signals (Entry | TP | SL), copy and paste the the messages for the DCA Bots configured.
Alert Setup:
When creating an alert, set the condition to the indicator and choose "alert() function call only.
Enter any desired Alert Name.
Open the Notifications tab, enable Webhook URL, and paste the Webhook URL.
For more details, refer to the section: "How to use TradingView Custom Signals".
Finalize Alerts: Click Create, you're done! Alerts will now be sent automatically in the correct format.
🔷 INDICATOR SETTINGS
MA 1: Fast MA Length
MA 2: Slow MA Length
MA Calc: MA's Calculations (SMA,EMA, RMA,WMA)
TP Ratio: This is the take profit ratio relative to the stop loss, where the trade will be closed in profit.
BE Ratio: This is the breakeven ratio relative to the stop loss, where the stop loss will be updated to breakeven or if the MA2 is greater than this level.
Strategy: Order Type direction in which trades are executed.
Use Custom Test Period: When enabled signals only works in the selected time window. If disabled it will use all historical data available on the chart.
Test Start and End: Once the Custom Test Period is enabled, here you select the start and end date that you want to analyze.
Check Messages: Enable the table to review the messages to be sent to the bot.
Entry | TP | SL: Enable this options to send Buy Entry, Take Profit (TP), and Stop Loss (SL) signals.
Deal Entry and Deal Exit : Copy and paste the message for the deal start signal and close order at Market Price of the DCA Bot. This is the message that will be sent with the alert to the Bot, you must verify that it is the same as the bot so that it can process properly so that it executes and starts the trade.
DCA Bot Multi-Pair: You must activate it if you want to use the signals in a DCA Bot Multi-pair in the text box you must enter (using the correct format) the symbol in which you are creating the alert, you can check the format of each symbol when you create the bot.
👨🏻💻💭 We hope this tool helps enhance your trading. Your feedback is invaluable, so feel free to share any suggestions for improvements or new features you'd like to see implemented.
__
The information and publications within the 3Commas TradingView account are not meant to be and do not constitute financial, investment, trading, or other types of advice or recommendations supplied or endorsed by 3Commas and any of the parties acting on behalf of 3Commas, including its employees, contractors, ambassadors, etc.
Boilerplate Configurable Strategy [Yosiet]This is a Boilerplate Code!
Hello! First of all, let me introduce myself a little bit. I don't come from the world of finance, but from the world of information and communication technologies (ICT) where we specialize in data processing with the aim of automating it and eliminating all human factors and actors in the processes. You could say that I am an algotrader.
That said, in my journey through trading in recent years I have understood that this world is often shown to be incomplete. All those who want to learn about trading only end up learning a small part of what it really entails, they only seek to learn how to read candlesticks. Therefore, I want to share with the entire community a fraction of what I have really understood it to be.
As a computer scientist, the most important thing is the data, it is the raw material of our work and without data you simply cannot do anything. Entropy is simple: Data in -> Data is transformed -> Data out.
The quality of the outgoing data will directly depend on the incoming data, there is no greater mystery or magic in the process. In trading it is no different, because at the end of the day it is nothing more than data. As we often say, if garbage comes in, garbage comes out.
Most people focus on the results only, on the outgoing data, because in the end we all want the same thing, to make easy money. Very few pay attention to the input data, much less to the process.
Now, I am not here to delude you, because there is no bigger lie than easy money, but I am here to give you a boilerplate code that will help you create strategies where you only have to concentrate on the quality of the incoming data.
To the Point
The code is a strategy boilerplate that applies the technique that you decide to customize for the criteria for opening a position. It already has the other factors involved in trading programmed and automated.
1. The Entry
This section of the boilerplate is the one that each individual must customize according to their needs and knowledge. The code is offered with two simple, well-known strategies to exemplify how the code can be reused for your own benefits.
For the purposes of this post on tradingview, I am going to use the simplest of the known strategies in trading for entries: SMA Crossing
// SMA Cross Settings
maFast = ta.sma(close, length)
maSlow = ta.sma(open, length)
The Strategy Properties for all cases published here:
For Stock TSLA H1 From 01/01/2025 To 02/15/2025
For Crypto XMR-USDT 30m From 01/01/2025 To 02/15/2025
For Forex EUR-USD 5m From 01/01/2025 To 02/15/2025
But the goal of this post is not to sell you a dream, else to show you that the same Entry decision works very well for some and does not for others and with this boilerplate code you only have to think of entries, not exits.
2. Schedules, Days, Sessions
As you know, there are an infinite number of markets that are susceptible to the sessions of each country and the news that they announce during those sessions, so the code already offers parameters so that you can condition the days and hours of operation, filter the best time parameters for a specific market and time frame.
3. Data Filtering
The data offered in trading are numerical series presented in vectors on a time axis where an endless number of mathematical equations can be applied to process them, with matrix calculation and non-linear regressions being the best, in my humble opinion.
4. Read Fundamental Macroeconomic Events, News
The boilerplate has integration with the tradingview SDK to detect when news will occur and offers parameters so that you can enable an exclusion time margin to not operate anything during that time window.
5. Direction and Sense
In my experience I have found the peculiarity that the same algorithm works very well for a market in a time frame, but for the same market in another time frame it is only a waste of time and money. So now you can easily decide if you only want to open LONG, SHORT or both side positions and know how effective your strategy really is.
6. Reading the money, THE PURPOSE OF EVERYTHING
The most important section in trading and the reason why many clients usually hire me as a financial programmer, is reading and controlling the money, because in the end everyone wants to win and no one wants to lose. Now they can easily parameterize how the money should flow and this is the genius of this boilerplate, because it is what will really decide if an algorithm (Indicator: A bunch of math equations) for entries will really leave you good money over time.
7. Managing the Risk, The Ego Destroyer
Many trades, little money. Most traders focus on making money and none of them know about statistics and the few who do know something about it, only focus on the winrate. Well, with this code you can unlock what really matters, the true success criteria to be able to live off of trading: Profit Factor, Sortino Ratio, Sharpe Ratio and most importantly, will you really make money?
8. Managing Emotions
Finally, the main reason why many lose money is because they are very bad at managing their emotions, because with this they will no longer need to do so because the boilerplate has already programmed criteria to chase the price in a position, cut losses and maximize profits.
In short, this is a boilerplate code that already has the data processing and data output ready, you only have to worry about the data input.
“And so the trader learned: the greatest edge was not in predicting the storm, but in building a boat that could not sink.”
DISCLAIMER
This post is intended for programmers and quantitative traders who already have a certain level of knowledge and experience. It is not intended to be financial advice or to sell you any money-making script, if you use it, you do so at your own risk.
Highs&Lows by HourHighs & Lows by Hour
Description:
Highs & Lows by Hour is a TradingView indicator that helps traders identify the most frequent hours at which daily high and low price points occur. By analyzing historical price data directly from the TradingView chart, this tool provides valuable insights into market timing, allowing traders to optimize their strategies around key price movements.
This indicator is specifically designed for the one-hour (H1) timeframe . It does not display any data on other timeframes , as it relies on analyzing daily highs and lows within hourly periods.
This indicator processes the available data based on the number of historical bars loaded in the TradingView chart. The number of analyzed bars depends on the TradingView subscription plan , which determines how much historical data is accessible.
Key Features:
Works exclusively on the H1 timeframe , ensuring accurate analysis of daily highs and lows
Hourly highs and lows analysis to identify the most frequent hours when the market reaches its daily high and low
Sorted by frequency, displaying the most significant trading hours in descending order based on their recurrence
Customizable table and colors to fit the chart theme and trading style
Useful for scalpers, day traders, and swing traders to anticipate potential price reversals and breakouts
How It Works:
The indicator scans historical price data directly from the TradingView chart to detect the hour at which daily highs and daily lows occur.
It counts the frequency of highs and lows for each hour of the trading day based on the number of available bars in the TradingView chart.
The recorded data is displayed in a structured table, sorted by frequency from highest to lowest.
Users can customize colors to enhance readability and seamlessly integrate the indicator into their analysis.
Why Use This Indicator?
Identify key market patterns by recognizing the most critical hours when price extremes tend to form
Improve timing for trades by aligning entries and exits with high-probability time windows
Enhance market awareness by understanding when market volatility is likely to peak based on historical trends
Important Notes:
This indicator works only on the one-hour (H1) timeframe . It will not display any data on other timeframes
Works well on Forex, stocks, crypto, and futures , especially for intraday traders
The indicator analyzes only the historical bars available on the TradingView chart, which varies depending on the TradingView subscription plan (Free, Pro, Pro+, Premium)
This indicator does not generate buy or sell signals but serves as a data-driven tool for market analysis
How to Use:
Apply the Highs & Lows by Hour indicator to a one-hour (H1) chart on TradingView
Review the table displaying the most frequent hours for daily highs and lows
Adjust colors and settings for better visualization
Use the data to refine trading decisions and align strategy with historical price behavior
Schwarzman Custom ORB with Box DisplayIndicator Overview
The Schwarzman Custom ORB (Opening Range Breakout) Indicator is a fully self-developed script designed for traders who utilize opening range breakout strategies. This indicator allows users to customize their ORB settings, apply them to historical price data, and visually connect multiple ORBs to analyze past performance. The goal is to provide traders with a tool to backtest and refine their breakout strategies based on historical ORB data.
How the Indicator Works
1️⃣ User-Defined ORB Settings
• The user selects a custom start time (hour and minute) for the ORB.
• The user defines a duration (e.g., 15 minutes, 30 minutes, etc.) for the ORB period.
• A timezone offset is included to adjust for different market sessions.
2️⃣ ORB High and Low Calculation
• The script records the highest and lowest prices within the selected ORB time window.
• The recorded values remain static after the ORB period ends, ensuring accurate range plotting.
3️⃣ Historical ORB Visualization
• Instead of only showing a single ORB for the current session, this indicator connects multiple ORBs across past data.
• This allows traders to visually analyze previous breakout performance.
• The plotted ORBs remain fixed and do not repaint, ensuring an accurate backtesting experience.
4️⃣ Stepline Visualization & Range Filling
• The high and low ORB levels are displayed using stepline plots to maintain clear horizontal levels.
• A shaded box is applied between the ORB high and low for better visualization.
Use Cases & Strategy Application
📌 Backtesting Historical ORBs – See how past ORBs performed under different market conditions.
📌 Custom ORB Settings – Adjust the start time and duration for different trading sessions.
📌 Multi-ORB Analysis – Connect ORBs over multiple trading days to study trends and breakouts.
📌 Breakout Strategy Optimization – Use the historical ORB connections to refine entry and exit points.
This indicator is particularly useful for day traders, scalpers, and breakout traders looking for a data-driven approach to trading.
Indicator Development & Transparency Statement
As a trader, I have tested various ORB (Opening Range Breakout) indicators available in the TradingView community. Through these experiences, I aimed to develop a version that best fits my own trading needs and strategy.
This script is a self-developed ORB tool, created from scratch while drawing inspiration from the concept of opening range breakouts, which is widely used in trading. Since I initially coded in Pine Script v4, I used ChatGPT to help refine and migrate the script to Pine Script v6 to ensure compatibility with the latest TradingView features. However, the core logic, structure, and customization were entirely designed and implemented based on my own approach.
I am making this indicator public not to violate any TradingView guidelines but to share my work with the trading community and provide a tool that can help others analyze ORB-based strategies. If there are any compliance concerns, I am open to adjusting the script accordingly, but I want to clarify that this is not a copy of any existing ORB script—it is a custom-built indicator tailored to my own trading preferences.
I appreciate the opportunity to contribute to the community and would welcome any specific feedback from TradingView regarding rule compliance.
Best regards,
Janko S. (Schwarzman)
Appeal to TradingView
Dear TradingView Team,
This script is 100% self-developed and does not copy or replicate any third-party code. It is a customized ORB tool designed for traders who wish to backtest and analyze opening range breakout strategies over multiple sessions. We kindly request specific clarification regarding which exact line(s) of code violate TradingView’s guidelines. If there are any compliance concerns, we are happy to adjust the script accordingly.
Please let us know the precise rules or community guidelines that were violated so we can make the necessary modifications.
🚀 Summary
✔ Fully Custom & Self-Developed – No copied or third-party code.
✔ Innovative Feature – Connects past ORBs for strategy backtesting.
✔ Transparent & Compliant – Requesting exact details on any potential rule violations.
Killzones & Previous High-Low Liquidity [odnac]This indicator is designed for use in intraday trading to visualize key "Killzones" (specific time windows during different global market sessions) and highlight liquidity levels based on previous highs and lows from the previous day and week.
It helps traders identify potential market entry and exit points based on time-based trading zones and price action levels.
Key Features:
Killzone (Market Session Timeframes):
Asia (2000-0000 UTC): Displays a shaded box over the Asia trading session.
Europe (0200-0500 UTC): Highlights the European trading session.
New York AM (0830-1100 UTC): Represents the morning session of the NY market.
New York PM (1330-1600 UTC): Represents the afternoon session of the NY market.
Each of these timeframes can be customized in terms of session start and end times, and the shaded areas will help identify high liquidity periods when the market tends to be more active.
Previous High-Low Liquidity Zones:
Previous Week's High/Low: Displays lines at the high and low of the previous week.
These are important liquidity levels that can influence price action.
Previous Day's High/Low: Shows the high and low from the previous trading day.
These are also significant levels to watch for potential support and resistance.
Filters and Customization:
Position Filtering: The indicator allows users to filter out previous highs or lows if the current price doesn't align with those levels.
For example, it can filter out previous week highs if the current price is lower than that level.
Vertical Lines: Optional vertical lines to highlight key time points such as the start and end of the previous week and day.
How It Works:
The indicator visually draws "killzones" as shaded regions on the chart, indicating periods of increased market activity.
This can help traders align their strategies with the most liquid periods of the day.
The previous high and low lines (both for the previous week and the previous day) are drawn as solid lines and can be toggled on/off in the settings.
Labels are added to indicate the specific levels and periods.
The indicator provides clear visual cues, helping traders assess if the price is near important liquidity levels and whether the current market conditions align with those levels.
Customizable Settings:
You can control whether each Killzone and liquidity level is shown on the chart.
Color customization for the various zones and lines is also available.
The indicator also lets you decide whether to hide weekend data, set time-frame limits, and choose whether or not to show vertical lines at the beginning and end of each trading session.
This indicator is aimed at traders who want to trade based on high-liquidity periods and understand where key support and resistance levels are likely to emerge based on previous price action.
Naive Bayes Candlestick Pattern Classifier v1.1 BETAAn intermezzo on why i made this script publication..
A : Candlestick Pattern took hours to backtest, why not using Machine Learning techniques?
B : Machine Learning, no that's gonna be really heavy bro!
A : Not really, because we use Naive Bayes.
B : The simplest, yet powerful machine learning algorithm to separate (a.k.a classify) multivariate data.
----------------------------------------------------------------------------------------------------------------------
Hello, everyone!
After deep research in extracting meaningful information from the market, I ended up building this powerful machine learning indicator based on the evolution of Bayesian Statistics. This indicator not only leverages the simplicity of Naive Bayes but also extends its application to candlestick pattern analysis, making it an invaluable tool for traders who are looking to enhance their technical analysis without spending countless hours manually backtesting each pattern on each market!.
What most interesting part is actually after learning all of likely useless methods like fibonacci, supply and demand, volume profile, etc. We always ended up back to basic like support and resistance and candlestick patterns, but with a slight twist on strategy algorithm design and statistical approach. Thus, the only reason why i made this, because i exactly know that you guys will ended up in this position as time goes by.
The essence of this indicator lies in its ability to automate the recognition and statistical evaluation of various candlestick patterns. Traditionally, traders have relied on visual inspection and manual backtesting to determine the effectiveness of patterns like Bullish Engulfing, Bearish Engulfing, Harami variations, Hammer formations, and even more complex multi-candle patterns such as Three White Soldiers, Three Black Crows, Dark Cloud Cover, and Piercing Pattern. However, these conventional methods are both time-consuming and prone to subjective bias.
To address these challenges, I employed Naive Bayes—a probabilistic classifier that, despite its simplicity, offers robust performance in various domains. Naive Bayes assumes that each feature is independent of the others given the class label, which, although a strong assumption, works remarkably well in practice, especially when the dataset is large like market data and the feature space is high-dimensional. In our case, each candlestick pattern acts as a feature that can be statistically evaluated based on its historical performance. The indicator calculates a probability that a given pattern will lead to a price reversal, by comparing the pattern’s close price to the highest or lowest price achieved in a lookahead window.
One of the standout features of this script is its flexibility. Each candlestick pattern is not only coded into the system but also comes with individual toggles to enable or disable them based on your trading strategy. This means you can choose to focus on single-candle patterns like Bullish Engulfing or more complex multi-candle formations such as Three White Soldiers, without modifying the core code. The built-in customization options allow you to adjust colors and labels for each pattern, giving you the freedom to tailor the visual output to your preference. This level of customization ensures that the indicator integrates seamlessly into your existing TradingView setup.
Moreover, the indicator isn’t just about pattern recognition—it also incorporates outcome-based learning. Every time a pattern is detected, it looks ahead a predefined number of bars to evaluate if the expected reversal actually materialized. This outcome is then stored in arrays, and over time, the script dynamically calculates the probability of success for each pattern. These probabilities are presented in a real-time updating table on your chart, which shows not only the percentage probability but also the count of historical occurrences. With this information at your fingertips, you can quickly gauge the reliability of each pattern in your chosen market and timeframe.
Another significant advantage of this approach is its speed and efficiency. While more complex machine learning models like neural networks might require heavy computational resources and longer training times, the Naive Bayes classifier in this script is lightweight, instantaneous and can be updated on the fly with each new bar. This real-time capability is essential for modern traders who need to make quick decisions in fast-paced markets.
Furthermore, by automating the process of backtesting, the indicator frees up your time to focus on other aspects of trading strategy development. Instead of manually analyzing hundreds or even thousands of candles, you can rely on the statistical power of Naive Bayes to provide you with insights on which patterns are most likely to result in profitable moves. This not only enhances your efficiency but also helps to eliminate the cognitive biases that often plague manual analysis.
In summary, this indicator represents a fusion of traditional candlestick analysis with modern machine learning techniques. It harnesses the simplicity and effectiveness of Naive Bayes to deliver a dynamic, real-time evaluation of various candlestick patterns. Whether you are a seasoned trader looking to refine your technical analysis or a beginner eager to understand market dynamics, this tool offers a powerful, customizable, and efficient solution. Welcome to a new era where advanced statistical methods meet practical trading insights—happy trading and may your patterns always be in your favor!
Note : On this current released beta version, you must manually adjust reversal percentage move based on each market. Further updates may include automated best range detection and probability.
ICT Killzones + Macros [TakingProphets]The ICT Killzones indicator is a powerful tool designed to visualize key trading sessions and market timing elements used in ICT (Inner Circle Trader) methodology. It includes:
• Session Markers:
- Asia Session
- London Session
- NY AM Session
- NY Lunch Session
- NY PM Session
• Key Price Levels:
- Session high/low levels that extend until violated
- Midnight Open price level (dotted line)
- True Day Open price level (6 PM EST, dotted line)
• ICT Macro Timing:
- First Macro: 9:45 AM - 10:15 AM EST
- Second Macro: 10:45 AM - 11:15 AM EST
- Distinctive L-shaped brackets marking start and end times
Features:
• Fully customizable colors and styles for all elements
• Adjustable label positions and sizes
• Toggle options for each component
• Smart timeframe filtering
• Clean, uncluttered visual design
This indicator helps traders identify key market structure points, session transitions, and optimal trading windows based on ICT concepts.
Johnny's Volatility-Driven Trend Identifier w/ Reversal SignalsJohnny's Volatility-Driven Trend Identifier w/ Reversal Signals is designed to identify high-probability trend shifts and reversals by incorporating volatility, momentum, and impulse-based filtering. It is specifically built for traders who want to capture strong trend movements while minimizing false signals caused by low volatility noise.
By leveraging Rate of Change (ROC), Relative Strength Index (RSI), and Average True Range (ATR)-based volatility detection, the indicator dynamically adapts to market conditions. It highlights breakout trends, reversals, and early signs of momentum shifts using strategically placed labels and color-coded trend visualization.
Inspiration taken from Top G indicator .
What This Indicator Does
The Volatility-Driven Trend Identifier works by:
Measuring Market Extremes & Momentum:
Uses ROC normalization with standard deviation to identify impulse moves in price action.
Implements RSI filtering to determine overbought/oversold conditions that validate trend strength.
Utilizes ATR-based volatility tracking to ensure signals only appear when meaningful market movements are occurring.
Identifying Key Trend Events:
Power Peak (🔥): Marks a confirmed strong downtrend, ideal for shorting opportunities.
Surge (🚀): Indicates a confirmed strong uptrend, signaling a potential long entry.
Soft Surge (↗): Highlights a mild bullish reentry or early uptrend formation.
Soft Peak (↘): Shows a mild bearish reentry or early downtrend formation.
Providing Adaptive Filtering for Reliable Signals:
Filters out weak trends with a volatility check, ensuring signals appear only in strong market conditions.
Implements multi-level confirmation by combining trend strength metrics, preventing false breakouts.
Uses gradient-based visualization to color-code market sentiment for quick interpretation.
What This Indicator Signals
Breakouts & Impulse Moves: 🚀🔥
The Surge (🚀) and Power Peak (🔥) labels indicate confirmed momentum breakouts, where the trend has been validated by a combination of ROC impulse, RSI confirmation, and ATR volatility filtering.
These signals suggest that the market is entering a strong trend, and traders can align their entries accordingly.
Early Trend Formation & Reentries: ↗ ↘
The Soft Surge (↗) and Soft Peak (↘) labels indicate areas where a trend might be forming, but is not yet fully confirmed.
These signals help traders anticipate potential entries before the trend gains full strength.
Volatility-Adaptive Trend Filtering: 📊
Since the indicator only activates in volatile conditions, it avoids the pitfalls of low-range choppy markets where false signals frequently occur.
ATR-driven adaptive windowing allows the indicator to dynamically adjust its sensitivity based on real-time volatility conditions.
How to Use This Indicator
1. Identifying High-Probability Entries
Bullish Entries (Long Trades)
Look for 🚀 Surge signals in an uptrend.
Confirm with RSI (should be above 50 for momentum).
Ensure volatility is increasing to validate the breakout.
Use ↗ Soft Surge signals for early entries before the trend fully confirms.
Bearish Entries (Short Trades)
Look for 🔥 Power Peak signals in a downtrend.
RSI should be below 50, indicating downward momentum.
Volatility should be rising, ensuring market momentum is strong.
Use ↘ Soft Peak signals for early entries before a full bearish confirmation.
2. Avoiding False Signals
Ignore signals when the market is ranging (low ATR).
Check RSI and ROC alignment to ensure trend confirmation.
Use additional confluences (e.g., price action, support/resistance levels, moving averages) for enhanced accuracy.
3. Trend Confirmation & Filtering
The stronger the trend, the higher the likelihood that Surge (🚀) and Power Peak (🔥) signals will continue in their direction.
Soft Surge (↗) and Soft Peak (↘) act as early warning signals before major breakouts occur.
What Makes This a Machine Learning-Inspired Moving Average?
While this indicator is not a direct implementation of machine learning (as Pine Script lacks AI/ML capabilities), it mimics machine learning principles by adapting dynamically to market conditions using the following techniques:
Adaptive Trend Selection:
It does not rely on fixed moving averages but instead adapts dynamically based on volatility expansion and momentum detection.
ATR-based filtering adjusts the indicator’s sensitivity to real-time conditions.
Multi-Factor Confirmation (Feature Engineering Equivalent in ML):
Combines ROC, RSI, and ATR in a structured way, similar to how ML models use multiple inputs to filter and classify data.
Implements conditional trend recognition, ensuring that only valid signals pass through the filter.
Noise Reduction with Data Smoothing:
The algorithm avoids false signals by incorporating trend intensity thresholds, much like how ML models remove outliers to refine predictions.
Adaptive filtering ensures that low-volatility environments do not produce misleading signals.
Why Use This Indicator?
✔ Reduces False Signals: Multi-factor validation ensures only high-confidence signals are triggered.
✔ Works in All Market Conditions: Volatility-adaptive nature allows the indicator to perform well in both trending and ranging markets.
✔ Great for Swing & Intraday Trading: It helps spot momentum shifts early and allows traders to catch major market moves before they fully develop.
✔ Visually Intuitive: Color-coded trends and clear signal markers make it easy to interpret.
