QuantForge

Github Repos

Swing Profile [BigBeluga] – Structure-Aware Volume Profiling Per Swing

Swing Profile [BigBeluga] – Structure-Aware Volume Profiling Per Swing

Key takeaways

  1. Visualize exactly where volume accumulated during each swing leg, with isolated profiles anchored to market structure instead of arbitrary time windows
  2. Identify high-probability support and resistance zones using the Point of Control from completed swings, ready to feed into automated limit order strategies
  3. Monitor buying vs selling pressure per swing via delta percentage, useful as a trend quality filter before committing to breakout entries
  4. Run it locally with PineTS on Node.js for backtesting or real-time signal generation through the Binance data provider, no TradingView needed

Loading chart…

Indicator Credits : Author : BigBeluga

Volume profiles are everywhere, but most of them anchor to fixed time sessions, the New York open, the Asian session, or whatever range you manually drag onto the chart. BigBeluga’s Swing Profile takes a different approach: it builds a complete volume distribution for each individual swing leg, anchored precisely between confirmed swing highs and lows. Every bullish and bearish move gets its own isolated profile, its own Point of Control, and its own buy/sell delta breakdown.

I ran this on weekly BTCUSDC and the profiles immediately showed me something useful: where the actual volume piled up during each leg, not just where price went. Instead of guessing which session or time window matters, the indicator lets the market structure itself define the boundaries. It also rebuilds the current swing’s profile in real time, so you can watch for volume skew before a swing completes.

Running Swing Profile with PineTS

You can run this indicator locally on Node.js using PineTS. No TradingView subscription needed, just your own data provider. Here’s how to get it set up.

Installing PineTS

npm install pinets

Loading the Pine Script Indicator

PineTS compiles and executes Pine Script v6 natively in JavaScript. Point it at the raw .pine file and a data provider (Binance here), and it runs everything, all 400+ lines of drawing logic, volume binning, and real-time profile updates, locally on your machine.

Method 1: Batch Execution with pineTS.run()

The simplest approach. Load the script, run it against historical data, and get back all the computed plot values in one shot. Perfect for backtesting or one-off analysis.

// PineTS batch execution example template
import { PineTS, Provider } from 'pinets'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __dirname = dirname(fileURLToPath(import.meta.url))
const pineScript = readFileSync(join(__dirname, 'source.pine'), 'utf-8')

const pineTS = new PineTS(Provider.Binance, 'BTCUSDC', '1w', 500)
const ctx = await pineTS.run(pineScript)

console.log('Bars processed:', ctx.marketData.length)
console.log('Plots:', Object.keys(ctx.plots).join(', '))

for (const [name, plot] of Object.entries(ctx.plots)) {
  const lastPoint = plot.data?.[plot.data.length - 1]
  if (lastPoint) {
    console.log(`  ${name}: last value = ${lastPoint.value}`)
  }
}

This fetches 500 weekly candles from Binance, runs the full Swing Profile calculation, and dumps every plot’s last value. You’ll see the MA plot plus the internal drawing objects (labels, lines, boxes, polylines) that PineTS tracks behind the scenes.

Method 2: Live Streaming with pineTS.stream()

If you want the indicator to update as new candles come in (or as the current candle ticks), the streaming API is what you want. It fires a callback on every data update with the latest computed values.

// PineTS live streaming example template
import { PineTS, Provider } from 'pinets'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __dirname = dirname(fileURLToPath(import.meta.url))
const pineScript = readFileSync(join(__dirname, 'source.pine'), 'utf-8')

const pineTS = new PineTS(Provider.Binance, 'BTCUSDC', '1w', 500)

let count = 0
const stream = pineTS.stream(pineScript)

stream.on('data', (ctx) => {
  count++
  console.log(`[Update ${count}] Bars: ${ctx.marketData.length}, Plots: ${Object.keys(ctx.plots).length}`)

  for (const [name, plot] of Object.entries(ctx.plots)) {
    const lastPoint = plot.data?.[plot.data.length - 1]
    if (lastPoint) {
      console.log(`  ${name}: ${lastPoint.value}`)
    }
  }

  if (count >= 5) {
    console.log('Received 5 updates, stopping stream.')
    process.exit(0)
  }
})

stream.on('error', (err) => {
  console.error('Stream error:', err.message)
  process.exit(1)
})

For live trading, this is the one you want. The stream re-executes the indicator on every data update, so you get fresh swing detection and volume profiles as the market moves. Combine this with your own order logic and you’ve got swing-aware volume profiling running in your bot.

Indicator Properties

Inputs

General

InputTypeDefaultDescription
Swing Lengthint50Lookback period for detecting swing highs and lows (min: 10)
Swing Color UpcolorlimeColor for bullish swing legs
Swing Color DowncolororangeColor for bearish swing legs
Data SizestringSmallLabel size on chart (Tiny, Small, Normal, Large, Huge)

Swing Volume Profile

InputTypeDefaultDescription
ProfilebooltrueShow volume profile bars for each swing
HeatMapboolfalseFill the entire swing range with a volume heatmap gradient

ZigZag

InputTypeDefaultDescription
ZigZagbooltrueDraw zigzag lines connecting swing highs and lows
ZigZag StylestringDottedLine style for zigzag connector (Dotted, Dashed, Solid)

Point of Control

InputTypeDefaultDescription
PoCbooltrueHighlight the Point of Control (highest volume price level)
PoC Widthint2Line width for the PoC marker
PoC ColorcolorredColor of the Point of Control line

Moving Average

InputTypeDefaultDescription
TypestringNoneMA type (None, SMA, EMA, SMMA/RMA, WMA, VWMA)
Lengthint25Moving average period
SourcesourceclosePrice source for the MA calculation

Plots

Plot NameTypeDescription
MALine (yellow)Optional moving average overlay, only visible when MA Type is not “None”

Beyond the MA plot, the indicator generates extensive drawing objects (boxes, polylines, labels, lines) for the volume profiles, zigzag connectors, PoC markers, and data labels. All of these come through Pine Script’s drawing API rather than plot() calls.

Alerts

There are no built-in alerts here. If you want to fire on swing completions or PoC breaks, you’ll need to add your own alertcondition() calls to the Pine source, or just watch for direction flips in your Node.js code.

Understanding the Indicator

Swing Detection: Simple but Effective

Alright so here’s the deal. BigBeluga’s swing detection is dead simple, and that’s a good thing. It uses ta.highest(swingLen) and ta.lowest(swingLen) to track the rolling highest high and lowest low over the lookback window (default 50 bars). When the current high matches the rolling highest, the indicator flips to “down mode.” When the current low matches the rolling lowest, it flips to “up mode.”

A swing point is confirmed when the previous bar was the extreme and the current bar has broken away from it. So if yesterday’s high was the 50-bar highest and today’s high is lower, that swing high is locked in. Clean, no repainting on historical swings. The real-time profile for the current swing does update on every bar, which is by design.

ATR-Adaptive Volume Binning

The bin-sizing logic is the clever part. Instead of using a fixed number of bins or a fixed dollar width, the bin size adapts to volatility via ta.atr(200) * 0.5. On a quiet market, the bins are tighter, giving you higher resolution. On a volatile market, they widen to keep the profile readable. The number of bins is then calculated as the swing range divided by the bin size.

For each bin, the script loops through every bar in the swing leg and checks if candleClose falls within that bin’s range. If it does, the bar’s volume gets added to the bin. Green candles (close > open) go into the buy bucket, red candles go into sell. That gives you the buy/sell split and delta for each price level.

One thing I noticed: the volume assignment uses a proximity check (math.abs(binMidPrice - candleClose) < binStep) rather than a strict "close is between binLow and binHigh" check. This means a single candle can contribute volume to adjacent bins if it's near the boundary. It's a form of smoothing that makes the profiles look cleaner, though it does mean volume totals per bin aren't perfectly exclusive.

Real-Time vs. Historical Profiles

Rendering splits into two distinct paths. When a swing completes (direction flips), the profile is drawn once and locked in place as permanent chart objects. While a swing is still forming, the profile gets completely rebuilt on every bar update, with old boxes deleted and new ones created.

Smart move here: the real-time profile only runs on barstate.islast, so it doesn't waste computation on historical bars. The zigzag connector for the current swing renders as a dashed preview line, and the data label (showing total, buy, sell, and delta volumes) updates continuously. Once the swing locks, everything solidifies into the final colored version.

Using It for Algorithmic Signal Generation

If you're building anything that trades around volume structure, this indicator gives you a lot to work with.

The PoC (Point of Control) from completed swings is a natural support/resistance level. If price retraces back to a previous swing's PoC, that's a high-probability reaction zone because it's where the most volume traded during that move. Extract PoC levels from the plot data and set limit orders there.

Delta percentage adds another layer. It tells you whether buyers or sellers dominated a swing. A bullish swing with, say, +35% delta is healthy. A bullish swing with -5% delta? That's distribution disguised as a rally, and you should be suspicious. I'd treat delta as a trend quality filter, something to check before committing to a breakout entry, especially on pairs where volume data tends to be noisy.

Beyond individual metrics, the shape of the real-time profile compared to completed ones reveals a lot. Volume clustered at the bottom of the range suggests accumulation, a meaningfully different signal than volume piling up at the top, which points to distribution. Build a simple skew metric from the volume bins to quantify this.

For the PineTS streaming setup, I'd monitor the isDownMove direction flag. When it flips, a swing just completed. Grab the delta and PoC from the now-finalized swing, compare them to your signal thresholds, and fire your orders. The 50-bar default swing length means you'll get roughly one signal per major move on the weekly chart.

Performance Notes

Some practical limits worth knowing about. The indicator uses calc_bars_count = 2000 and max_bars_back = 5000, which means it processes a substantial history. With the default 50-bar swing length, you need at least 50 bars before the first swing can be detected, and the 200-bar ATR needs even more warmup data.

On the weekly timeframe, that's about 4 years of data before the ATR is fully warmed up. On daily, it's less than a year. I'd stick to 4H or above for reliable volume classification, because on lower timeframes the buy/sell split (based purely on candle color) gets noisy. A green 1-minute candle doesn't reliably indicate buying pressure the way a green weekly candle does.

Because the algorithm nests bar iteration inside bin iteration, computation scales with swing length. With the default swing length of 50 and typical bin counts around 10-20, you're looking at 500-1000 iterations per swing calculation. Not a problem on modern hardware, but if you crank the swing length to 200+ on a 1-minute chart, expect some latency.

Important Notes

PineTS handles this indicator without issues: v6 syntax, the custom SwingData struct, array operations, and all the drawing objects (boxes, polylines, lines, labels) come through clean. I tested it on weekly BTCUSDC with 500 bars and got clean output across all 5 plot keys. You will need a data provider that supplies volume data, though. Binance works well for crypto pairs, but for equities or forex, make sure your provider's volume figures are reliable. Thin-volume pairs will produce sparse, unreliable profiles.

The indicator's buy/sell volume classification is based on candle color (close vs. open), not on actual order flow or tick data. This is a common approximation in Pine Script and works reasonably well on higher timeframes, but don't confuse it with real order flow analysis from Level 2 data.

Disclaimer

QuantForge publishes technical material about indicators: what they do, how they are built, and how you can experiment with them in code and on charts. All of this is offered for education and illustration only. It is not financial, investment, or trading advice, and it should not be read as a recommendation to buy, sell, or hold any asset. Past or simulated performance does not guarantee future results. You are responsible for your own decisions; seek independent professional advice where appropriate.