Quantum Dip Hunter | AlphaNattQuantum Dip Hunter | AlphaNatt
🎯 Overview
The Quantum Dip Hunter is an advanced technical indicator designed to identify high-probability buying opportunities when price temporarily dips below dynamic support levels. Unlike simple oversold indicators, this system uses a sophisticated quality scoring algorithm to filter out low-quality dips and highlight only the best entry points.
"Buy the dip" - but only the right dips. Not all dips are created equal.
⚡ Key Features
5 Detection Methods: Choose from Dynamic, Fibonacci, Volatility, Volume Profile, or Hybrid modes
Quality Scoring System: Each dip is scored from 0-100% based on multiple factors
Smart Filtering: Only signals above your quality threshold are displayed
Visual Effects: Glow, Pulse, and Wave animations for the support line
Risk Management: Automatic stop-loss and take-profit calculations
Real-time Statistics: Live dashboard showing current market conditions
📊 How It Works
The indicator calculates a dynamic support line using your selected method
When price dips below this line, it evaluates the dip quality
Quality score is calculated based on: trend alignment (30%), volume (20%), RSI (20%), momentum (15%), and dip depth (15%)
If the score exceeds your minimum threshold, a buy signal arrow appears
Stop-loss and take-profit levels are automatically calculated and displayed
🚀 Detection Methods Explained
Dynamic Support
Adapts to recent price action
Best for: Trending markets
Uses ATR-adjusted lowest points
Fibonacci Support
Based on 61.8% and 78.6% retracement levels
Best for: Pullbacks in strong trends
Automatically switches between fib levels
Volatility Support
Uses Bollinger Band methodology
Best for: Range-bound markets
Adapts to changing volatility
Volume Profile Support
Finds high-volume price levels
Best for: Identifying institutional support
Updates dynamically as volume accumulates
Hybrid Mode
Combines all methods for maximum accuracy
Best for: All market conditions
Takes the most conservative support level
⚙️ Key Settings
Dip Detection Engine
Detection Method: Choose your preferred support calculation
Sensitivity: Higher = more sensitive to price movements (0.5-3.0)
Lookback Period: How far back to analyze (20-200 bars)
Dip Depth %: Minimum dip size to consider (0.5-10%)
Quality Filters
Trend Filter: Only buy dips in uptrends when enabled
Minimum Dip Score: Quality threshold for signals (0-100%)
Trend Strength: Required trend score when filter is on
📈 Trading Strategies
Conservative Approach
Use Dynamic method with Trend Filter ON
Set minimum score to 80%
Risk:Reward ratio of 2:1 or higher
Best for: Swing trading
Aggressive Approach
Use Hybrid method with Trend Filter OFF
Set minimum score to 60%
Risk:Reward ratio of 1:1
Best for: Day trading
Scalping Setup
Use Volatility method
Set sensitivity to 2.0+
Focus on Target 1 only
Best for: Quick trades
🎨 Visual Customization
Color Themes:
Neon: Bright cyan/magenta for dark backgrounds
Ocean: Cool blues and teals
Solar: Warm yellows and oranges
Matrix: Classic green terminal look
Gradient: Smooth color transitions
Line Styles:
Solid: Clean, simple line
Glow: Adds depth with glow effect
Pulse: Animated breathing effect
Wave: Oscillating wave pattern
💡 Pro Tips
Start with the Trend Filter ON to avoid catching falling knives
Higher quality scores (80%+) have better win rates but fewer signals
Use Volume Profile method near major support/resistance levels
Combine with your favorite momentum indicator for confirmation
The pulse animation can help draw attention to key levels
⚠️ Important Notes
This indicator identifies potential entries, not guaranteed profits
Always use proper risk management
Works best on liquid instruments with good volume
Backtest your settings before live trading
Not financial advice - use at your own risk
📊 Statistics Panel
The live statistics panel shows:
Current detection method
Support level value
Trend direction
Distance from support
Current signal status
🤝 Support
Created by AlphaNatt
For questions or suggestions, please comment below!
Happy dip hunting! 🎯
Not financial advice, always do your own research
Cari dalam skrip untuk "volume profile"
.srb suiteThe essential suite Indicator.
that are well integrated to ensure visibility of essential items for trading.
it is very cumbersome to put symbol in the Tradingview chart and combine essential individual indicators one by one.
Moreover even with such a combination, the chart is messy and visibility is not good.
This is because each indicator is not designed with the others in mind.
This suite was developed as a composite-solution to that situation, and will make you happy.
designed to work in the same pane with open-source indicator by default.
Recommended visual order ; Back = .srb suite, Front = .srb suite vol & info
individually turn on/off only what you need on the screen.
BTC-agg. Volume
4 BTC-spot & 4 BTC-PERP volume aggregated.
It might helps you don't miss out on important volume flows.
Weighted to spot trading volume when using PERP+spot volume .
If enabled, BTC-agg.Vol automatically applied when selecting BTC-pair.
--> This is used in calculations involving volumes, such as VWAP.
Moving Average
1 x JMA trend ribbon ; Accurately follow short-term trend changes.
3 x EMA ribbon ; zone , not the line.
MA extension line ; It provide high visibility to recognize the direction of the MA.
SPECIAL TOOLS
VWAP with Standard Deviation Bands
VWAP ruler
BB regular (Dev. 2.0, 2.5)
BB Extented (Dev. 2.5, 3.0, 3.5)
Fixed Range Volume Profile ; steamlined one, performace tuned & update.
SPECIAL TOOLS - Auto Fibonacci Retracement - New GUI
'built-in auto FBR ' has been re-born
It shows - retracement Max top/ min bottom ; for higher visibility
It shows - current retracement position ; for higher visibility
The display of the Fib position that exceeds the regular range is auto-determined according to the price.
tradingview | chart setting > Appearance > Top margin 0%, Bottom margin 0% for optimized screen usage
tradingview | chart setting > Appearance > Right margin 57
.srb suite vol & info --> Visual Order > Bring to Front
.srb suite vol & info --> Pin to scale > No scale (Full-screen)
Visual order ; Back = .srb suite, Front = .srb suite vol & info
1. Fib.Retracement core is from tradingview built-in FBR ---> upgrade new-type GUI, and performance tuned.
2. Fixed-range volume-profile core is from the open-source one ---> some update & perf.tuned.
---------------------------------------------------------------------------------------------------------------------------------------
if you have any questions freely contact to me by message on tradingview.
but please understand that responses may be quite late.
Special thanks to all of contributors of community.
The script may be freely distributed under the MIT license.
VPoC per barThis study prints the current bar VPoC as an horizontal line.
It's aimed originally at BTCUSDT pair and 15m timeframe.
HOW IT WORKS
Zoom In mode: This is the default mode.
The study zooms in into the latest 15 1-minute bar candles in order to calculate the 15 minute candle VPoC.
Zoom Out mode: The VPoC from the last n bars from the current timeframe that match desired timeframe is shown on each bar.
In either case you are recommended to click on the '...' button associated to this study
and select 'Visual Order. Bring to Front.' so that it's properly shown in your chart.
HOW IT WORKS - Zoom In mode
Make sure that '(VP) Zoom into the VP timeframe' setting is set to true.
Choose the zoomed in timeframe where to calculate VPoC from thanks to the '(VP) Zoomed timeframe {1 minute}' setting.
Change '(VP) Zoomed in timeframe bars per current timeframe bar {15}' to its appropiated value. You just need to divide the current timeframe minutes per the zoomed in timeframe minutes per bar. E.g. If you are in 60 minute timeframe and you want to zoom in into 5 minute timeframe: 60 / 5 = 12 . You will write 12 here.
HOW IT WORKS - Zoom Out mode
Make sure that '(VP) Zoom into the VP timeframe' setting is set to false.
If you are using the Zoom out mode you might want to set '(VP) Print VPoC price as discrete lines {True}' to false.
Either choose the zoommed out timeframe where to calculate VPoC from thanks to the '(VP) Zoomed timeframe {1 minute}' setting or turn on the '(VP) Use number of bars (not VP timeframe)' setting in order to use '(VP) Number of bars {100}' as a custom number of bars.
WARNING - Zoom In mode last bar
The way that PineScript handles security function in last bar might result on the last bar not being accurate enough.
SETTINGS
__ SETTINGS - Volume Profile
(VP) Zoomed timeframe {1 minute}: Timeframe in which to zoom in or zoom out to calculate an accurate VPoC for the current timeframe.
(VP) Zoomed in timeframe bars per current timeframe bar {15}: Check 'HOW IT WORKS - Zoom In mode' above. Note : It is only used in 'Zoom in' mode.
(VP) Number of bars {100}: If 'Use number of bars (not VP timeframe)' is turned on this setting is used to calculate session VPoC. Note : It is only used in 'Zoom out' mode.
(VP) Price levels {24}: Price levels for calculating VPoC.
__ SETTINGS - MAIN TURN ON/OFF OPTIONS
(VP) Print VPoC price {True}: Show VPoC price
(VP) Zoom into the VP timeframe: When set to true the VPoC is calculated by zooming into the lower timeframe. When set to false a higher timeframe (or number of bars) is used.
(VP) Realtime Zoom in (Beta): Enable real time zoom for the last bar. It's beta because it would only work with zoomed in timeframe under 60 minutes. And when ratio between zoomout and zoomin is less than 60. Note : It is only used in 'Zoom in' mode.
(VP) Use number of bars (not VP timeframe): Uses 'Number of bars {100}' setting instead of 'Volume Profile timeframe' setting for calculating session VPoC. Note : It is only used in 'Zoom out' mode.
(VP) Print VPoC price as discrete lines {True}: When set to true the VPoC is shown as an small line in the center of each bar. When set to the false the VPoC line is printed as a normal line.
__ SETTINGS - EXTRA
(VP) VPoC color: Change the VPoC color
(VP) VPoC line width {1}: Change VPoC line width (in pixels).
(VP) Use number of bars (not VP timeframe): Uses 'Number of bars {100}' setting instead of 'Volume Profile timeframe' setting for calculating session VPoC. Note : It is only used in 'Zoom out' mode.
(VP) Print VPoC price as discrete lines {True}: When set to true the VPoC is shown as an small line in the center of each bar. When set to the false the VPoC line is printed as a normal line.
CREDITS
I have reused and adapted some code from
"Poor man's volume profile" study
which it's from TradingView IldarAkhmetgaleev user.
WorldCup Dashboard + Institutional Sessions© 2025 NewMeta™ — Educational use only.
# Full, Premium Description
## WorldCup Dashboard + Institutional Sessions
**A trade-ready, intraday framework that combines market structure, real flow, and institutional timing.**
This toolkit fuses **Institutional Sessions** with a **price–volume decision engine** so you can see *who is active*, *where value sits*, and *whether the drive is real*. You get: **CVD/Delta**, volume-weighted **Momentum**, **Aggression** spikes, **FVG (MTF)** with nearest side, **Daily Volume Profile (VAH/POC/VAL)**, **ATR regime**, a **24h position gauge**, classic **candle patterns**, IBH/IBL + **first-hour “true close”** lines, and a **10-vote confluence scoreboard**—all in one view.
---
## What’s inside (and how to trade it)
### 🌍 Institutional Sessions (Sydney • Tokyo • London • New York)
* Session boxes + a highlighted **first hour**.
* Plots the **true close** (first-hour close) as a running line with a label.
**Use:** Many desks anchor risk to this print. Above = bullish bias; below = bearish. **IBH/IBL** breaks during London/NY carry the most signal.
### 📊 CVD / Delta (Flow)
* Net buyer vs seller pressure with smooth trend state.
**Use:** **Rising CVD + acceptance above mid/POC** confirms continuation. Bearish price + rising CVD = caution (possible absorption).
### ⚡ Volume-Weighted Momentum
* Momentum adjusted by participation quality (volume).
**Use:** Momentum>MA and >0 → trend drive is “real”; <0 and falling → distribution risk.
### 🔥 Aggression Detector
* ROC × normalized volume × wick factor to flag **forceful** candles.
**Use:** On spikes, avoid fading blindly—wait for pullbacks into **aligned FVG** or for aggression to cool.
### 🟦🟪 Fair Value Gaps (with MTF)
* Detects up to 3 recent FVGs and marks the **nearest** side to price.
**Use:** Trend pullbacks into **bullish FVG** for longs; bounces into **bearish FVG** for shorts. Optional threshold to filter weak gaps.
### 🧭 24h Gauge (positioning)
* Shows current price across the 24h low⇢high with a mid reference.
**Use:** Above mid and pushing upper third = momentum continuation setups; below mid = sell the rips bias.
### 🧱 Daily Volume Profile (manual per day)
* **VAH / POC / VAL** derived from discretized rows.
**Use:** **POC below** supports longs; **POC above** caps rallies. Fade VAH/VAL in ranges; treat them as break/hold levels in trends.
### 📈 ATR Regime
* **ATR vs ATR-avg** with direction and regime flag (**HIGH / NORMAL / LOW**).
**Use:** HIGH ⇒ give trades room & favor trend following. LOW ⇒ fade edges, scale targets.
### 🕯️ Candle Patterns (contextual, not standalone)
* Engulfings, Morning/Evening Star, 3 Soldiers/Crows, Harami, Hammer/Shooting Star, Double Top/Bottom.
**Use:** Only with session + flow + momentum alignment.
### 🤝 Price–Volume Classification
* Labels each bar as **continuation**, **exhaustion**, **distribution**, or **healthy pullback**.
**Use:** Align continuation reads with trend; treat “Price↑ + Vol↓” as a caution flag.
### 🧪 Confluence Scoreboard & B/S Meter
* Ten elements vote: 🔵 bull, ⚪ neutral, 🟣 bear.
**Use:** Execution filter—take setups when the board’s skew matches your trade direction.
---
## Playbooks (actionable)
**Trend Pullback (Long)**
1. London/NY active, Momentum↑, CVD↑, price above 24h mid & POC.
2. Pullback into **nearest bullish FVG**.
3. Invalidate under FVG low or **true-close** line.
4. Targets: IBH → VAH → 24h high.
**Range Fade (Short)**
1. Asia/quiet regime, **Price↑ + Vol↓** into **VAH**, ATR low.
2. Nearest FVG bearish or scoreboard skew bearish.
3. Invalidate above VAH/IBH.
4. Targets: POC → VAL.
**News/Impulse**
Aggression spike? Don’t chase. Let it pull back into the aligned FVG; require CVD/Momentum agreement before entry.
---
## Alerts (included)
* **Bull/Bear Confluence ≥ 7/10**
* **Intraday Target Achieved** / **Daily Target Achieved**
* **Session True-Close Retests** (Sydney/Tokyo/London/NY)
*(Keep alerts “Once per bar” unless you specifically want intrabar triggers.)*
---
## Setup Tips
* **UTC**: Choose the reference that matches how you track sessions (default UTC+2).
* **Volume threshold**: 2.0× is a strong baseline; raise for noisy alts, lower for majors.
* **CVD smoothing**: 14–24 for scalps; 24–34 for slower markets.
* **ATR lengths**: Keep defaults unless your asset has a persistent regime shift.
---
## Why this framework?
Because **timing (sessions)**, **truth (flow)**, and **location (value/FVG)** together beat any single signal. You get *who is trading*, *how strong the push is*, and *where risk lives*—on one screen—so execution is faster and cleaner.
---
**Disclaimer**: Educational use only. Not financial advice. Markets are risky—backtest and size responsibly.
Volume Voids [theUltimator5]Volume Voids highlights price regions with no or unusually thin participation over a chosen lookback. It bins the lookback’s full price range into equal steps, assigns each bar’s close to a bin, and accumulates volume per bin. Contiguous runs of zero-volume bins are shown as “voids,” while low-volume runs (below a dynamic threshold) mark thin-liquidity “corridors” where price often traverses quickly when revisited.
An optional PoC (Point of Control) line marks the mid-price of the highest-volume bin—commonly treated as a recent “value” area that price may revisit.
What it draws on your chart
Histogram (optional): Right-anchored horizontal volume-by-price bars built from your lookback and bin count. Bars tint green→red via a simple delta proxy (up-bar volume minus down-bar volume) to hint at directional participation inside each price band.
Point of Control (optional): A horizontal line at the highest-volume bin’s mid-price (the PoC).
Zero-Volume Voids: Translucent boxes where no bin volume printed within the window (detected between the first and last non-empty bins ).
Low-Volume Zones: Translucent boxes where bin volume is below a dynamic threshold (see formula below), often acting like low-friction corridors.
How it works
Slice the lookback’s high→low into N equal price bins.
Assign each bar’s closing price to a bin and add that bar’s volume to the bin total. A simple up/down-bar delta proxy drives the histogram’s tinting.
PoC = bin with the maximum accumulated volume.
Zero-Volume Voids = contiguous runs of bins with exactly zero volume (bounded by the first/last occupied bins).
Low-Volume Zones = contiguous runs of bins with volume below:
threshold = total_window_volume ÷ (divisor × number_of_bins)
Lower divisor → more LV boxes; higher divisor → stricter/fewer boxes.
Note: This is a lightweight, chart-native approximation of a volume profile. Volume is binned by bar close (not by tick-level prints or intrabar distribution), so “voids”/“thin” areas reflect this approximation.
Key inputs
Lookback Period: Window for calculations.
Number of Volume Boxes (bins): Histogram resolution.
PoC / Show Histogram / Anchor to Right Side: Visibility and layout controls.
Low-Volume Threshold Divisor: Sensitivity for LV detection.
Colors & Labels: Customize zero-volume / low-volume box colors and optional labels with offsets.
How to use (educational, not signals)
Context: High-volume = acceptance; thin/zero-volume = inefficiency. Price often rotates near acceptance and moves faster through thin areas.
Revisits: On returns to prior voids/LV zones, watch for accelerated moves or fills; PoC can serve as a balance reference.
Confluence: Pair with trend tools (e.g., ADX), VWAP/session markers, or structure levels for timing and risk.
Limitations & performance
Bins use closing price only; intrabar distribution is not modeled.
Detections refresh on the live bar; visuals can be heavy on large lookbacks/high bin counts—reduce bins/lookback or hide labels if needed.
Technical Summary VWAP | RSI | VolatilityTechnical Summary VWAP | RSI | Volatility
The Quantum Trading Matrix is a multi-dimensional market-analysis dashboard designed as an educational and idea-generation tool to help traders read price structure, participation, momentum and volatility in one compact view. It is not an automated execution system; rather, it aggregates lightweight “quantum” signals — VWAP position, momentum oscillator behaviour, multi-EMA trend scoring, volume flow and institutional activity heuristics, market microstructure pivots and volatility measures — and synthesizes them into a single, transparent score and signal recommendation. The primary goal is to make explicit why a given market looks favourable or unfavourable by showing the individual ingredients and how they combine, enabling traders to learn, test and form rules based on observable market mechanics.
Each module of the matrix answers a distinct market question. VWAP and its percentage distance indicate whether the current price is trading above or below the intraday volume-weighted average — a proxy for intraday institutional control and value. The quantum momentum oscillator (fast and slow EMA difference scaled to percent) captures short-to-intermediate momentum shifts, providing a quickly responsive view of directional pressure. Multi-EMA trend scoring (8/21/50) produces a simple, transparent trend score by counting conditions such as price above EMAs and cross-EMAs ordering; this score is used to categorize market trend into descriptive buckets (e.g., STRONG UP, WEAK UP, NEUTRAL, DOWN). Volume analysis compares current volume to a recent moving average and computes a Z-score to detect spikes and unusual participation; additional buy/sell pressure heuristics (buyingPressure, sellingPressure, flowRatio) estimate whether upside or downside participation dominates the bar. Institutional activity is approximated by flagging large orders relative to volume baseline (e.g., volume > 2.5× MA) and estimating a dark pool proxy; this is a heuristic to highlight bars that likely had large players involved.
The dashboard also performs market-structure detection with small pivot windows to identify recent local support/resistance areas and computes price position relative to the daily high/low (dailyMid, pricePosition). Volatility is measured via ATR divided by price and bucketed into LOW/NORMAL/HIGH/EXTREME categories to help you adapt stop sizing and expectational horizons. Finally, all these pieces feed an interpretable scoring function that rewards alignment: VWAP above, strong flow ratio, bullish trend score, bullish momentum, and favorable RSI zone add to the overall score which is presented as a 0–100 metric and a colored emoji indicator for at-a-glance assessment.
The mashup is purposeful: each indicator covers a failure mode of the other. For example, momentum readings can be misleading during volatility spikes; VWAP informs whether institutions are on the bid or offer; volume Z-score detects abnormal participation that can validate a breakout; multi-EMA score mitigates single-EMA whipsaws by requiring a combination of price/EMA conditions. Combining these signals increases information content while keeping each component explainable — a key compliance requirement. The script intentionally emphasizes transparency: when it shows a BUY/SELL/HOLD recommendation, the dashboard shows the underlying sub-components so a trader can see whether VWAP, momentum, volume, trend or structure primarily drove the score.
For practical use, adopt a clear workflow: (1) check the matrix score and read the component tiles (VWAP position, momentum, trend and volume) to understand the drivers; (2) confirm market-structure support/resistance and pricePosition relative to the daily range; (3) require at least two corroborating components (for example, VWAP ABOVE + Momentum BULLISH or Volume spike + Trend STRONG UP) before considering entries; (4) use ATR-based stops or daily pivot distance for stop placement and size positions such that the trade risks a small, pre-defined percent of capital; (5) for intraday scalps shorten holding time and tighten stops, for swing trades increase lookback lengths and require multi-timeframe (higher TF) agreement. Treat the matrix as an idea filter and replay lab: when an alert triggers, replay the bars and observe which components anticipated the move and which lagged.
Parameter tuning matters. Shortening the momentum length makes the oscillator more sensitive (useful for scalping), while lengthening it reduces noise for swing contexts. Volume profile bars and MA length should match the instrument’s liquidity — increase the MA for low-liquidity stocks to reduce false institutional flags. The trend multiplier and signal sensitivity parameters let you calibrate how aggressively the matrix counts micro evidence into the score. Always backtest parameter sets across multiple periods and instruments; run walk-forward tests and keep a simple out-of-sample validation window to reduce overfitting risk.
Limitations and failure modes are explicit: institutional flags and dark-pool estimates are heuristics and cannot substitute for true tape or broker-level order flow; volume split by price range is an approximation and will not perfectly reflect signed volume; pivot detection with small windows may miss larger structural swings; VWAP is typically intraday-centric and less meaningful across multi-day swing contexts; the score is additive and may not capture non-linear relationships between features in extreme market regimes (e.g., flash crashes, circuit breaker events, or overnight gaps). The matrix is also susceptible to false signals during major news releases when price and volume behavior dislocate from typical patterns. Users should explicitly test behavior around earnings, macro data and low-liquidity periods.
To learn with the matrix, perform these experiments: (A) collect all BUY/SELL alerts over a 6-month period and measure median outcome at 5, 20 and 60 bars; (B) require additional gating conditions (e.g., only accept BUY when flowRatio>60 and trendScore≥4) and compare expectancy; (C) vary the institutional threshold (2×, 2.5×, 3× volumeMA) to see how many true positive spikes remain; (D) perform multi-instrument tests to ensure parameters are not tuned to a single ticker. Document every test and prefer robust, slightly lower returns with clearer logic rather than tuned “optimal” results that fail out of sample.
Originality statement: This script’s originality lies in the curated combination of intraday value (VWAP), multi-EMA trend scoring, momentum percent oscillator, volume Z-score plus buy/sell flow heuristics and a compact, interpretable scoring system. The script is not a simple indicator mashup; it is a didactic ensemble specifically designed to make internal rationale visible so traders can learn how each market characteristic contributes to actionable probability. The tool’s novelty is its emphasis on interpretability — showing the exact contributing signals behind a composite score — enabling reproducible testing and educational value.
Finally, for TradingView publication, include a clear description listing the modules, a short non-technical summary of how they interact, the tunable inputs, limitations and a risk disclaimer. Remove any promotional content or external contact links. If you used trademark symbols, either provide registration details or remove them. This transparent documentation satisfies TradingView’s requirement that mashups justify their composition and teach users how to use them.
Quantum Trading Matrix — multi-factor intraday dashboard (educational use only).
Purpose: Combines intraday VWAP position, a fast/slow EMA momentum percent oscillator, multi-EMA trend scoring (8/21/50), volume Z-score and buy/sell flow heuristics, pivot-based microstructure detection, and ATR-based volatility buckets to produce a transparent, componentized market score and trade-idea indicator. The mashup is intentional: VWAP identifies intraday value, momentum detects short bursts, EMAs provide structural trend bias, and volume/flow confirm participation. Signals require alignment of at least two components (for example, VWAP ABOVE + Momentum BULLISH + positive flow) for higher confidence.
Inputs: momentum period, volume MA/profile length, EMA configuration (8/21/50), trend multiplier, signal sensitivity, color and display options. Use shorter momentum lengths for scalps and longer for swing analysis. Increase volume MA for thinly traded instruments.
Limitations: Institutional/dark-pool estimates and flow heuristics are approximations, not actual exchange tape. VWAP is intraday-focused. Expect false signals during major news or low-liquidity sessions. Backtest and paper-trade before applying real capital.
Risk Disclaimer: For education and analysis only. Not financial advice. Use proper risk management. The author is not responsible for trading losses.
________________________________________
Risk & Misuse Disclaimer
This indicator is provided for education, analysis and idea generation only. It is not investment or financial advice and does not guarantee profits. Institutional activity flags, dark-pool estimates and flow heuristics are approximations and should not be treated as exchange tape. Backtest thoroughly and use demo/paper accounts before trading real capital. Always apply appropriate position sizing and stop-loss rules. The author is not responsible for any trading losses resulting from the use or misuse of this tool.
________________________________________
Risk Disclaimer: This tool is provided for education and analysis only. It is not financial advice and does not guarantee returns. Users assume all risk for trades made based on this script. Back test thoroughly and use proper risk management.
VHX EMA 135/315📈 EMA 135/315 Cross Strategy – Your Trend Compass with Smart Confirmations
🔍 Core Idea
The EMA 135/315 Cross strategy is a trend-following system.
It tracks two moving averages:
EMA 135 → the “fast” line that reacts to short-term price moves
EMA 315 → the “slow” line that reacts to the bigger trend
When the fast EMA crosses above the slow EMA → market momentum is turning up → BUY signal 🟢
When the fast EMA crosses below the slow EMA → momentum is turning down → SELL signal 🔴
This gives you a clear entry trigger — no guessing, no overcomplication.
✨ On Your Chart
BUY/SELL Arrows
🟢 Green arrow = bullish cross → trend turning up
🔴 Red arrow = bearish cross → trend turning down
Trend Info Panel (Top Left)
Current Trend: BUY / SELL / Neutral
Last Cross: how many bars ago it happened
EMA Gap in %: measures the strength of the trend
Status: “Approaching” if EMAs are getting close → possible cross soon
Automatic TP/SL Levels
📈 TP line (+2% from entry)
📉 SL line (–0.5% from entry)
Saves time — you instantly see your target and protection
EMA Distance Meter
Big % gap = strong trend momentum 🚀
Small % gap = weak or sideways market ⚠️
Real-Time Alerts
You get notified when a cross happens, even if you’re away from the screen
🧠 The Logic Behind It
The EMA 135 reacts faster → it reflects short-term momentum
The EMA 315 moves slower → it reflects the main trend
When the fast EMA overtakes the slow EMA: short-term strength now aligns with the long-term trend → higher probability of a sustained move
The gap % tells you how strong the alignment is — large gap = cleaner moves, small gap = market in transition
“Approaching” status warns that the EMAs are converging, which often happens before a reversal
📊 Boosting the Strategy with Volume Analysis
The EMA cross is a strong trigger, but volume confirms the quality of the move:
High Volume + Cross → more reliable signal, as strong market participation is pushing the trend
Low Volume + Cross → caution, the move might be weak or a false breakout
💡 Tip:
Check the volume histogram or a volume-based indicator (e.g., Volume Profile, OBV).
On a BUY signal: volume should spike above the recent average.
On a SELL signal: watch for strong selling volume bars.
📍 Adding Support & Resistance for Precision
Support and resistance levels help filter out bad trades and optimize entries:
Best BUY setups:
EMA 135 crosses above EMA 315 near a known support zone
Bonus if volume confirms the move
Avoid buying directly into a strong resistance
Best SELL setups:
EMA 135 crosses below EMA 315 near a known resistance zone
Bonus if selling volume is strong
Avoid selling directly into a major support
💡 Use tools like horizontal lines, previous highs/lows, and Volume Profile nodes to spot these zones.
📈 Best Usage Practices
Timeframes
Lower timeframes (1m–5m) → more signals, but more noise → best for scalping with extra filters
Always Combine With Confirmation
EMA Cross = Trigger
Volume spike = Confirmation
S/R zone in your favor = High-probability setup
Manage Risk
Start with the built-in TP/SL
Adjust SL if volatility is higher than usual
Consider trailing stop once price moves in your favor
Avoid Sideways Markets
If EMA gap % is very small and crosses happen often → stand aside until a clear direction forms
Use Alerts
Set alerts for BUY & SELL crosses so you never miss a setup
In short:
This isn’t just an EMA cross indicator — it’s a trend system with built-in risk management, strength measurement, and pre-trade preparation. Combine it with volume confirmation and smart use of support/resistance, and you turn a simple signal into a high-probability trading edge.
Z-Score Volume with CVD Clustering Script Title:
Z-Score Volume with CVD Clustering & NY VWAP
📘 Description:
This indicator combines statistical volume analysis with order flow confirmation to detect high-probability trade zones and volume-based divergences.
📌 Components:
Z-Score of Volume: Identifies statistically significant volume surges or drops relative to a moving average baseline.
Cumulative Volume Delta (CVD): Gauges net buying vs. selling pressure using high-frequency bid/ask delta.
K-Means Clustering: Applies clustering logic to classify each bar into:
Cluster 2 – Strong Bullish: Z-Score and CVD both strong
Cluster 1 – Divergence / Bull Trap: Z-Score high, but weak CVD
Cluster 0 – Neutral / Noise: No clear alignment
Anchored VWAP (NY Session Open): Confirms market structure and institutional trend bias from 9:30 AM ET forward.
🎯 Suggested Applications:
✅ 1. Trend Continuation Entries (Add-ons):
Look to add to positions when:
Cluster 2 signal occurs
Price is above the NY session VWAP
Price structure has broken out of prior day high/low or range
⚠️ 2. Divergence Detection (Fade Traps):
Cluster 1 signals a bearish divergence (e.g., high volume but weak CVD).
Especially useful when price is failing to stay above VWAP.
Useful for early exits or reversal setups.
📊 3. Volume Profile Confirmation:
Combine with fixed or session-based volume profile tools.
Use Z-Score clusters to confirm volume spikes into low-volume nodes (LVNs) or during imbalance transitions.
📍 4. VWAP Structure Confirmation:
Anchored VWAP acts as a dynamic reference point.
Helps confirm acceptance vs. rejection zones at key institutional levels.
📈 Visuals & Alerts:
Color-coded volume bars show intensity of Z-Score & CVD confluence
CVD Line plots real-time delta bias with green/red coloring
Cluster-based shape markers highlight key bars for actionable signals
Optional: Add alerts for Cluster 2 above VWAP or Cluster 1 below VWAP
⚙️ Customization Options:
Adjustable Z-Score length
Custom anchor timeframe for CVD (e.g., 1D or sessions)
Adjustable max lookback depth
Toggle VWAP inclusion
Extendable to include additional filters: RSI, structure break alerts, etc.
🔧 Ideal Use Cases:
NY session intraday traders (ES, NQ, CL, 6E, FX pairs)
Breakout traders wanting order flow confirmation
Mean reversion traders spotting fake moves
Volume-based scalpers looking for edge on short-term order imbalance
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
Liquidity Sweep Filter [AlgoAlpha]Unlock a deeper understanding of market liquidity with the Liquidity Sweep Filter by AlgoAlpha. This indicator identifies liquidity sweeps, highlighting key price levels where large liquidations have occurred. By visualizing major and minor liquidation events, traders can better anticipate potential reversals and market structure shifts, making this an essential tool for those trading in volatile conditions.
Key Features :
🔍 Liquidity Sweep Detection – Identifies and highlights areas where liquidity has been swept, distinguishing between major and minor liquidation events.
📊 Volume Profile Integration – Displays a volume profile overlay, helping traders spot high-activity price zones where the market is likely to react.
📈 Trend-Based Filtering – Utilizes an adaptive trend detection algorithm to refine liquidity sweeps based on market direction, reducing noise.
🎨 Customizable Visualization – Modify colors, thresholds, and display settings to tailor the indicator to your trading style.
🔔 Alerts for Liquidity Sweeps & Trend Changes – Stay ahead of the market by receiving alerts when significant liquidity events or trend shifts occur.
How to Use:
🛠 Add the Indicator : Add the Liquidity Sweep Filter to your chart and configure the settings based on your preferred sensitivity. Adjust the major sweep threshold to filter out smaller moves.
📊 Analyze Liquidity Zones and trend direction : Look for liquidation levels where large buy or sell stops have been triggered. Major sweeps indicate strong reactions, while minor sweeps show gradual liquidity absorption. You can also see which levels are high in liquidity by the transparency of the levels.
🔔 Set-Up Alerts : Use the in-built alerts so you don't miss a trading opportunity
How It Works :
The Liquidity Sweep Filter detects liquidity events by tracking swing highs and lows (defined as a pivot where neighboring candles are lower/higher than it) where traders are likely to have placed stop-loss orders. It evaluates volume and price action, marking areas where liquidity has been absorbed by the market. Additionally, the integrated trend filter ensures that only relevant liquidity sweeps are highlighted based on market direction, lows in an uptrend and highs in a downtrend. The trend filter works by calculating a basis, and defining trend shifts when the closing price crosses over the upper or lower bands.The included volume profile further enhances analysis by displaying key trading zones where price may react.
Range Detect SystemTechnical analysis indicator designed to identify potential significant price ranges and the distribution of volume within those ranges. The system helps traders calculate POC and show volume history. Also detecting breakouts or potential reversals. System identifies ranges with a high probability of price consolidation and helps screen out extreme price moves or ranges that do not meet certain volatility thresholds.
⭕️ Key Features
Range Detection — identifies price ranges where consolidation is occurring.
Volume Profile Calculation — indicator calculates the Point of Control (POC) based on volume distribution within the identified range, enhancing the analysis of market structure.
Volume History — shows where the largest volume was traded from the center of the range. If the volume is greater in the upper part of the range, the color will be green. If the volume is greater in the lower part, the color will be red.
Range Filtering — Includes multi-level filtering options to avoid ranges that are too volatile or outside normal ranges.
Visual Customization — Shows graphical indicators for potential bullish or bearish crossovers at the upper and lower range boundaries. Users can choose the style and color of the lines, making it easier to visualize ranges and important levels on the chart.
Alerts — system will notify you when a range has been created and also when the price leaves the range.
⭕️ How it works
Extremes (Pivot Points) are taken as a basis, after confirming the relevance of the extremes we take the upper and lower extremes and form a range. We check if it does not violate a number of rules and filters, perform volume calculations, and only then is the range displayed.
Pivot points is a built-in feature that shows an extremum if it has not been updated N bars to the left and N bars to the right. Therefore, there is a delay depending on the bars specified to check, which allows for a more accurate range. This approach allows not to make unnecessary recalculations, which completely eliminates the possibility of redrawing or range changes.
⭕️ Settings
Left Bars and Right Bars — Allows you to define the point that is the highest among the specified number of bars to the left and right of this point.
Range Logic — Select from which point to draw the range. Maximums only, Minimums only or both.
Use Wick — Option to consider the wick of the candles when identifying Range.
Breakout Confirmation — The number of bars required to confirm a breakout, after which the range will close.
Minimum Range Length — Sets the minimum number of candles needed for a range to be considered valid.
Row Size — Number of levels to calculate POC. *Larger values increase the script load.
% Range Filter — Dont Show Range is than more N% of Average Range.
Multi Filter — Allows use of Bollinger Bands, ATR, SMA, or Highest-Lowest range channels for filtering ranges based on volatility.
Range Hit — Shows graphical labels when price hits the upper or lower boundaries of the range, signaling potential reversal or breakout points.
Range Start — Show points where Range was created.
PRINT_TYPELibrary "PRINT_TYPE"
Inputs
Inputs objects
Fields:
inbalance_percent (series int) : percentage coefficient to determine the Imbalance of price levels
stacked_input (series int) : minimum number of consecutive Imbalance levels required to draw extended lines
show_summary_footprint (series bool)
procent_volume_area (series int) : definition size Value area
new_imbalance_cond (series bool) : bool input for setup alert on new imbalance buy and sell
new_imbalance_line_cond (series bool) : bool input for setup alert on new imbalance line buy and sell
stop_past_imbalance_line_cond (series bool) : bool input for setup alert on stop past imbalance line buy and sell
Constants
Constants all Constants objects
Fields:
imbalance_high_char (series string) : char for printing buy imbalance
imbalance_low_char (series string) : char for printing sell imbalance
color_title_sell (series color) : color for footprint sell
color_title_buy (series color) : color for footprint buy
color_line_sell (series color) : color for sell line
color_line_buy (series color) : color for buy line
color_title_none (series color) : color None
Calculation_data
Calculation_data data for calculating
Fields:
detail_open (array) : array open from calculation timeframe
detail_high (array) : array high from calculation timeframe
detail_low (array) : array low from calculation timeframe
detail_close (array) : array close from calculation timeframe
detail_vol (array) : array volume from calculation timeframe
previos_detail_close (array) : array close from calculation timeframe
isBuyVolume (series bool) : attribute previosly bar buy or sell
Footprint_row
Footprint_row objects one footprint row
Fields:
price (series float) : row price
buy_vol (series float) : buy volume
sell_vol (series float) : sell volume
imbalance_buy (series bool) : attribute buy inbalance
imbalance_sell (series bool) : attribute sell imbalance
buy_vol_box (series box) : for ptinting buy volume
sell_vol_box (series box) : for printing sell volume
buy_vp_box (series box) : for ptinting volume profile buy
sell_vp_box (series box) : for ptinting volume profile sell
row_line (series label) : for ptinting row price
empty (series bool) : = true attribute row with zero volume buy and zero volume sell
Imbalance_line_var_object
Imbalance_line_var_object var objects printing and calculation imbalance line
Fields:
cum_buy_line (array) : line array for saving all history buy imbalance line
cum_sell_line (array) : line array for saving all history sell imbalance line
Imbalance_line
Imbalance_line objects printing and calculation imbalance line
Fields:
buy_price_line (array) : float array for saving buy imbalance price level
sell_price_line (array) : float array for saving sell imbalance price level
var_imba_line (Imbalance_line_var_object) : var objects this type
Footprint_bar
Footprint_bar all objects one bar with footprint
Fields:
foot_rows (array) : objects one row footprint
imba_line (Imbalance_line) : objects imbalance line
row_size (series float) : size rows
total_vol (series float) : total volume one footprint bar
foot_buy_vol (series float) : buy volume one footprint bar
foot_sell_vol (series float) : sell volume one footprint bar
foot_max_price_vol (map) : map with one value - price row with max volume buy + sell
calc_data (Calculation_data) : objects with detail data from calculation resolution
Support_objects
Support_objects support object for footprint calculation
Fields:
consts (Constants) : all consts objects
inp (Inputs) : all input objects
bar_index_show_condition (series bool) : calculation bool value for show all objects footprint
row_line_color (series color) : calculation value - color for row price
dop_info (series string)
show_table_cond (series bool)
footprint_typeLibrary "footprint_type"
Contains all types for calculating and rendering footprints
Inputs
Inputs objects
Fields:
inbalance_percent (series int) : percentage coefficient to determine the Imbalance of price levels
stacked_input (series int) : minimum number of consecutive Imbalance levels required to draw extended lines
show_summary_footprint (series bool) : bool input for show summary footprint
procent_volume_area (series int) : definition size Value area
show_vah (series bool) : bool input for show VAH
show_poc (series bool) : bool input for show POC
show_val (series bool) : bool input for show VAL
color_vah (series color) : color VAH line
color_poc (series color) : color POC line
color_val (series color) : color VAL line
show_volume_profile (series bool)
new_imbalance_cond (series bool) : bool input for setup alert on new imbalance buy and sell
new_imbalance_line_cond (series bool) : bool input for setup alert on new imbalance line buy and sell
stop_past_imbalance_line_cond (series bool) : bool input for setup alert on stop past imbalance line buy and sell
Constants
Constants all Constants objects
Fields:
imbalance_high_char (series string) : char for printing buy imbalance
imbalance_low_char (series string) : char for printing sell imbalance
color_title_sell (series color) : color for footprint sell
color_title_buy (series color) : color for footprint buy
color_line_sell (series color) : color for sell line
color_line_buy (series color) : color for buy line
color_title_none (series color) : color None
Calculation_data
Calculation_data data for calculating
Fields:
detail_open (array) : array open from calculation timeframe
detail_high (array) : array high from calculation timeframe
detail_low (array) : array low from calculation timeframe
detail_close (array) : array close from calculation timeframe
detail_vol (array) : array volume from calculation timeframe
previos_detail_close (array) : array close from calculation timeframe
isBuyVolume (series bool) : attribute previosly bar buy or sell
Footprint_row
Footprint_row objects one footprint row
Fields:
price (series float) : row price
buy_vol (series float) : buy volume
sell_vol (series float) : sell volume
imbalance_buy (series bool) : attribute buy inbalance
imbalance_sell (series bool) : attribute sell imbalance
buy_vol_box (series box) : for ptinting buy volume
sell_vol_box (series box) : for printing sell volume
buy_vp_box (series box) : for ptinting volume profile buy
sell_vp_box (series box) : for ptinting volume profile sell
row_line (series label) : for ptinting row price
empty (series bool) : = true attribute row with zero volume buy and zero volume sell
Value_area
Value_area objects for calculating and printing Value area
Fields:
vah_price (series float) : VAH price
poc_price (series float) : POC price
val_price (series float) : VAL price
vah_label (series label) : label for VAH
poc_label (series label) : label for POC
val_label (series label) : label for VAL
vah_line (series line) : line for VAH
poc_level (series line) : line for POC
val_line (series line) : line for VAL
Imbalance_line_var_object
Imbalance_line_var_object var objects printing and calculation imbalance line
Fields:
cum_buy_line (array) : line array for saving all history buy imbalance line
cum_sell_line (array) : line array for saving all history sell imbalance line
Imbalance_line
Imbalance_line objects printing and calculation imbalance line
Fields:
buy_price_line (array) : float array for saving buy imbalance price level
sell_price_line (array) : float array for saving sell imbalance price level
var_imba_line (Imbalance_line_var_object) : var objects this type
Footprint_info_var_object
Footprint_info_var_object var objects for info printing
Fields:
cum_delta (series float) : var delta volume
cum_total (series float) : var total volume
cum_buy_vol (series float) : var buy volume
cum_sell_vol (series float) : var sell volume
cum_info (series table) : table for ptinting
Footprint_info
Footprint_info objects for info printing
Fields:
var_info (Footprint_info_var_object) : var objects this type
total (series label) : total volume
delta (series label) : delta volume
summary_label (series label) : label for ptinting
Footprint_bar
Footprint_bar all objects one bar with footprint
Fields:
foot_rows (array) : objects one row footprint
val_area (Value_area) : objects Value area
imba_line (Imbalance_line) : objects imbalance line
info (Footprint_info) : objects info - table,label and their variable
row_size (series float) : size rows
total_vol (series float) : total volume one footprint bar
foot_buy_vol (series float) : buy volume one footprint bar
foot_sell_vol (series float) : sell volume one footprint bar
foot_max_price_vol (map) : map with one value - price row with max volume buy + sell
calc_data (Calculation_data) : objects with detail data from calculation resolution
Support_objects
Support_objects support object for footprint calculation
Fields:
consts (Constants) : all consts objects
inp (Inputs) : all input objects
bar_index_show_condition (series bool) : calculation bool value for show all objects footprint
row_line_color (series color) : calculation value - color for row price
Volume Heatmap 2024 | NXT2017 Christmas EditionHi big players around the world,
I wish you a merry christmas time.
Today I have a nice present for you: a new volume heatmap indicator for free using!
HISTORY
My first volume heatmap project got a lot of feedback and a big demand. You can find it here:
In this time pinescript version 4 was the newest one and I worked the first time with arrays.
Today we have pinescript version 5 and some new features. This is why I tried again with matrix function and the results are better than I expected.
HOW IT WORKS
The indicator calculates similar like the volume profile. It looks back and every volume where the close price is on the same row area, the volume will cumulated. How much rows the new chart view is showing, you can choose manually.
The mind behind this is to find high volume levels, where high volume catch the price in a range or get function as support/resistance line.
PICTURES
I hope it helps for your trading. You are welcome to give some comments.
Merry christmas and best regards
NXT2017
Multi-Asset Performance [Spaghetti] - By LeviathanThis indicator visualizes the cumulative percentage changes or returns of 30 symbols over a given period and offers a unique set of tools and data analytics for deeper insight into the performance of different assets.
Multi Asset Performance indicator (also called “Spaghetti”) makes it easy to monitor the changes in Price, Open Interest, and On Balance Volume across multiple assets simultaneously, distinguish assets that are overperforming or underperforming, observe the relative strength of different assets or currencies, use it as a tool for identifying mean reversion opportunities and even for constructing pairs trading strategies, detect "risk-on" or "risk-off" periods, evaluate statistical relationships between assets through metrics like correlation and beta, construct hedging strategies, trade rotations and much more.
Start by selecting a time period (e.g., 1 DAY) to set the interval for when data is reset. This will provide insight into how price, open interest, and on-balance volume change over your chosen period. In the settings, asset selection is fully customizable, allowing you to create three groups of up to 30 tickers each. These tickers can be displayed in a variety of styles and colors. Additional script settings offer a range of options, including smoothing values with a Simple Moving Average (SMA), highlighting the top or bottom performers, plotting the group mean, applying heatmap/gradient coloring, generating a table with calculations like beta, correlation, and RSI, creating a profile to show asset distribution around the mean, and much more.
One of the most important script tools is the screener table, which can display:
🔸 Percentage Change (Represents the return or the percentage increase or decrease in Price/OI/OBV over the current selected period)
🔸 Beta (Represents the sensitivity or responsiveness of asset's returns to the returns of a benchmark/mean. A beta of 1 means the asset moves in tandem with the market. A beta greater than 1 indicates the asset is more volatile than the market, while a beta less than 1 indicates the asset is less volatile. For example, a beta of 1.5 means the asset typically moves 150% as much as the benchmark. If the benchmark goes up 1%, the asset is expected to go up 1.5%, and vice versa.)
🔸 Correlation (Describes the strength and direction of a linear relationship between the asset and the mean. Correlation coefficients range from -1 to +1. A correlation of +1 means that two variables are perfectly positively correlated; as one goes up, the other will go up in exact proportion. A correlation of -1 means they are perfectly negatively correlated; as one goes up, the other will go down in exact proportion. A correlation of 0 means that there is no linear relationship between the variables. For example, a correlation of 0.5 between Asset A and Asset B would suggest that when Asset A moves, Asset B tends to move in the same direction, but not perfectly in tandem.)
🔸 RSI (Measures the speed and change of price movements and is used to identify overbought or oversold conditions of each asset. The RSI ranges from 0 to 100 and is typically used with a time period of 14. Generally, an RSI above 70 indicates that an asset may be overbought, while RSI below 30 signals that an asset may be oversold.)
⚙️ Settings Overview:
◽️ Period
Periodic inputs (e.g. daily, monthly, etc.) determine when the values are reset to zero and begin accumulating again until the period is over. This visualizes the net change in the data over each period. The input "Visible Range" is auto-adjustable as it starts the accumulation at the leftmost bar on your chart, displaying the net change in your chart's visible range. There's also the "Timestamp" option, which allows you to select a specific point in time from where the values are accumulated. The timestamp anchor can be dragged to a desired bar via Tradingview's interactive option. Timestamp is particularly useful when looking for outperformers/underperformers after a market-wide move. The input positioned next to the period selection determines the timeframe on which the data is based. It's best to leave it at default (Chart Timeframe) unless you want to check the higher timeframe structure of the data.
◽️ Data
The first input in this section determines the data that will be displayed. You can choose between Price, OI, and OBV. The second input lets you select which one out of the three asset groups should be displayed. The symbols in the asset group can be modified in the bottom section of the indicator settings.
◽️ Appearance
You can choose to plot the data in the form of lines, circles, areas, and columns. The colors can be selected by choosing one of the six pre-prepared color palettes.
◽️ Labeling
This input allows you to show/hide the labels and select their appearance and size. You can choose between Label (colored pointed label), Label and Line (colored pointed label with a line that connects it to the plot), or Text Label (colored text).
◽️ Smoothing
If selected, this option will smooth the values using a Simple Moving Average (SMA) with a custom length. This is used to reduce noise and improve the visibility of plotted data.
◽️ Highlight
If selected, this option will highlight the top and bottom N (custom number) plots, while shading the others. This makes the symbols with extreme values stand out from the rest.
◽️ Group Mean
This input allows you to select the data that will be considered as the group mean. You can choose between Group Average (the average value of all assets in the group) or First Ticker (the value of the ticker that is positioned first on the group's list). The mean is then used in calculations such as correlation (as the second variable) and beta (as a benchmark). You can also choose to plot the mean by clicking on the checkbox.
◽️ Profile
If selected, the script will generate a vertical volume profile-like display with 10 zones/nodes, visualizing the distribution of assets below and above the mean. This makes it easy to see how many or what percentage of assets are outperforming or underperforming the mean.
◽️ Gradient
If selected, this option will color the plots with a gradient based on the proximity of the value to the upper extreme, zero, and lower extreme.
◽️ Table
This section includes several settings for the table's appearance and the data displayed in it. The "Reference Length" input determines the number of bars back that are used for calculating correlation and beta, while "RSI Length" determines the length used for calculating the Relative Strength Index. You can choose the data that should be displayed in the table by using the checkboxes.
◽️ Asset Groups
This section allows you to modify the symbols that have been selected to be a part of the 3 asset groups. If you want to change a symbol, you can simply click on the field and type the ticker of another one. You can also show/hide a specific asset by using the checkbox next to the field.
Liquidity PeaksThe "Liquidity Peaks" indicator is a tool designed to identify significant supply and demand zones based on volumetric analysis. It analyzes the volume profile within a specified lookback range to pinpoint the most volumetric point and draw corresponding zones on the price chart.
The 𝐋𝐢𝐪. 𝐏𝐞𝐚𝐤𝐬 indicator utilizes volume data to identify key supply and demand areas on the price chart. By examining the volume profile within a defined lookback range, it highlights three distinct zones: liquidity grab, volume containment, and the most volumetric point.
Zones and their meanings:
Liquidity grab (Orange box): This zone represents a price level where there is a significant swipe of the previous demand zone within the volume range. It indicates a potential shift in market sentiment and serves as a key supply or demand area.
Volume containment (Gray box): This zone displays the area of volume contained before the peak in volume. It provides insights into the range where buying or selling pressure was concentrated, highlighting potential support or resistance levels.
Most volumetric point (Light blue box): This zone represents the point within the lookback range that exhibits the highest volume. It signifies a significant area of market interest and indicates a potential supply or demand level.
Adjustable options:
Adjust liquidity Grab: This option allows you to adjust the size of the boxes. When enabled, the box size is set to twice the size of the high or low of the candle's wick. This adjustment enhances the visibility and accuracy of identifying swipes at specific price levels.
Show origin: Enabling this option ensures that the liquidity boxes are drawn from the wick they were created from. This provides a clear visual reference to the specific candle and highlights the liquidity levels associated with it.
Utility:
The 𝐋𝐢𝐪. 𝐏𝐞𝐚𝐤𝐬 indicator is a valuable tool for traders and investors seeking to identify significant supply and demand zones in the market. By analyzing volume data and drawing corresponding zones on the chart, it helps to pinpoint areas where buying or selling pressure is likely to emerge.
Traders can utilize this information to identify potential support and resistance levels, plan their entries and exits, and make more informed trading decisions. The liquidity grab zones can act as potential reversal or breakout points, while the volume containment zones and most volumetric points provide insights into areas of high market interest.
It is important to note that this indicator should be used in conjunction with other technical analysis tools and indicators to confirm trading signals and validate market dynamics.
Example Charts:
Tick Profile HeatmapThis is a market internal TICK heatmap with the intent of displaying areas of price associated to stronger reactions with NYSE TICK (by default).
This code is based off of a variation of a Volume Profile coded originally by colejustice who originally used code from LuxAlgo . The full-width volume bars that colejustice setup were replaced with full-width bars representative of TICK breaking +/- $500, the current cumulative value representing the "heat" is comprised of hlc3 by default but that can be changed. In a future update I may add additional logic here to capture highs and lows in the heatmap specifically, and perhaps additional colors.
As with other traditional profiling studies, this indicators purpose is to visualize correspondence to specific price levels, allowing rapid assessment where the most TICK activity is occurring, and where it hasn't been. This information may provide areas of support and resistance and regions where price may move quickly repeatedly.
All of the same input guidance that colejustice provided is the same for those pre-existing inputs:
Inputs are set up such that you can customize the lookback period, number of rows, and width of rows for most major timeframes individually. Timeframes between those available will use the next lower timeframe settings (e.g., 2m chart will use the 1m settings.)
Zero usage of volume is present in this indicator, only TICK data so please don't confuse it with volume studies.
Modified TradingView's Up/Down Volume [vnhilton]
When plotting columns, histograms, etc. You'll notice that the indicator does not stick to the bottom of the pane. To fix this, you need another indicator (we'll call this 'placeholder') in the same pane as this indicator. Pin the placeholder indicator to the left scale, & pin the main indicator to the left scale. Then, pin the placeholder indicator to scale A, & finally the main indictor to the right scale.
Note: On the daily timeframes & higher, the up/down volume isn't accurate. Therefore, I've added a feature where you can toggle on the main indicator to disappear & only show ordinary total volume similar to the TradingView volume indicator.
The original code belongs to TradingView. This is a modified indicator that displays the down volume above the up volume similar to the volume profile. Also includes a moving average using the total volume, & a feature to display ordinary volume to solve the up/down inaccuracies on the daily timeframe & higher.
Volume CompressorTurns volume into a more informative representation, ready to be further analyzed
...
Rationale
Volume
Back in the "before the quant" days I was a big fan of market & volume profile. Thing is J. Steidlmayer had lotta different ideas & works aside of profiling, it's just most of them ain't got to mainstream, one of them was "Hot / Cold volume" (yes, you can't really google it). From my interpretation, the idea was that in a given asset there is a usual constant volume that stays there no matter what, and if it ever changes it changes very slow and gradually; and there's another kind of, so to say, 'active' volume that actually influences price dynamics and very volatile by its nature. So I've met concept lately, and decided to quantify & model it one day when I'll have an idea how. That day was yesterday.
Compression
When we do music we always use different kinds of filters (low-pass, high pass, etc) for equalization and filtering itself. That stuff we use in finance as well. What we also always use in music are compressors, there dynamic processors that automatically adjust volume so it will be more consistent. Almost all the cool music you hear is compressed (both individual instruments (especially vocals) and the whole track afterwards), otherwise stuff will be too quite and too weak to flex on it, and also DJing it would be a nightmare. I am a big adept of loudness war. So I was like, how can I use compression in finance, when ima get an idea? That day was yesterday as well.
Volume structure
Being inspired by Steidlmayer's idea, I decided to distinguish volume this way:
1) Passive / static volume. The ~ volume that's always there no matter what (hedges, arbitrages, spread legs, portfolio parts etc etc), doesn't affect things;
2) Active / dynamic volume. The volume that flows from one asset to another, really matters and affects things;
3) Excess volume. The last portion of number 2 volume, that doesn't represent any powerful value to affect things.
Now it's clear that we can get rid of number 1 and number 3, the components that don't really matter, and concentrate on number 2 in order to improve information gain, both for ourselves and for the models we feed this data. How?
Model
I don't wanna explain it all in statistical / DSP way for once.
First of all, I think the population of volumes is log-normally distributed, so let's take logs of volumes, now we have a ~ normally distributed data. We take linearly weighted mean, add and subtract linearly weighted standard deviation from it, these would be our thresholds, the borders between different kinds of volumes explained before.
The upper threshold is for downward compression, that will not let volume pass it higher.
The lower threshold is for upward compression, all the volumes lower than this threshold will be brought up to the threshold's level.
Then we apply multipliers to the thresholds in order to adjust em and find the sweet spots. We do it the same way as in sound engineering when we don't aim for overcompression, we adjust the thresholds until they start to touch the signal and all good.
Afterwards, we delete all the number 1 and number 3 volume, leaving us exclusively with the clear main component, ready to be processed further.
We return the volumes to dem real scale.
About the parameters, based on testing I don't recommend changing the thresholds from dem default values, first of all they make sense statistically and second they work as intended.
Window length can and should be adjusted, find your own way, or leave the default value. ML (moving location) length is up to you as well.
So yeah, you can see now we can smooth the data and make it visually appealing not only by applying a smooth filter over it.
All good TV?
Volume Footprint [LuxAlgo]This indicator estimates a volume footprint using tick data. The script automatically separates a candle into equidistant intervals with a width obtained from the average true range or a user-given width.
Settings
Method: Interval width calculation method. This ultimately determines the number of intervals separating one candle.
Width (At the right of Method): Atr period or user given width depending on the selected method. A lower user-given width would divide a candle into a higher number of intervals.
As Percent: Returns the accumulated volume within each interval as a percentage of the total candle volume.
Style
Display Type: Determines the appearance of the returned volume footprint.
Trend Color: Color to use based on whether a candle is bullish or bearish.
Usage
When applied to a chart, the user will be asked to select the settings to use for the volume footprint. Note that changing the settings afterward will reset the volume footprint, removing previously generated footprints.
A new footprint will appear on the confirmation of a new bar, as such this version might only be useful in lower timeframes.
A volume footprint allows users to see the number of contracts exchanged within a candle interval. It can as such be seen as some kind of intrabar volume profile.
This can be useful to see areas of interest within a candle.
Different Appearance
By default, the volume footprint makes use of colored boxes with a color based on whether the candle was bullish or bearish.
Another appearance that gives additional information is the gradient type, which uses intervals color based on the number of contracts exchanged within an interval relative to the total volume of the candle. A higher number of contracts within an interval would return a darker color by default.
The regular display type makes use of boxes with a single color, with lines on the side indicating whether the candle was bullish or bearish.
Jitendra Volume Pro / Fixed RangeHello All,
This script calculates and shows Volume Profile for the fixed range. Recently we have box.new() feature in Pine Language and it's used in this script as an example. Thanks to Pine Team and Tradingview!..
Sell/Buy volumes are calculated approximately!.
Options:
"Number of Bars" : Number of the bars that volume profile will be calculated/shown
"Row Size" : Number of the Rows
"Value Area Volume %" : the percent for Value Area
and there are other options for coloring and POC line style
Enjoy!
Jitendra Sankpal
Bull Run Galaxy
2.11.2025
ProScalper📊 ProScalper - Professional 1-Minute Scalping System
🎯 Overview
ProScalper is a sophisticated, multi-confluence scalping indicator designed specifically for 1-minute chart trading. Combining advanced technical analysis with intelligent signal filtering, it provides high-probability trade setups with clear entry, stop loss, and take profit levels.
✨ Key Features
🔺 Smart Signal Detection
Range Filter Technology: Fast-responding trend detection (25-period) optimized for 1-minute timeframe
Medium-sized triangles appear above/below candles for clear buy/sell signals
Only most recent signal shown - no chart clutter
Automatically deletes old signals when new ones appear
📋 Real-Time Signal Table
Top-center display shows complete trade breakdown
Grade system: A+, A, B+, B, C+ ratings for every setup
All confluence reasons listed with checkmarks
Score and R:R displayed for instant trade quality assessment
Color-coded: Green for LONG, Red for SHORT
📐 Multi-Confluence Analysis
ProScalper combines 10+ technical factors:
✅ EMA Trend: 4 EMAs (200, 48, 13, 8) for multi-timeframe alignment
✅ VWAP: Dynamic support/resistance
✅ Fibonacci Retracement: Golden ratio (61.8%), 50%, 38.2%, 78.6%
✅ Range Filter: Adaptive trend confirmation
✅ Pivot Points: Smart reversal detection
✅ Volume Analysis: Spike detection and volume profile
✅ Higher Timeframe: 5-minute trend confirmation
✅ HTF Support/Resistance: Key levels from higher timeframes
✅ Liquidity Sweeps: Smart money detection
✅ Opening Range Breakout: First 15-minute range
💰 Complete Trade Management
Entry Lines: Dashed green (LONG) or red (SHORT) showing exact entry
Stop Loss: Red dashed line with price label
Take Profit: Blue dashed line with price label and R:R
Partial Exits: 1R level marked with orange dashed line
All lines extend 10 bars for clean alignment with Fibonacci levels
📊 Dynamic Risk/Reward
Adaptive R:R calculation based on market volatility
Targets adjusted for pivot distances
Minimum 1.2:1 to maximum 3.5:1 for scalping
Position sizing based on account risk percentage
🎨 Professional Visualization
Clean chart layout - no clutter, only essential information
Custom EMA colors: Red (200), Aqua (48), Green (13), White (8)
Gold VWAP line for key support/resistance
Color-coded Fibonacci: Bright yellow (61.8%), white (50%), orange (38.2%), fuchsia (78.6%)
No shaded zones - pure price action focus
📈 Performance Tracking
Real-time statistics table (optional)
Win rate, total trades, P&L tracking
Average R:R and win/loss ratios
Setup-specific performance metrics
⚙️ Settings & Customization
Risk Management
Adjustable account risk per trade (default: 0.5%)
ATR-based stop loss multiplier (default: 0.8 for tight scalping)
Dynamic position sizing
Signal Sensitivity
Confluence Score Threshold: 40-100 (default: 55 for balanced signals)
Range Filter Period: 25 bars (fast signals for 1-min)
Range Filter Multiplier: 2.2 (tighter bands for more signals)
Visual Controls
Toggle signal table on/off
Show/hide Fibonacci levels
Control EMA visibility
Adjust table text size
Partial Exits
1R: 50% (default)
2R: 30% (default)
3R: 20% (default)
Fully customizable percentages
Trailing Stops
ATR-Based (best for scalping)
Pivot-Based
EMA-Based
Breakeven trigger at 0.8R
🎯 Best Use Cases
Ideal For:
✅ 1-minute scalping on liquid instruments
✅ Day traders looking for quick 2-8 minute trades
✅ High-frequency trading with 8-15 signals per session
✅ Trending markets where Range Filter excels
✅ Crypto, Forex, Futures - works on all liquid assets
Trading Style:
Timeframe: 1-minute (can work on 3-5 min with adjusted settings)
Hold Time: 3-8 minutes average
Target: 1.2-3R per trade
Frequency: 8-15 signals per day
Win Rate: 45-55% (with proper risk management)
📋 How to Use
Step 1: Wait for Signal
Watch for green triangle (BUY) or red triangle (SELL)
Signal table appears at top center automatically
Step 2: Review Confluence
Check grade (prefer A+, A, B+ for best quality)
Review all reasons listed in table
Confirm score is above your threshold (55+ recommended)
Note the R:R ratio
Step 3: Enter Trade
Enter at current market price
Set stop loss at red dashed line
Set take profit at blue dashed line
Mark 1R level (orange line) for partial exit
Step 4: Manage Trade
Exit 50% at 1R (orange line)
Move to breakeven after 0.8R
Trail remaining position using your chosen method
Exit fully at TP or opposite signal
🎨 Chart Setup Recommendations
Optimal Display:
Timeframe: 1-minute
Chart Type: Candles or Heikin Ashi
Background: Dark theme for best color visibility
Volume: Enable volume bars below chart
Complementary Indicators (optional):
Order flow/Delta for institutional confirmation
Market profile for key levels
Economic calendar for news avoidance
⚠️ Important Notes
Risk Disclaimer:
Not financial advice - for educational purposes only
Always use proper risk management (0.5-1% per trade max)
Past performance doesn't guarantee future results
Test on demo account before live trading
Best Practices:
✅ Trade during high liquidity hours (9:30-11 AM, 2-4 PM EST)
✅ Avoid news events and market open/close (first/last 2 minutes)
✅ Use tight stops (0.8-1.0 ATR) for 1-minute scalping
✅ Take partial profits quickly (1R = 50% off)
✅ Respect max daily loss limits (3% recommended)
✅ Focus on A and B grade setups for consistency
What Makes This Different:
🎯 Complete system - not just signals, but full trade management
📊 Multi-confluence - 10+ factors analyzed per trade
🎨 Professional visualization - clean, focused chart design
⚡ Optimized for 1-min - settings specifically tuned for fast scalping
📋 Transparent reasoning - see exactly why each trade was taken
🏆 Grade system - instantly know trade quality
🔧 Technical Details
Pine Script Version: 5
Overlay: Yes (plots on price chart)
Max Lines: 500
Max Labels: 100
Non-repainting: All signals confirmed on bar close
Alerts: Compatible with TradingView alerts
📞 Support & Updates
This indicator is actively maintained and optimized for 1-minute scalping. Settings can be adjusted for different timeframes and trading styles, but default configuration is specifically tuned for high-frequency 1-minute scalping.
🚀 Get Started
Add ProScalper to your 1-minute chart
Adjust settings to your risk tolerance
Wait for signals (green/red triangles)
Follow the signal table guidance
Manage trades using provided levels
Track performance with stats table
Happy Scalping! 📊⚡💰
VPOC Harmonics - Liquidity-Weighted Price / Time RatiosVPOC Harmonics - Liquidity-Weighted Price / Time Ratios
Summary
This indicator transforms a swing’s price range, duration, and liquidity profile into a structured set of price-per-bar ratios. By anchoring two points and manually entering the swing’s VPOC (highest-volume price), it generates candidate compression values that unify price, time, and liquidity structure. These values can be applied to chart scaling, harmonic testing, and liquidity-aware market geometry.
________________________________________
Overview
Most swing analysis tools only consider price (ΔP) and time (N bars). This script goes further by incorporating the VPOC (Point of Control) — the price with the highest traded volume — directly into swing geometry.
• Anchors define the swing’s Low (L), High (H), and bar count (N).
• The user manually enters the VPOC (highest-volume price).
• The indicator then computes a suite of ratios that integrate range, duration, and liquidity placement.
The output is a table of liquidity-weighted price-per-bar candidates, designed for compression testing and harmonic analysis across swings and instruments.
________________________________________
How to Use
1. Select a Swing
- Place Anchor A and Anchor B to define the swing’s Low, High, and bar count.
2. Find the VPOC
- Apply TradingView’s Fixed Range Volume Profile tool over the same swing.
- Identify the Point of Control (POC) — the price level with the highest traded volume.
3. Enter the VPOC
- Manually input the POC into the indicator settings.
4. Review Outputs
- The table will display candidate ratios expressed mainly as price-per-bar values.
5. Apply in Practice
- Use the ratios as chart compression inputs or as benchmarks for testing harmonic alignments across swings.
________________________________________
Outputs
Swing & Inputs
• Bars (N): total bar count of the swing.
• Low (L): swing low price.
• High (H): swing high price.
• ΔP = H − L: price range.
• Mid = (L + H) ÷ 2: midpoint price.
• VPOC (V): user-entered highest-volume price.
• Base slope s0 = ΔP ÷ N: average change per bar.
• π-adjusted slope sπ = (π × ΔP) ÷ (2 × N): slope adjusted for half-cycle arc geometry.
________________________________________
VPOC Harmony Ratios (L, H, V, N)
• λ = (V − L) ÷ ΔP: normalized VPOC position within the range.
• R = (V − L) ÷ (H − V): symmetry ratio comparing lower vs. upper segment.
• s1 = (V − L) ÷ N: slope from Low → VPOC.
• s2 = (H − V) ÷ N: slope from VPOC → High.
________________________________________
Blended Means (s1, s2)
These combine the two segment slopes in different ways:
• HM(s1,s2) = 2 ÷ (1/s1 + 1/s2): Harmonic mean, emphasizes the smaller slope.
• GM(s1,s2) = sqrt(s1 × s2): Geometric mean, balances both slopes proportionally.
• RMS(s1,s2) = sqrt((s1² + s2²) ÷ 2): Root-mean-square, emphasizes the larger slope.
• L2 = sqrt(s1² + s2²): Euclidean norm, the vector length of both slopes combined.
________________________________________
Slope Blends
• Quadratic weighting: s_quad = s0 × ((V−L)² + (H−V)²) ÷ (ΔP²)
• Tilted slope: s_tilt = s0 × (0.5 + λ)
• Entropy-scaled slope: s_ent = s0 × H2(λ), with H2(λ) = −
________________________________________
Curvature & Liquidity Extensions
• π-arc × λ: s_arc = sπ × λ
• Liquidity-π: s_piV = sπ × (V ÷ Mid)
________________________________________
Scale-Normalized Families
With k = sqrt(H ÷ L):
• k (scale factor) = sqrt(H ÷ L)
• s_comp = s0 ÷ k: compressed slope candidate
• s_exp = s0 × k: expanded slope candidate
• Exponentiated blends:
- s_kλ = s0 × k^(2λ−1)
- s_φλ = s0 × φ^(2λ−1), with φ = golden ratio ≈ 1.618
- s_√2λ = s0 × (√2)^(2λ−1)
________________________________________
Practical Application
All formulas generate liquidity-weighted price-per-bar ratios that integrate range, time, and VPOC placement.
These values are designed for:
• Chart compression settings
• Testing harmonic alignments across swings
• Liquidity-aware scaling experiments
________________________________________
