Where to Get Historical Implied Volatility Data

Historical implied volatility data is derived, not recorded, and that one fact explains why it is harder to source than a price history. IV is the number you get by running an option's market price backwards through a pricing model until the model's value matches the price on the screen. No exchange prints it on a tape, so every published IV history carries choices about model, quote, contract selection and interpolation, and those choices are the whole difference between two series that claim to measure the same thing.

If you want the definition first, what implied volatility is and how implied volatility is calculated cover the mechanics. What follows is where the history lives and how to tell two versions of it apart.

Why is historical implied volatility data harder to get than price data?

A daily close is observed: it printed, and every vendor reports the same number. An IV level is computed, and four inputs to that computation vary from source to source.

• The model: a European Black-Scholes solve, an American binomial tree with discrete dividends, or a vendor variant carrying its own rate and borrow assumptions.
• The price fed in: the bid, the ask, the mid, the last trade, or an exchange settlement price.
• Which contracts count: one at-the-money strike, a moneyness band, a volume or open-interest filter.
• How the number reaches a fixed maturity: interpolating between the two expiries that straddle 30 days, or averaging everything inside a days-to-expiry window.

Change one input and the level shifts. Change all four and two careful sources land several volatility points apart on the same session, with neither of them wrong.

The dispersion starts inside a single name. The panel below takes AAPL across June 2026, keeps only contracts struck within 5% of the spot price, and splits them by time left to expiry.

SELECT
    dte_band,
    round(100 * quantileDeterministic(0.25)(iv, contract_hash), 1) AS iv_p25_pct,
    round(100 * quantileDeterministic(0.50)(iv, contract_hash), 1) AS iv_median_pct,
    round(100 * quantileDeterministic(0.75)(iv, contract_hash), 1) AS iv_p75_pct,
    count()                                                        AS contract_day_count
FROM
(
    SELECT
        multiIf(days_to_expiry <=   7, '01-07d',
                days_to_expiry <=  21, '08-21d',
                days_to_expiry <=  45, '22-45d',
                days_to_expiry <=  90, '46-90d',
                days_to_expiry <= 180, '91-180d',
                                       '181d+')  AS dte_band,
        toFloat64(implied_volatility)             AS iv,
        cityHash64(ticker)                        AS contract_hash,
        days_to_expiry                            AS dte
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date >= '2026-06-01'
      AND date <  '2026-07-01'
      AND iv_converged = 1
      AND volume > 0
      AND days_to_expiry > 0
      AND underlying_close > 0
      AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
)
GROUP BY dte_band
ORDER BY min(dte)

Same underlying, same month, near-the-money strikes only. The shortest band in view, 01-07d, carried a median IV of 29.6%. The longest, 181d+, sat at 28.1%. Inside that first band alone the 25th and 75th percentiles ran 24.9% and 35.8%. The shape across expiries is the term structure, and its cousin across strikes is volatility skew. There is no single IV here. There is a surface, and any published AAPL IV figure is one summary of it, which is what our AAPL implied volatility page tracks.

Why do two 30-day IV charts show different numbers?

Take one liquid underlying, one year of sessions, and build a 30-day IV three ways from the same rows. The first column keeps strikes within 1% of spot and expiries of 25 to 35 days, the tightest reading available. The second widens to 5% of spot and 20 to 45 days, the practical default when every session has to be populated. The third weights that wider set by contract volume, pulling the average toward the strikes that actually traded.

WITH
    near_money AS
    (
        SELECT
            toMonday(date)                                                 AS week_start,
            toFloat64(implied_volatility)                                  AS iv,
            days_to_expiry                                                 AS dte,
            volume                                                         AS vol,
            abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS moneyness
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'SPY'
          AND date >= '2025-08-01'
          AND date <  '2026-08-01'
          AND iv_converged = 1
          AND volume > 0
          AND underlying_close > 0
          AND days_to_expiry BETWEEN 20 AND 45
          AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
    ),
    weekly AS
    (
        SELECT
            week_start,
            avgIf(iv, dte BETWEEN 25 AND 35 AND moneyness < 0.01) AS tight_atm,
            avg(iv)                                               AS wide_atm,
            sum(iv * vol) / sum(vol)                              AS volume_weighted
        FROM near_money
        GROUP BY week_start
        HAVING countIf(dte BETWEEN 25 AND 35 AND moneyness < 0.01) > 0
    )
SELECT
    toString(week_start) AS week,
    concat(monthName(week_start), ' ', toString(toDayOfMonth(week_start)), ', ', toString(toYear(week_start))) AS week_label,
    round(100 * tight_atm, 1)       AS tight_atm_pct,
    round(100 * wide_atm, 1)        AS wide_atm_pct,
    round(100 * volume_weighted, 1) AS volume_weighted_pct,
    round(100 * (greatest(tight_atm, wide_atm, volume_weighted)
               - least(tight_atm, wide_atm, volume_weighted)), 1) AS spread_pp
FROM weekly
ORDER BY week_start

In the first week in view, July 28, 2025, the three recipes printed 16.6%, 16.4% and 16.7%. The distance between the highest and lowest of them was 0.2 percentage points, and the spread column tracks that gap across all 53 weeks. None of the three is the true 30-day IV for the fund. Each answers a slightly different question, and a vendor chart is one of them with the recipe left off the label.

How far back does per-contract implied volatility history go?

The set behind these panels is global_markets.options_greeks: one row per contract per trading day, holding implied volatility next to delta, gamma, vega, theta and rho, plus the strike, the expiration, days to expiry, the underlying symbol and the underlying close. It is end-of-day, not a live chain snapshot. The panel below counts how many distinct underlying names carry at least one converged IV row in each quarter.

SELECT
    concat(toString(toYear(date)), '-Q', toString(toQuarter(date))) AS quarter,
    uniqExact(underlying_symbol)                                    AS underlyings_covered
FROM global_markets.options_greeks
WHERE iv_converged = 1
  AND volume > 0
  AND underlying_symbol NOT IN ('SPCX')
  AND date < '2026-07-01'
GROUP BY quarter
ORDER BY min(date)

Coverage runs from 2014-Q2 through 2026-Q2, 49 quarters in all, with 5799 underlying names carrying converged daily IV in the last full quarter shown.

Four filters do most of the work when you query a set like this.

• Keep iv_converged = 1. The solver does not always land, and an unconverged row is a failed fit rather than a low reading.
• Keep volume > 0. A contract that never traded carries an IV solved from a stale quote.
• Group by underlying_symbol. The ticker column holds the OCC contract code, so grouping on it returns one row per strike and expiry instead of one per company.
• Select contracts deliberately, near the money and inside a days-to-expiry window. Skipping that step averages the skew and the term structure into one figure.

Is there a free implied volatility API?

Free sources exist, and each is partial in a specific way.

• Broker platforms compute IV on their own chains and display it live. Downloadable history is short or absent, and the number is that broker's model rather than a standard.
• Exchange-published volatility indices go back decades and cost nothing. Each is a single blended figure for one basket, so it answers a market-wide question and not a single-name one.
• General market data APIs mostly stop at prices. Per-contract greeks are a separate product nearly everywhere, and free tiers that include them tend to return a live snapshot with no archive. Our free stock market data API rundown covers what the open tiers actually hand over.
• Vendor-priced per-contract history is where the long single-name archives sit, sold as end-of-day files by month or by year, with realtime chains priced well above the historical set. What real time market data costs lays out the shape of those price lists.

The snapshot versus end-of-day distinction matters as much as the price. A snapshot taken at 4:00 p.m. ET uses whatever quotes stood at that instant. A file built from settlement prices uses a different input entirely, and the two diverge most on the fastest days.

Blended index volatility and single-name volatility are also not interchangeable. An index option prices a basket's move, where offsetting moves between members damp the total. A single-name option prices one company's own path. The panel below puts household names side by side over one month on identical filters.

SELECT
    underlying_symbol                                              AS symbol,
    round(100 * quantileDeterministic(0.50)(iv, contract_hash), 1) AS median_iv_pct,
    count()                                                        AS contract_day_count
FROM
(
    SELECT
        underlying_symbol,
        toFloat64(implied_volatility) AS iv,
        cityHash64(ticker)            AS contract_hash
    FROM global_markets.options_greeks
    WHERE underlying_symbol IN ('SPY', 'AAPL', 'MSFT', 'NVDA', 'AMZN', 'KO', 'XOM', 'TLT')
      AND date >= '2026-06-01'
      AND date <  '2026-07-01'
      AND iv_converged = 1
      AND volume > 0
      AND underlying_close > 0
      AND days_to_expiry BETWEEN 20 AND 45
      AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
)
GROUP BY symbol
ORDER BY median_iv_pct DESC

Over June 2026, median near-the-money IV in the 20 to 45 day window ran from 38.5% at NVDA down to 10.4% at TLT, across 8 names. Same window, same filters, same solve. A ranking like that holds only while the recipe stays fixed for every name in it.

Does the source matter for IV rank and IV percentile?

It decides the answer. IV rank measures today's IV against the highest and lowest values of a lookback, usually a year, and IV percentile counts what share of days in that lookback sat below today. Both read one series end to end, so a change in the series moves the score with no change in the market at all. Splice a broker's mid-quote IV onto a vendor's settlement-based archive and you install a permanent step in the middle of the lookback, and every rank computed across it inherits that step. IV rank vs IV percentile walks through both calculations. The same requirement applies when you compare implied against realized movement: historical volatility vs implied volatility covers that pairing.

The working standard is a provenance rule. Pick one source, one model, one contract-selection recipe and one maturity convention, then hold all four fixed for the entire lookback. A series that is internally consistent and slightly different from everyone else's is worth more than a stitched one that agrees with each vendor in patches.

FAQ

Where can I get historical implied volatility data?

Long single-name histories come from options data vendors that sell per-contract end-of-day greeks, usually as monthly or annual files. Exchanges publish free index-level volatility histories. Broker platforms show live IV on their chains with little downloadable history. The panels above run against a per-contract daily set covering every listed contract with a converged fit.

Is there a free implied volatility API?

Free tiers that include per-contract greeks are rare, and the ones that exist usually return a live snapshot rather than an archive. Index volatility history is the main genuinely free long series. Deep single-name history is normally a paid product.

Why do two sources show different implied volatility for the same stock?

Different pricing models, different input quotes, different contract selection and different maturity interpolation. The panel above builds three 30-day series from one set of rows and they sit 0.2 percentage points apart in the first week alone, so a gap between two vendors is expected rather than an error.

How far back does implied volatility data go?

It depends on the source, and per-contract archives are shorter than price archives everywhere. The set behind this page starts at 2014-Q2 and carries daily rows for every converged contract since then.

Every panel here ships with the SQL that produced it, expand one to see exactly which contracts went into the number. To build the same series for another name, another window or another recipe, ask for it in plain English on the Strasmore terminal.