How to get historical implied volatility and IV rank as data

The short way

"The implied volatility of AAPL" is not a field on any option. The feed carries option quotes and trades; every vendor solves an IV per contract and then builds one number per stock from them — usually at the money, at a constant 30 calendar days, interpolated between the two expiries either side of that date, which is the convention Cboe's VIX methodology formalises for the index. Why the per-contract numbers differ between platforms — model, quote, clock, rate, dividend — is the whole of why implied volatility differs. This page is about getting a daily series out, and the first decision is whose construction you want.

If one vendor's construction will do, buy the series. ORATS's historical IV rank endpoint returns, per trading day, iv — defined as "implied volatility at 30 days interpolated" — with one-month and one-year rank and percentile beside it:

import pandas as pd
import requests

r = requests.get(
    "https://api.orats.io/datav2/hist/ivrank",
    params={"token": "YOUR_API_KEY", "ticker": "AAPL"},
    timeout=60,
)
r.raise_for_status()
iv = pd.DataFrame(r.json()["data"])
iv["tradeDate"] = pd.to_datetime(iv["tradeDate"])
print(iv[["tradeDate", "iv", "ivRank1m", "ivPct1m", "ivRank1y", "ivPct1y"]].tail())

The docs make tradeDate optional when a ticker is given, which is what turns a snapshot into a history; check the row count against the dates you expected. Every ORATS data plan includes the end-of-day history back to 2007, from the $199 Delayed plan with 20,000 requests a month.

What the options are

A finished series with rank and percentile. ORATS as above. For the term structure, the historical summaries endpoint carries iv10d, iv20d, iv30d, iv60d, iv90d, iv6m and iv1y — each a calendar-day interpolated IV — plus ex-earnings versions such as exErnIv30d, all from one smoothed surface per day.

A finished series at fixed tenors. IVolatility's IVX is built, per its API reference, from eight at-the-money options in each expiry — four calls and four puts — weighted by delta and vega, then normalised to 7, 14, 21, 30, 60, 90, 120, 150, 180, 270, 360, 720 and 1,080 days. The endpoint returns a call, a put and a mean IV for each tenor, so the term structure is one row per day. The vendor's own Python package handles the paging:

import ivolatility as ivol

ivol.setLoginParams(apiKey="YOUR_API_KEY")
get_ivx = ivol.setMethod("/equities/eod/ivx")
ivx = get_ivx(symbol="AAPL", from_="2024-01-01", to="2025-12-31")
print(ivx[["date", "30d_iv_mean", "30d_iv_call", "30d_iv_put", "90d_iv_mean"]].tail())

Over 500 rows, the REST API returns an empty data array and a link to a CSV instead; the package follows the link for you, a hand-rolled client has to. IV rank and percentile for 30 to 180 days sit on a separate stock-market-data endpoint, defined as the IVX's position in its 52-week range and the share of days in the past 52 weeks when the IVX was lower. Retail plans start at $79 a month.

Your broker's own number. With an Interactive Brokers account, ib_async asks TWS for daily bars of OPTION_IMPLIED_VOLATILITY, which IB's API reference lists for stocks, ETFs and indices and describes as an at-market volatility for a maturity thirty calendar days forward, based on option prices from two consecutive expiration months:

from ib_async import IB, Stock, util

ib = IB()
ib.connect("127.0.0.1", 7497, clientId=2)
bars = ib.reqHistoricalData(
    Stock("AAPL", "SMART", "USD"), endDateTime="", durationStr="2 Y",
    barSizeSetting="1 day", whatToShow="OPTION_IMPLIED_VOLATILITY", useRTH=True,
)
iv = util.df(bars)[["date", "close"]]   # close is the day's last implied volatility

It comes with no rank, no percentile and no term structure, and IB's own pacing rules on historical requests apply. It is also IB's construction, which is the point if IB is the platform you watch.

A chain you turn into a series yourself. ThetaData's end-of-day greeks endpoint returns, for every strike and expiry of one underlying on one day, implied_vol, iv_error, underlying_price and underlying_timestamp. It runs through the local Theta Terminal, expiration=* has to be requested a day at a time, and it needs the Standard plan, $80 a month with history from 2016. The 30-day at-the-money number is then yours to build — here by averaging the call and put IV at the strike nearest the stock, then interpolating total variance between the expiries either side of 30 days:

import io

import numpy as np
import pandas as pd
import requests

URL = "http://127.0.0.1:25503/v3/option/history/greeks/eod"

def iv30(symbol: str, day: str) -> float:
    """30-calendar-day at-the-money IV for one day, from that day's end-of-day chain."""
    r = requests.get(URL, params={"symbol": symbol, "expiration": "*", "start_date": day,
                                  "end_date": day, "strike_range": 1}, timeout=300)
    r.raise_for_status()
    df = pd.read_csv(io.StringIO(r.text))
    df = df[df["implied_vol"] > 0]
    df = df.assign(dte=(pd.to_datetime(df["expiration"]) - pd.Timestamp(day)).dt.days,
                   dist=(df["strike"] - df["underlying_price"]).abs())
    df = df[df["dte"] > 0]
    atm = df[df["dist"] == df.groupby("expiration")["dist"].transform("min")]
    term = atm.groupby("dte")["implied_vol"].mean()          # one ATM IV per expiry
    t = term.index.to_numpy() / 365
    if not t.min() <= 30 / 365 <= t.max():
        return float("nan")                                   # no expiry on one side of 30 days
    var = term.to_numpy() ** 2 * t                            # total variance
    return float(np.sqrt(np.interp(30 / 365, t, var) / (30 / 365)))

print(iv30("AAPL", "20241104"))

Every line of that function is a choice a vendor made differently: which strike counts as at the money, whether calls and puts are averaged, whether to interpolate in variance or in volatility, and in calendar or trading days.

Exchange files. Cboe DataShop's Option EOD Summary covers every OPRA series on US stocks, ETFs and indices from January 2012, with IV and greeks as an add-on calculated at the 15:45 ET snapshot, which Cboe says it uses as a more accurate picture of liquidity than the close. A full-market day with the calculations is $70 in the cart; it arrives as CSV on SFTP overnight, and it is a chain, so the series is built as above.

Once you have a series, rank and percentile over your own window are three lines:

win = iv_series.rolling(252)                                  # trading days, about a year
rank = 100 * (iv_series - win.min()) / (win.max() - win.min())
pct = 100 * win.apply(lambda w: (w[:-1] < w[-1]).mean(), raw=True)

Computed on ORATS's iv, these will not always match its ivRank1y: the window length and whether today counts are the first suspects.

On pandas 3.0. pandas 3.0, released on 21 January 2026, turns on Copy-on-Write, reads text columns into a str dtype and parses date strings to microseconds rather than nanoseconds. On 9 October 2026, under pandas 3.0.6, the ThetaData function and the rank lines ran unchanged against a hand-made chain with the columns the function reads, and pd.to_datetime on the ORATS tradeDate gave datetime64[us]. They survive because they build columns with assign and filter by selection rather than writing into a slice. A cleaning step written the old way — df["implied_vol"][df["iv_error"] > 0.05] = np.nan — now changes nothing and only warns; write df.loc[df["iv_error"] > 0.05, "implied_vol"] = np.nan. And a date column turned into epoch integers with .astype("int64") counts microseconds, not nanoseconds.

Market Chameleon and Quant Data show IV rankings too, with one year of IV history or about one — enough to look at, not to backfill.

Where this breaks

The same vendor ships two units. ORATS's IV rank endpoint gives iv in percent — its own example reads 36.195 — while its summaries give iv30d as a decimal, 0.185834 in the example. IVolatility's IVX fields are decimals. A chart that joins the two shows a hundredfold jump, and a rank computed across it is meaningless. Check the magnitude of the first row before anything else.

Four vendors, four instants. ORATS takes its daily snapshot 14 minutes before the close. DataShop calculates at 15:45 ET. IVolatility's end-of-day price is the mid of the closing bid and ask, published after 17:00 ET, with a 15:45 snapshot kept as well. ThetaData's end-of-day greeks come from a report generated at 17:15 ET from closing prices. On a day the stock moves in the last quarter hour, these are four different IVs, all correct.

A backfill needs the stock price at the same moment as the option. IV is solved against an underlying price, and an option quote at 16:00 against a stock price from 15:50 is a different option. ThetaData returns underlying_timestamp beside the option's timestamp for exactly this check, and its own pages disagree with each other about which option price feeds the end-of-day IV — the endpoint description says the closing price, the field description says the trade price. For a strike that last traded at 10:00, the second reading means a morning price against an afternoon stock. Filter on the timestamps, and treat a large iv_error as a contract to drop rather than a number to average.

Index options need an index price someone may not sell you. A ThetaData options plan does not include index prices — those are its separate indices plan — and DataShop's index underlying bid and ask cover SPX and OEX only, for holders of a Cboe index feed licence. ORATS sidesteps it by solving an implied futures price per expiry for index underlyings. A home-built SPX series has to settle this before the first IV.

Earnings move the 30-day number on a schedule. Once an announcement falls inside 30 days, the interpolation leans on an expiry that carries the event, and the series climbs into the date and drops after it. ORATS publishes ex-earnings IVs for this reason, and its ivPctile1y on the cores endpoint is a percentile of the ex-earnings IV, not of the iv that ivPct1y uses. Same vendor, two "IV percentiles".

Rank and percentile need a year before the first value. A one-year rank on a series that starts in January 2016 has nothing to say until early 2017. Backfill a year more than you plan to use. And rank and percentile are different statistics on the same series — the guide's IV rank section has the definitions and why a threshold from one platform means nothing on another.

The interpolation needs an expiry on each side. A name with monthly expiries only can have its nearest expiry 35 days out, at which point there is nothing to interpolate from and np.interp would quietly hand back the edge value; the function above returns NaN instead. IVolatility's 7-, 14-, 21- and 270-day tenors start only on 10 October 2019, for the same kind of reason.

The licence is personal. ThetaData's and IVolatility's retail plans are one person's own use; showing the series on a website or inside a product is a business licence at a multiple of the price. See redistribution.

If you outgrow this

Intraday IV. IVolatility sells one-minute IVX for US stocks since 2017, delivered after the close; ORATS's one-minute history starts in August 2020 on its $599 Live Intraday plan.

The whole surface rather than one point. ORATS's implied monies endpoint carries its smoothed surface per expiry at fixed deltas, and IVolatility sells an IV surface across moneyness; past that, it is chains — how to get an options chain covers the retrieval, and the options data cost calculator prices the OPRA fee that comes with real-time.

Why chains cost what they do is why options data costs more, and every card that sells options data is in the options data collection.