Skip to main content

Volatility

Volatility indicators measure the degree of price variation in financial instruments. They help traders assess market uncertainty, risk levels, and potential breakout conditions. OpenAlgo provides a comprehensive collection of volatility indicators optimized for performance and accuracy.

Import Statement​

from openalgo import ta
from openalgo import api

# Initialize API client
client = api(api_key='your_api_key_here', host='http://127.0.0.1:5000')

# Get sample data
df = client.history(symbol="SBIN", exchange="NSE", interval="5m", 
                   start_date="2025-04-01", end_date="2025-04-08")

Available Volatility Indicators​

Average True Range (ATR)​

ATR measures market volatility by decomposing the entire range of an asset price for that period. It's one of the most widely used volatility indicators.

Usage​

atr_result = ta.atr(high, low, close, period=14)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • period (int, default=14): Number of periods for ATR calculation

Returns​

  • array: ATR values in the same format as input

Example​

# Calculate 14-period ATR
atr_14 = ta.atr(df['high'], df['low'], df['close'], period=14)
df['ATR_14'] = atr_14

# Calculate 21-period ATR
atr_21 = ta.atr(df['high'], df['low'], df['close'], period=21)
df['ATR_21'] = atr_21

print(df[['close', 'ATR_14', 'ATR_21']].tail())

Bollinger Bands​

Bollinger Bands consist of a middle band (SMA) and two outer bands that are standard deviations away from the middle band, used to identify overbought and oversold conditions.

Usage​

upper, middle, lower = ta.bbands(data, period=20, std_dev=2.0)

Parameters​

  • data (array-like): Price data (typically closing prices)
  • period (int, default=20): Number of periods for moving average and standard deviation
  • std_dev (float, default=2.0): Number of standard deviations for the bands

Returns​

  • tuple: (upper_band, middle_band, lower_band) arrays

Example​

# Calculate Bollinger Bands
bb_upper, bb_middle, bb_lower = ta.bbands(df['close'], period=20, std_dev=2.0)
df['BB_Upper'] = bb_upper
df['BB_Middle'] = bb_middle
df['BB_Lower'] = bb_lower

# Calculate tighter bands
bb_upper_tight, bb_middle_tight, bb_lower_tight = ta.bbands(df['close'], period=20, std_dev=1.5)
df['BB_Upper_Tight'] = bb_upper_tight
df['BB_Lower_Tight'] = bb_lower_tight

print(df[['close', 'BB_Upper', 'BB_Middle', 'BB_Lower']].tail())

Keltner Channel​

Keltner Channels are volatility-based envelopes set above and below an exponential moving average, using ATR to set channel distance.

Usage​

upper, middle, lower = ta.keltner(high, low, close, ema_period=20, atr_period=10, multiplier=2.0)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • ema_period (int, default=20): Period for the EMA calculation
  • atr_period (int, default=10): Period for the ATR calculation
  • multiplier (float, default=2.0): Multiplier for the ATR

Returns​

  • tuple: (upper_channel, middle_line, lower_channel) arrays

Example​

# Calculate Keltner Channel
kc_upper, kc_middle, kc_lower = ta.keltner(df['high'], df['low'], df['close'])
df['KC_Upper'] = kc_upper
df['KC_Middle'] = kc_middle
df['KC_Lower'] = kc_lower

# Custom parameters
kc_upper_custom, kc_middle_custom, kc_lower_custom = ta.keltner(
    df['high'], df['low'], df['close'], 
    ema_period=14, atr_period=14, multiplier=1.5
)

print(df[['close', 'KC_Upper', 'KC_Middle', 'KC_Lower']].tail())

Donchian Channel​

Donchian Channels are formed by taking the highest high and lowest low of the last n periods, providing dynamic support and resistance levels.

Usage​

upper, middle, lower = ta.donchian(high, low, period=20)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • period (int, default=20): Number of periods for the channel calculation

Returns​

  • tuple: (upper_channel, middle_line, lower_channel) arrays

Example​

# Calculate Donchian Channel
dc_upper, dc_middle, dc_lower = ta.donchian(df['high'], df['low'], period=20)
df['DC_Upper'] = dc_upper
df['DC_Middle'] = dc_middle
df['DC_Lower'] = dc_lower

# Different periods
dc_upper_10, dc_middle_10, dc_lower_10 = ta.donchian(df['high'], df['low'], period=10)
df['DC_Upper_10'] = dc_upper_10
df['DC_Lower_10'] = dc_lower_10

print(df[['high', 'low', 'DC_Upper', 'DC_Middle', 'DC_Lower']].tail())

Chaikin Volatility​

Chaikin Volatility measures the rate of change of the trading range, indicating periods of increasing or decreasing volatility.

Usage​

cv_result = ta.chaikin(high, low, ema_period=10, roc_period=10)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • ema_period (int, default=10): Period for EMA of high-low range
  • roc_period (int, default=10): Period for rate of change calculation

Returns​

  • array: Chaikin Volatility values

Example​

# Calculate Chaikin Volatility
cv = ta.chaikin(df['high'], df['low'])
df['Chaikin_Volatility'] = cv

# Custom parameters
cv_custom = ta.chaikin(df['high'], df['low'], ema_period=14, roc_period=14)
df['CV_Custom'] = cv_custom

print(df[['close', 'Chaikin_Volatility', 'CV_Custom']].tail())

Normalized Average True Range (NATR)​

NATR is ATR expressed as a percentage of closing price, making it useful for comparing volatility across different price levels.

Usage​

natr_result = ta.natr(high, low, close, period=14)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • period (int, default=14): Period for ATR calculation

Returns​

  • array: NATR values (percentage)

Example​

# Calculate NATR
natr = ta.natr(df['high'], df['low'], df['close'], period=14)
df['NATR'] = natr

# Different period
natr_21 = ta.natr(df['high'], df['low'], df['close'], period=21)
df['NATR_21'] = natr_21

print(df[['close', 'NATR', 'NATR_21']].tail())

Relative Volatility Index (RVI)​

RVI applies the RSI calculation to standard deviation instead of price changes, measuring volatility momentum.

Usage​

rvi_result = ta.rvi(data, stdev_period=10, rsi_period=14)

Parameters​

  • data (array-like): Price data (typically closing prices)
  • stdev_period (int, default=10): Period for standard deviation calculation
  • rsi_period (int, default=14): Period for RSI calculation

Returns​

  • array: RVI values (0-100 range)

Example​

# Calculate RVI
rvi = ta.rvi(df['close'])
df['RVI'] = rvi

# Custom parameters
rvi_custom = ta.rvi(df['close'], stdev_period=14, rsi_period=21)
df['RVI_Custom'] = rvi_custom

print(df[['close', 'RVI', 'RVI_Custom']].tail())

Ultimate Oscillator​

Ultimate Oscillator combines short, medium, and long-term price action into one oscillator, incorporating volatility analysis.

Usage​

uo_result = ta.ultimate_oscillator(high, low, close, period1=7, period2=14, period3=28)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • period1 (int, default=7): Short period
  • period2 (int, default=14): Medium period
  • period3 (int, default=28): Long period

Returns​

  • array: Ultimate Oscillator values (0-100 range)

Example​

# Calculate Ultimate Oscillator
uo = ta.ultimate_oscillator(df['high'], df['low'], df['close'])
df['Ultimate_Oscillator'] = uo

# Custom periods
uo_custom = ta.ultimate_oscillator(df['high'], df['low'], df['close'], 
                                  period1=5, period2=10, period3=20)
df['UO_Custom'] = uo_custom

print(df[['close', 'Ultimate_Oscillator', 'UO_Custom']].tail())

True Range​

True Range measures volatility that accounts for gaps between periods.

Usage​

tr_result = ta.true_range(high, low, close)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices

Returns​

  • array: True Range values

Example​

# Calculate True Range
tr = ta.true_range(df['high'], df['low'], df['close'])
df['True_Range'] = tr

print(df[['high', 'low', 'close', 'True_Range']].tail())

Mass Index​

Mass Index uses the high-low range to identify trend reversals based on range expansion.

Usage​

mass_result = ta.massindex(high, low, length=10)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • length (int, default=10): Period for sum calculation

Returns​

  • array: Mass Index values

Example​

# Calculate Mass Index
mass = ta.massindex(df['high'], df['low'])
df['Mass_Index'] = mass

# Different period
mass_14 = ta.massindex(df['high'], df['low'], length=14)
df['Mass_Index_14'] = mass_14

print(df[['close', 'Mass_Index', 'Mass_Index_14']].tail())

Bollinger Bands %B​

%B shows where price is in relation to the Bollinger Bands, with 1 indicating price at upper band and 0 at lower band.

Usage​

percent_b = ta.bbpercent(data, period=20, std_dev=2.0)

Parameters​

  • data (array-like): Price data (typically closing prices)
  • period (int, default=20): Period for moving average and standard deviation
  • std_dev (float, default=2.0): Number of standard deviations for the bands

Returns​

  • array: %B values

Example​

# Calculate Bollinger Bands %B
bb_percent = ta.bbpercent(df['close'])
df['BB_Percent_B'] = bb_percent

# Custom parameters
bb_percent_tight = ta.bbpercent(df['close'], period=14, std_dev=1.5)
df['BB_Percent_B_Tight'] = bb_percent_tight

print(df[['close', 'BB_Percent_B', 'BB_Percent_B_Tight']].tail())

Bollinger Bandwidth​

Bollinger Bandwidth measures the width of the Bollinger Bands, useful for identifying volatility squeezes.

Usage​

bandwidth = ta.bbwidth(data, period=20, std_dev=2.0)

Parameters​

  • data (array-like): Price data (typically closing prices)
  • period (int, default=20): Period for moving average and standard deviation
  • std_dev (float, default=2.0): Number of standard deviations for the bands

Returns​

  • array: Bandwidth values

Example​

# Calculate Bollinger Bandwidth
bb_width = ta.bbwidth(df['close'])
df['BB_Bandwidth'] = bb_width

# Different standard deviation
bb_width_tight = ta.bbwidth(df['close'], std_dev=1.5)
df['BB_Bandwidth_Tight'] = bb_width_tight

print(df[['close', 'BB_Bandwidth', 'BB_Bandwidth_Tight']].tail())

Chandelier Exit​

Chandelier Exit is a trailing stop-loss technique that follows price action using highest/lowest values and ATR.

Usage​

long_exit, short_exit = ta.chandelier_exit(high, low, close, period=22, multiplier=3.0)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • period (int, default=22): Period for highest/lowest and ATR calculation
  • multiplier (float, default=3.0): ATR multiplier

Returns​

  • tuple: (long_exit, short_exit) arrays

Example​

# Calculate Chandelier Exit
ce_long, ce_short = ta.chandelier_exit(df['high'], df['low'], df['close'])
df['CE_Long_Exit'] = ce_long
df['CE_Short_Exit'] = ce_short

# Custom parameters
ce_long_custom, ce_short_custom = ta.chandelier_exit(
    df['high'], df['low'], df['close'], period=14, multiplier=2.0
)
df['CE_Long_Custom'] = ce_long_custom
df['CE_Short_Custom'] = ce_short_custom

print(df[['close', 'CE_Long_Exit', 'CE_Short_Exit']].tail())

Historical Volatility​

Historical Volatility measures the standard deviation of logarithmic returns over a specified period.

Usage​

hv_result = ta.hv(close, length=10, annual=365, per=1)

Parameters​

  • close (array-like): Closing prices
  • length (int, default=10): Period for volatility calculation
  • annual (int, default=365): Annual periods for scaling
  • per (int, default=1): Timeframe periods (1 for daily/intraday, 7 for weekly+)

Returns​

  • array: Historical volatility values (annualized percentages)

Example​

# Calculate Historical Volatility
hv = ta.hv(df['close'], length=20)
df['Historical_Volatility'] = hv

# Different periods
hv_10 = ta.hv(df['close'], length=10)
hv_30 = ta.hv(df['close'], length=30)
df['HV_10'] = hv_10
df['HV_30'] = hv_30

print(df[['close', 'Historical_Volatility', 'HV_10', 'HV_30']].tail())

Ulcer Index​

Ulcer Index measures downside risk by calculating the depth and duration of drawdowns from recent highs.

Usage​

ui_result = ta.ulcerindex(data, length=14, smooth_length=14, signal_length=52, 
                         signal_type="SMA", return_signal=False)

Parameters​

  • data (array-like): Price data (typically closing prices)
  • length (int, default=14): Period for highest calculation
  • smooth_length (int, default=14): Period for smoothing squared drawdowns
  • signal_length (int, default=52): Period for signal line calculation
  • signal_type (str, default="SMA"): Signal smoothing type ("SMA" or "EMA")
  • return_signal (bool, default=False): Whether to return signal line

Returns​

  • array or tuple: Ulcer Index values (and signal if return_signal=True)

Example​

# Calculate Ulcer Index
ui = ta.ulcerindex(df['close'])
df['Ulcer_Index'] = ui

# With signal line
ui_with_signal, ui_signal = ta.ulcerindex(df['close'], return_signal=True)
df['UI_Signal'] = ui_signal

# Custom parameters
ui_custom = ta.ulcerindex(df['close'], length=21, smooth_length=21)
df['UI_Custom'] = ui_custom

print(df[['close', 'Ulcer_Index', 'UI_Signal', 'UI_Custom']].tail())

STARC Bands​

STARC Bands use a Simple Moving Average and Average True Range to create volatility-based bands.

Usage​

upper, middle, lower = ta.starc(high, low, close, ma_period=5, atr_period=15, multiplier=1.33)

Parameters​

  • high (array-like): High prices
  • low (array-like): Low prices
  • close (array-like): Closing prices
  • ma_period (int, default=5): Period for SMA calculation
  • atr_period (int, default=15): Period for ATR calculation
  • multiplier (float, default=1.33): ATR multiplier

Returns​

  • tuple: (upper_band, middle_line, lower_band) arrays

Example​

# Calculate STARC Bands
starc_upper, starc_middle, starc_lower = ta.starc(df['high'], df['low'], df['close'])
df['STARC_Upper'] = starc_upper
df['STARC_Middle'] = starc_middle
df['STARC_Lower'] = starc_lower

# Custom parameters
starc_upper_custom, starc_middle_custom, starc_lower_custom = ta.starc(
    df['high'], df['low'], df['close'], 
    ma_period=10, atr_period=20, multiplier=2.0
)

print(df[['close', 'STARC_Upper', 'STARC_Middle', 'STARC_Lower']].tail())

Complete Example: Volatility Analysis​

from openalgo import ta, api
import pandas as pd

# Initialize API and get data
client = api(api_key='your_api_key_here', host='http://127.0.0.1:5000')
df = client.history(symbol="SBIN", exchange="NSE", interval="5m", 
                   start_date="2025-04-01", end_date="2025-04-08")

# Calculate multiple volatility indicators
df['ATR'] = ta.atr(df['high'], df['low'], df['close'], period=14)
df['NATR'] = ta.natr(df['high'], df['low'], df['close'], period=14)

# Bollinger Bands
bb_upper, bb_middle, bb_lower = ta.bbands(df['close'], period=20, std_dev=2.0)
df['BB_Upper'] = bb_upper
df['BB_Middle'] = bb_middle
df['BB_Lower'] = bb_lower
df['BB_Width'] = ta.bbwidth(df['close'], period=20, std_dev=2.0)
df['BB_Percent_B'] = ta.bbpercent(df['close'], period=20, std_dev=2.0)

# Keltner Channel
kc_upper, kc_middle, kc_lower = ta.keltner(df['high'], df['low'], df['close'])
df['KC_Upper'] = kc_upper
df['KC_Middle'] = kc_middle
df['KC_Lower'] = kc_lower

# Donchian Channel
dc_upper, dc_middle, dc_lower = ta.donchian(df['high'], df['low'], period=20)
df['DC_Upper'] = dc_upper
df['DC_Middle'] = dc_middle
df['DC_Lower'] = dc_lower

# Advanced volatility indicators
df['RVI'] = ta.rvi(df['close'])
df['Historical_Vol'] = ta.hv(df['close'], length=20)
df['Ulcer_Index'] = ta.ulcerindex(df['close'])
df['Mass_Index'] = ta.massindex(df['high'], df['low'])

# Chandelier Exit levels
ce_long, ce_short = ta.chandelier_exit(df['high'], df['low'], df['close'])
df['CE_Long'] = ce_long
df['CE_Short'] = ce_short

# Volatility analysis
print("=== Volatility Analysis ===")
print(f"Average ATR: {df['ATR'].mean():.2f}")
print(f"Average NATR: {df['NATR'].mean():.2f}%")
print(f"Average Historical Volatility: {df['Historical_Vol'].mean():.2f}%")
print(f"Average BB Width: {df['BB_Width'].mean():.4f}")

# Recent values
print("\n=== Recent Volatility Indicators ===")
recent_data = df[['close', 'ATR', 'NATR', 'BB_Width', 'RVI', 'Historical_Vol']].tail()
print(recent_data)

# Volatility squeeze detection (BB Width < KC Width equivalent)
df['Squeeze'] = (df['BB_Upper'] - df['BB_Lower']) < (df['KC_Upper'] - df['KC_Lower'])
print(f"\nVolatility Squeeze periods: {df['Squeeze'].sum()} out of {len(df)} periods")

Common Use Cases​

  1. Volatility Breakouts: Use BB Width and Mass Index to identify low volatility periods before breakouts
  2. Risk Management: Use ATR and NATR for position sizing and stop-loss placement
  3. Overbought/Oversold: Use BB %B and RVI to identify extreme price levels
  4. Trend Strength: Higher volatility often accompanies strong trends
  5. Market Regime: Compare different volatility measures to understand market conditions

Performance Tips​

  1. Efficient Calculations: Use vectorized operations for multiple timeframes
  2. Memory Management: Calculate only needed indicators to save memory
  3. Parameter Optimization: Test different periods for your specific market and timeframe
  4. Combination Analysis: Use multiple volatility indicators together for confirmation