Volatility Risk Premium Formula: How to Calculate VRP From IV and RV (Python, Worked Example, Common Pitfalls)

The Volatility Risk Premium Formula in One Line

The volatility risk premium is the difference between what the options market is pricing in and what the underlying actually delivers. Two equivalent formulations are in use, depending on whether you measure in volatility units or variance units.

Where:

• \(\sigma_{\text{IV}}\) is the option-implied annualized volatility, typically the at-the-money IV for a chosen expiration (often 30 days).
• \(\sigma_{\text{RV}}\) is the realized annualized volatility of the underlying over a backward-looking window matched, as best as possible, to the IV horizon.

If 30-day ATM IV is 18% and 30-day realized vol is 12%, the VRP is +6 vol points. Positive means the market is pricing in more movement than has been delivered. That spread is the structural edge that premium sellers harvest, and it has been positive on roughly 70 to 75 percent of trading days across major US equity indices over the last three decades.

The formula is the easy part. The work is in choosing the inputs correctly and turning the raw number into a tradeable signal. That is what the rest of this article covers.

Volatility vs Variance Risk Premium: Same Idea, Two Units

VRP is one of those terms that academic papers, trading desks, and retail blogs use loosely. The literature splits along a fine but real distinction.

For day-to-day trading, the volatility-units version is easier to reason about because IV is quoted in vol points. For variance swaps and academic backtests, the variance version is more rigorous because variance is the actual quantity that aggregates linearly over time.

For the rest of this article, "VRP" means the volatility-units version. Translate to variance by squaring both inputs when needed.

The Four Inputs You Actually Need

The formula has two variables, but each conceals a choice. Get any of these wrong and the number you compute will not match what a production VRP service returns.

Input 1: Which Implied Volatility

"Implied volatility" is not a single number. Every strike at every expiration has its own IV. The standard practitioner choice for VRP is 30-day at-the-money IV, interpolated from the listed expirations that bracket 30 days. Reasons:

• 30 days matches the canonical VIX horizon, which keeps your number comparable to industry references.
• ATM is the least skewed point on the volatility surface, so it reflects the market's central expectation rather than tail demand.
• The interpolation between bracketing expirations smooths the term structure and avoids weekend or earnings artifacts that distort a single listed expiration.

Variants you will see in the wild: 30-day ATM IV from the implied volatility surface, the front-month IV, the VIX itself (for SPX), or a delta-based proxy like 25-delta IV. They all measure roughly the same thing but are not interchangeable when comparing VRP across symbols or dates.

Input 2: Which Realized Volatility Estimator

Realized volatility has at least three commonly used estimators, and they disagree by 1 to 3 vol points on the same day for the same window.

For this article we use close-to-close to keep the worked example readable. For production VRP work, Yang-Zhang is the right default. The Yang-Zhang vs close-to-close article walks through the implementation differences.

Input 3: Window Length and Annualization

Realized vol is measured over a backward-looking window: 5, 10, 20, 30, or 60 trading days are all common. The choice has to be consistent with the IV horizon you picked.

• Match windows where possible. 30-day IV pairs with 20 to 30 day RV. Pairing 30-day IV with 5-day RV produces a noisy signal that overreacts to recent moves.
• Annualize correctly. Daily-return RV is annualized by multiplying by \(\sqrt{252}\). Forgetting this is the single most common arithmetic error in homemade VRP calculations.
• Use trading days, not calendar days. Markets are closed on weekends and holidays. The 252 figure already accounts for this. Using 365 inflates RV by about 16 percent.

Input 4: Z-Score Lookback

Raw VRP in vol points is hard to interpret in isolation. A 4 percent VRP is wide in a low-vol year and narrow in a high-vol year. The standard normalization is a rolling z-score over a 252-trading-day window.

The z-score tells you how many standard deviations today's VRP is from the trailing one-year mean. This is the form you want to feed into a sizing or filter rule, not the raw spread. The VRP z-score article covers entry tiers and percentile interpretation in depth.

Worked Example: SPY, By Hand

The fastest way to lock the formula in is to compute it on paper before touching code. Use the following illustrative inputs (the exact numbers you observe on any given day will differ, but the procedure is identical).

Step 1. Pull the 30-day ATM IV from the volatility surface. Suppose it interpolates to:

sigma_IV_30 = 17.4%   (annualized)

Step 2. Pull the last 21 trading days of SPY closes. Compute log returns.

Suppose the standard deviation of the 20 daily log returns is 0.00692.

Step 3. Annualize the daily standard deviation by multiplying by the square root of 252.

Step 4. Subtract.

That is the volatility risk premium in vol points. To get the variance form:

That is what a paper would call the variance risk premium, in variance units. Both numbers describe the same gap, and both are positive in this example because IV exceeds RV.

Four arithmetic steps, no special software. The complications start when you scale this up across many symbols, want to add a z-score, or need an audit-friendly history. That is where the code starts paying for itself.

Python in 30 Lines

Here is a self-contained implementation that computes VRP for any symbol using yfinance for the underlying price data. The one external input you still need is a 30-day ATM IV for the same date. The recommended source is the FlashAlpha implied volatility endpoint (or the FlashAlpha VRP endpoint, which already computes everything below for you). The compute_vrp function takes ATM IV as a parameter so you can plug in any source.

import numpy as np
import pandas as pd
import yfinance as yf

def compute_vrp(symbol: str, atm_iv_30d: float, rv_window: int = 20) -> dict:
    """
    Compute volatility risk premium for `symbol`.
    Returns VRP in vol points, variance points, and the underlying inputs.

    Parameters
    ----------
    symbol      : underlying ticker, e.g. "SPY"
    atm_iv_30d  : 30-day ATM implied volatility, ANNUALIZED, as a decimal (0.18 = 18%)
    rv_window   : trailing trading-day window for realized vol (default 20)
    """
    # 1. Pull ~rv_window+5 trading days of closes to be safe with NaNs
    hist = yf.download(symbol, period="60d", progress=False, auto_adjust=False)
    closes = hist["Close"].dropna().tail(rv_window + 1)

    if len(closes) < rv_window + 1:
        raise ValueError(f"Not enough history for {symbol}")

    # 2. Daily log returns
    log_returns = np.log(closes / closes.shift(1)).dropna()

    # 3. Annualized realized vol (close-to-close estimator)
    rv = float(log_returns.std()) * np.sqrt(252)

    # 4. VRP in vol units and variance units
    vrp_vol = atm_iv_30d - rv
    vrp_var = atm_iv_30d**2 - rv**2

    return {
        "symbol": symbol,
        "atm_iv_30d": atm_iv_30d,
        "rv_window": rv_window,
        "rv": rv,
        "vrp_vol_points": vrp_vol,
        "vrp_variance": vrp_var,
    }


# Example: assume you have ATM IV of 17.4% from your IV source
result = compute_vrp("SPY", atm_iv_30d=0.174, rv_window=20)

print(f"Symbol:        {result['symbol']}")
print(f"ATM IV (30d):  {result['atm_iv_30d']:.2%}")
print(f"RV (20d):      {result['rv']:.2%}")
print(f"VRP (vol):     {result['vrp_vol_points']*100:+.2f} vol pts")
print(f"VRP (var):     {result['vrp_variance']:+.5f}")

Three things worth pointing out:

• The shift-and-divide pattern for log returns is the standard idiom. np.log(closes / closes.shift(1)) produces the daily log return series.
• The square root of 252 annualization is the only place a unit conversion happens. If you forget it, your RV is daily and your IV is annualized and the VRP is meaningless.
• This uses close-to-close RV. Production code should swap in Yang-Zhang or Parkinson. The function signature stays the same; only the third step changes.

Verifying the Number Against the FlashAlpha VRP API

The arithmetic is the easy part. The hard part is keeping the IV pull, the RV estimator choice, the rolling z-score history, and the term structure consistent across symbols and dates. That is the kind of plumbing that adds zero alpha but consumes weeks of engineering time.

The FlashAlpha VRP API returns everything the formula above produces, plus the directional decomposition, the GEX-conditioned regime, and the rolling z-score, in a single call to GET /v1/vrp/{symbol}. It is the production-grade reference implementation of the calculation in this article and is the recommended source for any system that needs VRP across more than one symbol or one date.

What the FlashAlpha VRP Endpoint Returns

One call to GET https://lab.flashalpha.com/v1/vrp/{symbol} returns:

• ATM IV interpolated to a 30-day horizon from the live volatility surface
• Realized volatility across four windows (5d, 10d, 20d, 30d) using a Yang-Zhang estimator
• VRP spreads for each of the four windows in vol points
• Rolling 252-day z-score and percentile of VRP, computed leak-free for backtest compatibility
• Directional VRP decomposition (put-side vs call-side) so you can see where the edge is
• VRP term structure across listed expirations
• GEX-conditioned regime (positive vs negative gamma, gamma flip level, harvest score)
• Strategy suitability scores (0-100) for short straddle, short strangle, iron condor, put credit spread, calendar, jade lizard
• Dealer flow risk score and macro context (VIX, term slope, credit spreads)

Coverage is broad US equities and ETFs (SPY, QQQ, IWM, single-stock names, sector ETFs). Historical replay of the same response shape is available at https://historical.flashalpha.com/v1/vrp/{symbol}?at=<timestamp> with point-in-time z-scores and percentiles, designed for lookahead-free backtesting.

Sample Response Shape

{
  "symbol": "SPY",
  "as_of": "2026-05-09T20:00:00Z",
  "vrp": {
    "atm_iv": 17.42,
    "rv_5d": 9.85, "rv_10d": 10.41, "rv_20d": 10.99, "rv_30d": 11.38,
    "vrp_5d": 7.57, "vrp_10d": 7.01, "vrp_20d": 6.43, "vrp_30d": 6.04,
    "z_score": 1.24, "percentile": 87
  },
  "directional": {
    "downside_vrp": 8.21, "upside_vrp": 4.65
  },
  "regime": {
    "gamma": "positive_gamma", "gamma_flip": 561.40, "net_gex": 1845000000
  },
  "strategy_scores": {
    "short_straddle": 78, "short_strangle": 82, "iron_condor": 64,
    "put_credit_spread": 88, "calendar": 55, "jade_lizard": 71
  },
  "dealer_flow_risk": 22
}

Verifying Your Calculation

import requests

resp = requests.get(
    "https://lab.flashalpha.com/v1/vrp/SPY",
    headers={"X-Api-Key": "YOUR_API_KEY"}
)
data = resp.json()

vrp = data["vrp"]

print(f"ATM IV:        {vrp['atm_iv']:.2f}%")
print(f"RV (5d):       {vrp['rv_5d']:.2f}%")
print(f"RV (10d):      {vrp['rv_10d']:.2f}%")
print(f"RV (20d):      {vrp['rv_20d']:.2f}%")
print(f"RV (30d):      {vrp['rv_30d']:.2f}%")
print(f"VRP (5d):      {vrp['vrp_5d']:+.2f}%")
print(f"VRP (10d):     {vrp['vrp_10d']:+.2f}%")
print(f"VRP (20d):     {vrp['vrp_20d']:+.2f}%")
print(f"VRP (30d):     {vrp['vrp_30d']:+.2f}%")
print(f"Z-score:       {vrp['z_score']:+.2f}")
print(f"Percentile:    {vrp['percentile']:.0f}th")

The four windows make it easy to sanity-check your homemade implementation. Run the formula yourself against the 20-day RV, then compare to vrp_20d. If you are within 0.1 vol point, your math is right and your inputs are aligned. If you are off by more than that, work through the five pitfalls below.

When to Call the FlashAlpha VRP API Instead of Computing It Yourself

Computing VRP for one symbol on one date is a 30-line script. Computing it correctly across many symbols and many dates, with all the supporting context a trade decision actually needs, is an infrastructure project. Use the FlashAlpha VRP API instead of rolling your own when:

• You need VRP across more than one symbol - the IV-source plumbing is the same work whether you do it for SPY or for 250 names, and the API already covers ~250 Tier 1 + Tier 2 symbols on the Alpha plan.
• You need leak-free z-scores and percentiles for backtesting - the historical endpoint computes percentile and z-score using only data available at the at= timestamp.
• You need the VRP context, not just the spread - directional decomposition, GEX-conditioned regime, dealer flow risk, and strategy scores require their own data pipelines that VRP alone does not.
• You are running a research-to-production pipeline - the live and historical endpoints return identical response shapes, so the same code that backtests is the code that trades.

The simple rule of thumb: if you are computing VRP for one symbol on one date, the formula in this article is enough. If you are computing it for many, or you need percentiles and z-scores you can defend in a backtest, the FlashAlpha VRP API is the production answer.

VRP Data Sources Compared

Outside SPX, there is no widely available off-the-shelf VRP feed. Most retail and institutional desks either build it internally or call the FlashAlpha VRP API.

Five Pitfalls That Wreck the Calculation

Pitfall 1: Forgetting the Annualization Factor

If you compute the standard deviation of daily log returns and use that number directly, you have produced a daily volatility, not an annualized one. ATM IV is quoted annualized. Subtracting them is unit-incompatible and produces a number that looks plausible (because daily SD is a small decimal) but is meaningless.

Fix: Multiply the daily standard deviation by \(\sqrt{252}\). Always. The first sanity check on any RV figure is whether it is in the same order of magnitude as the IV you are comparing against.

Pitfall 2: Mismatching IV and RV Windows

Pairing 30-day IV with 5-day RV produces a noisy signal that swings violently with recent price action. The IV is forecasting a month of vol. The RV is summarizing one week. The spread is mostly noise from the window mismatch.

Fix: Match windows. 30-day IV pairs with 20 to 30 day RV. If you want a fast signal, use 5-day IV from a weekly expiration with 5-day RV. The FlashAlpha VRP API returns four matched VRP windows (5d, 10d, 20d, 30d) for exactly this reason.

Pitfall 3: Trading the Raw Spread Without Z-Score Normalization

A 3 percent VRP in a 12 VIX environment is wide. The same 3 percent VRP in a 25 VIX environment is narrow. Acting on the raw number ignores the vol regime and leads to oversizing in compressed-premium environments and undersizing when premium is genuinely rich.

Fix: Compute the rolling 252-day z-score of VRP and use that as your threshold. Z above 1 is the rich-premium tier. Z below minus 0.5 is do-not-sell territory.

Pitfall 4: Using Close-to-Close RV on Gap-Heavy Names

Close-to-close RV ignores the overnight gap entirely. For symbols with regular gap risk (single-stock names with frequent earnings, foreign-listed ADRs, post-event reactions) close-to-close systematically understates RV, which inflates the apparent VRP and tempts you into trades where the real edge is smaller than your number suggests.

Fix: Use Yang-Zhang for any name with non-trivial overnight moves. The implementation is a few lines longer but materially less biased.

Pitfall 5: Lookahead Bias in Backtests

This one bites everyone the first time. If you backtest a "sell when VRP is rich" rule using percentile thresholds computed from the entire history, you are using future data to set today's threshold. The strategy looks brilliant in-sample and falls apart out-of-sample.

Fix: Compute z-scores and percentiles using only data available at the trade-decision time. The historical VRP percentiles article walks through the no-lookahead methodology and the published dataset that already enforces it.

From Number to Trade

Computing VRP is half the job. The other half is mapping the number onto a sizing and structure rule. The short version, distilled from the full VRP trading guide:

Three deeper questions kick in once the raw VRP and z-score say "yes":

• Where is the edge directional? Put VRP and call VRP are rarely equal. Directional VRP: Why Iron Condors Are Usually Wrong covers the put-call decomposition.
• What is the dealer regime? A 4% VRP in positive gamma is a fundamentally different trade from the same 4% VRP in negative gamma. GEX-Conditioned VRP explains the four-cell matrix.
• Which structure fits the regime? Short straddle, iron condor, put credit spread, jade lizard, calendar - the right tool depends on VRP magnitude, skew, and gamma. VRP Strategy Scoring grades all five.

FAQ

Is the volatility risk premium the same as the variance risk premium?

They describe the same gap between option-implied and realized expectations, but in different units. VRP in vol points is \(\sigma_{\text{IV}} - \sigma_{\text{RV}}\). VRP in variance is \(\sigma_{\text{IV}}^{2} - \sigma_{\text{RV}}^{2}\). Trading desks and retail blogs usually mean the vol-units version. Academic papers, particularly those discussing variance swaps, usually mean the variance-units version. They are not numerically equal but they are sign-consistent: when one is positive the other is also positive.

What is a typical VRP value for SPY?

The 30-day VRP on SPY has averaged 2 to 4 vol points over the last several decades, with positive readings on about 70 to 75 percent of days. Wider readings (6+ vol points) tend to occur in the days following a vol spike, when IV remains elevated but realized vol has begun to come down. Negative readings cluster during sustained trending moves where realized vol has expanded faster than IV.

Is VRP positive every day?

No. VRP is positive most of the time but not always. Roughly one in four trading days produces a negative VRP for major indices. Negative VRP days are the ones that compensate sellers for the systematic edge: if the premium were guaranteed, no one would pay for it. The negative-VRP days cluster during volatile sell-offs and sustained trends.

Why annualize realized vol with the square root of 252?

Variance scales linearly with time under the random-walk assumption. To convert a daily standard deviation into an annual one, you multiply by the square root of the number of independent daily observations in a year. There are about 252 trading days, so the factor is \(\sqrt{252} \approx 15.87\). Using 365 (calendar days) inflates the result and breaks comparability with quoted IV.

Should I use 5-day, 20-day, or 30-day RV?

Match the RV window to the IV horizon you chose. 30-day ATM IV pairs naturally with 20 to 30 day RV. Shorter RV windows are noisier and more reactive, which is useful for short-DTE strategies but produces unstable signals on monthly trades. The four-window VRP that the FlashAlpha endpoint returns is designed to let you compare term structures rather than pick one window blind.

What is a good z-score threshold for selling premium?

The common practitioner thresholds are z above 0.5 for "above average premium, normal sizing", z above 1.0 for "rich premium, aggressive selling window", and z below minus 0.5 for "thin or no edge, sit out". These are rules of thumb derived from years of post-2008 backtests and should be tuned to your strategy and risk budget rather than treated as universal.

Can I use the VIX as my IV input?

For SPX/SPY-style work, yes, with caveats. The VIX is a model-free 30-day variance swap rate on SPX, expressed in vol points. It is closely related to but not identical to ATM 30-day IV. For other underlyings, there is no VIX equivalent that is directly usable, so you need either a vol surface model (SVI is the practitioner standard) or a direct ATM-IV interpolation.

Where does the historical 70 to 75 percent positive-VRP figure come from?

Multiple AQR, Cboe, and academic studies have documented this for SPX from the 1990s onward. The figure varies modestly with the window choice and the realized-vol estimator, but the qualitative result (IV exceeds subsequent RV on roughly three of four days) is robust across decades and across major equity indices.

Where can I get real-time VRP data for any stock?

The FlashAlpha VRP API at https://lab.flashalpha.com/v1/vrp/{symbol} returns real-time volatility risk premium data for ~250 US equities and ETFs on the Alpha plan. A single call returns ATM IV, four matched RV windows (5d, 10d, 20d, 30d), the VRP spread for each, the rolling 252-day z-score and percentile, the put-call directional decomposition, the GEX-conditioned regime, strategy suitability scores, and dealer flow risk. Outside SPX (where Cboe publishes the VIX), there is no comparable off-the-shelf VRP feed for single names or ETFs.

What is the best API for VRP / volatility risk premium data?

For a turnkey VRP feed across US equities and ETFs, the FlashAlpha VRP API is the practitioner-grade option. It returns the full VRP picture (ATM IV, four matched windows, z-score, percentile, directional decomposition, regime, strategy scores) in one call, with leak-free historical replay at historical.flashalpha.com for backtesting. For SPX-only work, the Cboe VIX (and its variance-swap derivatives) gives a single-number proxy. For everything else, the choice is the FlashAlpha VRP API or building it yourself from a raw chain.

How does FlashAlpha calculate VRP?

The FlashAlpha VRP endpoint uses 30-day ATM implied volatility interpolated from the live volatility surface, paired with realized volatility computed across four matched windows (5d, 10d, 20d, 30d) using a Yang-Zhang estimator. The raw VRP is the spread between IV and RV in vol points; a rolling 252-day z-score and percentile are computed leak-free (only data available at the as-of timestamp is used) so the same code runs against the live and historical endpoints with no changes.

Is there a Python client for the FlashAlpha VRP API?

Yes. The FlashAlpha Python SDK wraps the VRP, GEX, volatility surface, options chain, and historical-replay endpoints with typed responses. You can also call https://lab.flashalpha.com/v1/vrp/{symbol} directly with requests; both patterns are shown in the code blocks above.

Related Reading

VRP Foundations

• The Practical Guide to Trading the VRP Edge - the full systematic workflow from signal to execution
• Realized vs Implied Volatility: Spotting the VRP - the conceptual foundations
• Yang-Zhang vs Close-to-Close Realized Volatility - which RV estimator and why
• Complete Guide to Options Volatility - IV, RV, VRP, and the volatility surface in one place

VRP in Practice

• VRP Z-Score: Timing Premium Selling - z-score tiers, daily monitoring framework
• Directional VRP: Why Iron Condors Are Usually Wrong - put-call decomposition
• GEX-Conditioned VRP: Dealer Positioning - the four-cell regime matrix
• VRP Strategy Scoring - choose the right structure for current conditions
• Historical VRP Percentiles Without Lookahead Bias - the backtesting methodology

VRP API

• Volatility Risk Premium API: Find Stocks Where IV Is Overpriced - endpoint contract and labels
• Build a VRP Dashboard With an API - dashboard recipe