What Is an Implied Volatility Index? IV30 & VIX

An implied volatility index is one number that summarizes how much movement the options on a stock or index are pricing in over a fixed horizon, usually 30 days. The term covers two related things: a per-stock series such as IV30 or IVX, the figure a broker labels "IV" on a quote page, and the exchange-published family that begins with the VIX, the 30-day implied volatility index of the S&P 500. Both exist for the same reason: one option's implied volatility changes meaning every day as the contract ages, so a constant-maturity number is built from two expirations instead.

What does "implied volatility index" mean?

Implied volatility (IV) is the annualized volatility that, fed into an option-pricing model, reproduces an option's market price; the implied volatility calculation walks through the solving step. Every listed contract carries its own IV, and a liquid name like AAPL has thousands of them on any given day.

An IV index collapses that surface to one figure at a fixed maturity. The per-stock version (IV30, IV60, IV90, or a vendor label such as IVX) is what a quote page shows as "IV", and it is the raw series behind IV rank and IV percentile. The index-level version is a benchmark an exchange computes from an entire option chain and quotes like a price. The VIX is the best known, but every major equity index has one, and so does the Treasury market.

How is a per-stock IV index like IV30 built?

A constant-maturity IV starts from the term structure: the at-the-money IV of each listed expiration, laid out by time to expiry. At the money means strikes close to the current stock price, where an option's IV is least distorted by skew. The panel below takes every AAPL call and put struck within 2.5% of the closing price on June 15, 2026, keeps only contracts that traded that day with a converged IV solve, and averages the IV within each expiration.

SELECT
    toString(expiration_date)                                              AS expiry_date,
    concat(monthName(expiration_date), ' ', toString(toDayOfMonth(expiration_date))) AS expiry_label,
    concat(toString(days_to_expiry), ' days')                              AS time_to_expiry,
    round(avg(toFloat64(implied_volatility)) * 100, 2)                     AS atm_iv_pct,
    count()                                                                AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = '2026-06-15'
  AND iv_converged = 1
  AND volume > 0
  AND days_to_expiry BETWEEN 1 AND 120
  AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
GROUP BY expiration_date, days_to_expiry
HAVING contract_count >= 2
ORDER BY expiration_date

On that date 13 expirations qualified, from the June 17 contracts (2 days out) to September 18 (95 days out). Read the atm_iv_pct column top to bottom and you are reading AAPL's IV term structure. Nothing forces a row to sit at exactly 30 days, and on most days none does. The IV30 is manufactured from the two expirations that straddle the target: the last one at or under 30 days (the near leg) and the first one beyond it (the far leg).

The IV30 formula, worked on real numbers

The interpolation happens in variance-time rather than in volatility, and that detail is the whole method. Variance is volatility squared, and variance adds up over time, so the total variance an option prices in to expiry is IV² × D, with D the days to expiry. The IV30 is the volatility whose 30-day variance is a weighted blend of the two legs' variances:

IV30² × 30 = w × IV1² × D1 + (1 - w) × IV2² × D2, with w = (D2 - 30) / (D2 - D1)

IV1 and D1 are the near leg's IV and days to expiry; IV2 and D2 are the far leg's. The weight w tilts the answer toward whichever leg sits closer to 30 days. Swap 30 for 60 or 90 and the same formula yields IV60 and IV90. Here are AAPL's two legs for June 15, 2026, with the weight and the result computed in the same query:

SELECT
    leg,
    leg_expiry                                              AS expiry,
    leg_dte                                                 AS dte,
    round(leg_iv * 100, 2)                                  AS atm_iv_pct,
    leg_contracts                                           AS contract_count,
    round(leg_weight * 100, 1)                              AS weight_pct,
    round(sqrt((near_iv * near_iv * near_dte * (far_dte - 30)
              + far_iv * far_iv * far_dte * (30 - near_dte))
              / (far_dte - near_dte) / 30) * 100, 2)        AS iv30_pct
FROM
(
    SELECT
        maxIf(days_to_expiry, days_to_expiry <= 30)                     AS near_dte,
        minIf(days_to_expiry, days_to_expiry > 30)                      AS far_dte,
        argMaxIf(atm_iv, days_to_expiry, days_to_expiry <= 30)          AS near_iv,
        argMinIf(atm_iv, days_to_expiry, days_to_expiry > 30)           AS far_iv,
        argMaxIf(expiry_label, days_to_expiry, days_to_expiry <= 30)    AS near_expiry,
        argMinIf(expiry_label, days_to_expiry, days_to_expiry > 30)     AS far_expiry,
        argMaxIf(contracts, days_to_expiry, days_to_expiry <= 30)       AS near_contracts,
        argMinIf(contracts, days_to_expiry, days_to_expiry > 30)        AS far_contracts
    FROM
    (
        SELECT
            concat(monthName(expiration_date), ' ', toString(toDayOfMonth(expiration_date)), ', ', toString(toYear(expiration_date))) AS expiry_label,
            days_to_expiry,
            avg(toFloat64(implied_volatility))  AS atm_iv,
            count()                             AS contracts
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'AAPL'
          AND date = '2026-06-15'
          AND iv_converged = 1
          AND volume > 0
          AND days_to_expiry BETWEEN 7 AND 90
          AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
        GROUP BY expiration_date, days_to_expiry
        HAVING contracts >= 2
    )
)
ARRAY JOIN
    ['near', 'far']                                     AS leg,
    [near_expiry, far_expiry]                           AS leg_expiry,
    [near_dte, far_dte]                                 AS leg_dte,
    [near_iv, far_iv]                                   AS leg_iv,
    [near_contracts, far_contracts]                     AS leg_contracts,
    [(far_dte - 30) / (far_dte - near_dte),
     (30 - near_dte) / (far_dte - near_dte)]            AS leg_weight
ORDER BY leg_dte

The near leg expires July 10, 2026, 25 days out, with an at-the-money IV of 21.77% averaged over 6 contracts. The far leg expires July 17, 2026, 32 days out, at 21.85% over 6 contracts. The day counts hand the near leg 28.6% of the variance blend and the far leg 71.4%. Solve for IV30 and AAPL's 30-day implied volatility index that day comes out at 21.83%. The blend is a weighted average of two variances, so the result always lands between the two legs' IVs; a leg sitting exactly 30 days out would take 100% of the weight. Anyone holding per-contract IV can reproduce this with two averages and a square root.

What does an IV30 series look like over time?

Run the same recipe every session and you get the series a broker charts. The panel below rebuilds AAPL's IV30 daily from mid-June through the end of August 2026, next to the two legs it was blended from.

SELECT
    toString(date)                                              AS session_date,
    concat(monthName(date), ' ', toString(toDayOfMonth(date)), ', ', toString(toYear(date))) AS as_of_label,
    round(near_iv * 100, 2)                                     AS near_iv_pct,
    round(far_iv * 100, 2)                                      AS far_iv_pct,
    round(sqrt((near_iv * near_iv * near_dte * (far_dte - 30)
              + far_iv * far_iv * far_dte * (30 - near_dte))
              / (far_dte - near_dte) / 30) * 100, 2)            AS iv30_pct
FROM
(
    SELECT
        date,
        maxIf(days_to_expiry, days_to_expiry <= 30)             AS near_dte,
        minIf(days_to_expiry, days_to_expiry > 30)              AS far_dte,
        argMaxIf(atm_iv, days_to_expiry, days_to_expiry <= 30)  AS near_iv,
        argMinIf(atm_iv, days_to_expiry, days_to_expiry > 30)   AS far_iv
    FROM
    (
        SELECT
            date,
            days_to_expiry,
            avg(toFloat64(implied_volatility))  AS atm_iv,
            count()                             AS contracts
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'AAPL'
          AND date BETWEEN '2026-06-15' AND '2026-08-31'
          AND iv_converged = 1
          AND volume > 0
          AND days_to_expiry BETWEEN 7 AND 90
          AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
        GROUP BY date, days_to_expiry
        HAVING contracts >= 2
    )
    GROUP BY date
    HAVING countIf(days_to_expiry <= 30) > 0
       AND countIf(days_to_expiry > 30) > 0
)
ORDER BY date

Across 54 sessions the index read 21.83% on June 15, 2026 and 24.36% on August 31, 2026. Underneath, the legs swap identities every week: the contract that was the far leg becomes the near leg seven days later, and the weights reset. A single contract's IV is not comparable with itself across time, since it belongs to a shrinking horizon. The IV30 is, and that is the property every historical IV chart depends on.

Why is there an IV formula but no single IV calculator?

The formula is fixed. Its inputs are choices, and every vendor makes them a little differently. Which strikes count as at the money: the single nearest strike or a band around the price? Do calls and puts both count? Last trade or bid-ask midpoint? Do contracts that did not trade today count? Calendar days or trading days? Each choice moves the result by tenths of a percentage point on an ordinary day, and by more when an earnings date sits inside the window.

There is no universal calculator to type a ticker into. The calculator is the data pipeline: a full option chain with a per-contract IV on every row, plus the formula. The queries on this page are one such recipe written out in full. For the long history rather than one day, the guide to historical implied volatility data covers where series like this can be sourced.

What is an IV screener actually ranking?

An IV screener applies one recipe to every symbol and sorts. The figure being ranked is the constant-maturity IV, or a statistic derived from it such as IV rank. Here is the idea applied to six household names for the same June 15, 2026 session, using the AAPL recipe above:

SELECT
    underlying_symbol                                           AS symbol,
    round(sqrt((near_iv * near_iv * near_dte * (far_dte - 30)
              + far_iv * far_iv * far_dte * (30 - near_dte))
              / (far_dte - near_dte) / 30) * 100, 2)            AS iv30_pct,
    round(near_iv * 100, 2)                                     AS near_iv_pct,
    round(far_iv * 100, 2)                                      AS far_iv_pct
FROM
(
    SELECT
        underlying_symbol,
        maxIf(days_to_expiry, days_to_expiry <= 30)             AS near_dte,
        minIf(days_to_expiry, days_to_expiry > 30)              AS far_dte,
        argMaxIf(atm_iv, days_to_expiry, days_to_expiry <= 30)  AS near_iv,
        argMinIf(atm_iv, days_to_expiry, days_to_expiry > 30)   AS far_iv
    FROM
    (
        SELECT
            underlying_symbol,
            days_to_expiry,
            avg(toFloat64(implied_volatility))  AS atm_iv,
            count()                             AS contracts
        FROM global_markets.options_greeks
        WHERE underlying_symbol IN ('SPY', 'AAPL', 'MSFT', 'NVDA', 'AMZN', 'KO')
          AND date = '2026-06-15'
          AND iv_converged = 1
          AND volume > 0
          AND days_to_expiry BETWEEN 7 AND 90
          AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
        GROUP BY underlying_symbol, days_to_expiry
        HAVING contracts >= 2
    )
    GROUP BY underlying_symbol
    HAVING countIf(days_to_expiry <= 30) > 0
       AND countIf(days_to_expiry > 30) > 0
)
ORDER BY iv30_pct DESC

NVDA tops the list at 36.84% and SPY sits at the bottom at 13.59%. Read the ranking for what it is: the annualized movement each name's options were pricing over the following 30 days. A high figure is not "expensive" and a low one is not "cheap" without context; a hypothetical 20% would be routine for one stock and extreme for another. Scoring each name against its own history is the job of IV rank and IV percentile. Sorted on raw IV30, a screener lists the names with the most priced-in movement; sorted on IV rank, it lists the names pricing more movement than they usually do.

The VIX and its family of implied volatility indexes

The VIX is the S&P 500's 30-day implied volatility index. It uses the same two-expiration, variance-time interpolation, but instead of a handful of at-the-money contracts it takes the whole strip of out-of-the-money SPX puts and calls, weighted so the result approximates the fair price of a 30-day variance swap. That wide strike set is what separates an exchange volatility index from a broker's IV30. The VIX explainer covers the method step by step, and why VIX options don't track the VIX covers the most common misunderstanding about trading it. The same construction has been applied elsewhere:

• VIX: S&P 500 (SPX) options, 30-day horizon, published by Cboe.
• VIX1D, VIX9D, VIX3M, VIX6M: the SPX method at one-day, nine-day, three-month and six-month horizons; VIX1D is the one-day version.
• VXN: Nasdaq-100 (NDX) options. RVX: Russell 2000 (RUT) options. VXD: Dow Jones Industrial Average (DJX) options. All 30-day.
• VVIX: options on the VIX itself, so the implied volatility of volatility.
• OVX: options on the United States Oil Fund (USO). GVZ: options on SPDR Gold Shares (GLD). Both are ETF-based commodity volatility indexes.
• MOVE: the ICE BofA MOVE Index, built from one-month options on 2-, 5-, 10- and 30-year Treasuries and quoted in basis points of yield rather than percent, so it is never directly comparable with an equity volatility index.
• VSTOXX: EURO STOXX 50 options on Eurex, 30-day. VDAX-NEW: DAX options, 30-day.
• Nikkei Stock Average Volatility Index: Nikkei 225 futures and options on the Osaka Exchange, 30-day.
• HSI Volatility Index (VHSI): Hang Seng Index options, 30-day.
• India VIX: NIFTY 50 options on the NSE, 30-day, computed from bid-ask quotes rather than trades.

Each is a constant-maturity IV, so the IV30 recipe above is the right mental model for all of them. What differs is the underlying and the strike set.

FAQ

What is the difference between implied volatility and an implied volatility index?

Implied volatility belongs to one option contract: it is the volatility that reproduces that contract's market price. An implied volatility index is a constant-maturity summary of many contracts, such as a stock's IV30 or the VIX for the S&P 500, built so the number keeps the same meaning from one day to the next.

Is IV30 the same as the VIX?

They share the 30-day target and the variance-time interpolation between two expirations. The VIX is computed by Cboe from a wide strip of out-of-the-money S&P 500 index options; a stock's IV30 is computed by a broker or data vendor from near-the-money contracts. An IV30 built on SPY options is a close cousin of the VIX, not the VIX itself.

What does an implied volatility index reading of 30 mean?

As a hypothetical, a reading of 30 means the options in the calculation are priced as if the underlying's annualized volatility over the horizon will be 30%. Dividing by the square root of 12 converts that to roughly an 8.7% one-standard-deviation move over a month. It is a market price for movement, not a forecast that has to come true.

Why do brokers show different IV numbers for the same stock?

Each broker uses its own recipe for the constant-maturity blend: which strikes count as at the money, whether untraded contracts are included, which price is used and which expirations bracket the horizon. The formula is shared; the inputs are not, and the outputs differ by fractions of a point on most days.

Every panel above carries its exact SQL; expand one to see how the legs were picked and the weight applied. To rebuild an IV30 for a different ticker or date, ask the question in plain English on the Strasmore terminal.