> For the complete documentation index, see [llms.txt](https://gitbook-docs.coinmetrics.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gitbook-docs.coinmetrics.io/market-data/market-data-overview/implied-volatility-metrics.md). # Implied Volatility Metrics ## Overview Implied volatility metrics turn a fragmented option chain into continuous, comparable timeseries. Raw option markets scatter liquidity across hundreds of discrete contracts, each with its own strike and expiration date, and each of those contracts stops existing when it expires. Coin Metrics interpolates the exchange-reported implied volatility of those contracts onto a fixed grid of tenors and deltas, so a single series can be tracked through time without the shape of the underlying contract changing underneath it. The family covers three views of the same surface. **At-the-money implied volatility** gives one headline number per tenor, anchored to the current spot price. **Constant-delta implied volatility** gives the full surface, a call and a put value at each delta and tenor, which is what makes the volatility smile visible. **Skew** is the call-minus-put spread at matching delta and tenor, a direct read on whether the market is paying up for upside or for downside protection. Options desks use them to quote and hedge, risk teams use them as forward-looking risk inputs, and researchers use them alongside [realized volatility](/market-data/market-data-overview/realized-volatility-metrics.md) to measure the volatility risk premium. ## At a Glance
Data typeEntitiesFrequency / cadenceUnitPrimary endpointCoverage
MetricExchange-pairs (constant delta, skew), exchange-assets (at-the-money)1h, 1dDimensionless (annualized decimal)/timeseries/exchange-pair-metrics🔗
## Metrics The family splits into three groups by what is held constant. Each group is generated over a parameter grid, so every metric ID encodes a tenor, the two surface groups encode a delta as well, and only the constant-delta group encodes an option type. ### Constant maturity, at-the-money These metrics estimate the implied volatility of a hypothetical option that always has a fixed time to expiration and a strike equal to the current spot price. They are published for exchange-assets and follow the convention: ``` volatility_implied_atm__expiration ``` The `` component takes the values `1d`, `2d`, `3d`, `7d`, `14d`, `21d`, `30d`, `60d`, `90d`, `120d`, `180d`, `270d`, and `1y`. This group is small enough to list in full, so each metric carries its own coverage link below. Coverage for the group as a whole: [at-the-money ↗](https://coverage.coinmetrics.io/search-results?query=volatility_implied_atm_%2A).
MetricDescriptionFrequencyCoverage
volatility_implied_atm_1d_expirationThe annualized estimated implied volatility of an option expiring 1 day in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_2d_expirationThe annualized estimated implied volatility of an option expiring 2 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_3d_expirationThe annualized estimated implied volatility of an option expiring 3 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_7d_expirationThe annualized estimated implied volatility of an option expiring 7 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_14d_expirationThe annualized estimated implied volatility of an option expiring 14 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_21d_expirationThe annualized estimated implied volatility of an option expiring 21 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_30d_expirationThe annualized estimated implied volatility of an option expiring 30 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_60d_expirationThe annualized estimated implied volatility of an option expiring 60 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_90d_expirationThe annualized estimated implied volatility of an option expiring 90 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_120d_expirationThe annualized estimated implied volatility of an option expiring 120 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_180d_expirationThe annualized estimated implied volatility of an option expiring 180 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_270d_expirationThe annualized estimated implied volatility of an option expiring 270 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
volatility_implied_atm_1y_expirationThe annualized estimated implied volatility of an option expiring 365 days in the future, using at the money option contracts with near-by expiration dates.1h, 1d🔗
### Constant maturity, constant delta These metrics are standardized slices of the volatility surface, holding both time to expiration and moneyness fixed. They are published for exchange-pairs. All 260 metric IDs follow one convention: ``` volatility_implied__delta___expiration ```
ComponentValuesMeaning
<type>call, putThe contract type the value is interpolated from. Calls and puts are interpolated separately and are never averaged together.
<delta>05, 10, 15, 20, 25, 30, 35, 40, 45, 50The target option delta, as an absolute value scaled by 100. A value of 25 means a delta of 0.25 for a call and a delta of -0.25 for a put. Lower values sit further out of the money, and 50 is approximately at the money.
<tenor>1d, 2d, 3d, 7d, 14d, 21d, 30d, 60d, 90d, 120d, 180d, 270d, 1yThe target time to expiration.
For example, `volatility_implied_put_delta_25_30d_expiration` is the annualized interpolated implied volatility of a 25-delta put expiring 30 days in the future. Not every tenor is published for every exchange-pair, because venues differ in how far out they list contracts. See [Tenor ranges and null values](#tenor-ranges-and-null-values). Coverage for the group: [calls ↗](https://coverage.coinmetrics.io/search-results?query=volatility_implied_call_%2A) and [puts ↗](https://coverage.coinmetrics.io/search-results?query=volatility_implied_put_%2A). ### Skew Skew metrics are the spread between the call and put implied volatility at the same absolute delta and tenor, following the risk-reversal convention. They are published for exchange-pairs. All 130 metric IDs follow one convention: ``` volatility_implied_skew_delta___expiration ```
ComponentValuesMeaning
<delta>05, 10, 15, 20, 25, 30, 35, 40, 45, 50The absolute delta shared by both legs, scaled by 100. The call leg is taken at a delta of +0.<delta> and the put leg at -0.<delta>, so the two sit equidistant from the money. Lower values compare the far wings of the smile, where the premium for tail risk shows up most clearly. At 50 both legs are approximately at the money and the spread is typically closest to zero.
<tenor>1d, 2d, 3d, 7d, 14d, 21d, 30d, 60d, 90d, 120d, 180d, 270d, 1yThe target time to expiration, shared by both legs. There is no <type> component, because a skew value consumes one call and one put rather than being published per contract type.
For example, `volatility_implied_skew_delta_25_30d_expiration` is the 25-delta, 30-day skew, the difference between `volatility_implied_call_delta_25_30d_expiration` and `volatility_implied_put_delta_25_30d_expiration`. Because skew is derived from those two constant-delta metrics at the same coordinates, it exists only where both of them exist. Coverage for the group: [skew ↗](https://coverage.coinmetrics.io/search-results?query=volatility_implied_skew_%2A). {% hint style="info" %} **Conventions.** Decimals are returned as JSON strings to preserve precision. Timestamps are UTC ISO-8601 with nanosecond resolution, and `time` is the observation time of the interpolated value. Every metric in this family is an annualized standard deviation of returns expressed as a decimal rather than a percentage, so `0.3180286` means 31.80286%. Skew is a difference of two such decimals and can be negative. The frequency is a query parameter rather than part of the metric ID. {% endhint %} ## Methodology Every metric on this page is an interpolation of values the venues themselves publish. The subsections below cover the input data, the interpolation used for each group, the entity level each group is published at, and when a value is withheld. ### Input data: exchange-reported implied volatility The input is the mark implied volatility and the delta that each option venue reports for each of its listed contracts, the same values served by [Market Implied Volatility](/market-data/market-data-overview/market-implied-volatility.md) and [Market Greeks](/market-data/market-data-overview/market-greeks.md). Coin Metrics does not run its own option pricing model for these metrics and does not reprice the contracts. Only the mark value is used, never the bid or ask implied volatility, because the mark comes from the venue's own mark price and stays populated even for contracts with no live two-sided quote. Two consequences follow. First, each figure inherits the reporting venue's model assumptions about the risk-free rate, the underlying price, and funding, so values are best compared within a venue rather than across venues. Second, the delta used to place a contract in a delta bucket is also the venue's own, and comes from that same model. ### Why constant maturity and constant delta Tracking the implied volatility of a specific contract through time conflates two effects that a continuous series needs to separate. 1. **Time decay.** The time to expiration of any specific contract decreases linearly. An option that expires in 30 days today expires in 29 days tomorrow, so a day-over-day change in its implied volatility mixes a change in market conditions with the mechanical passage of time. 2. **Moneyness.** As the spot price of the underlying moves, the meaning of a fixed strike changes. A $60,000 strike is a very different risk profile when the underlying trades at $40,000 than when it trades at $59,000. Holding maturity fixed removes the first effect. Holding delta, or the at-the-money condition, fixed removes the second. What remains is a series whose movement reflects the market's changing expectations rather than the changing shape of the contract. ### At-the-money interpolation The at-the-money metrics are built per exchange-asset from call contracts, in five steps. 1. **Horizon selection.** For each observation, a target time to expiration $$T\_{target}$$ is set from the metric's tenor. 2. **Spot reference.** The price of the underlying, $$S\_t$$, is taken from the [Coin Metrics Reference Rate](/coin-metrics-prices/coin-metrics-prices/reference-rate-metrics.md) at real-time frequency. Where the option's quote asset is not US dollars, a synthetic rate is built from the two US-dollar reference rates for the base and quote assets. 3. **Expiry selection.** Among the venue's listed call contracts, the nearest expiration before the target and the nearest expiration after the target are selected, giving a near-term and a far-term expiry that bracket $$T\_{target}$$. 4. **Strike selection.** Within each of those two expiries, the contract whose strike $$K$$ minimizes $$|S\_t - K|$$ is chosen. That yields two reference values, $$\sigma\_{near}$$ and $$\sigma\_{far}$$. 5. **Time-weighted mean.** The two values are combined into a weighted mean whose weights are inversely proportional to each contract's distance from the target date, so the contract expiring closer to the target dominates. Writing $$\Delta t\_i$$ for the absolute difference between a contract's expiration and the target: $$ \Delta t\_{i} = | T\_{target} - T\_{expiration, i} | $$ $$ w\_i = \frac{1}{\Delta t\_{i}} $$ $$ \sigma\_{target} = \frac{w\_{near} \cdot \sigma\_{near} + w\_{far} \cdot \sigma\_{far}}{w\_{near} + w\_{far}} $$ When a listed expiry falls exactly on the target date, that contract receives an overwhelming weight and effectively determines the value on its own. When the venue lists a contract expiring before the target but nothing after it, the near-term value is used directly with no interpolation. When the reverse holds and only a later expiry is available, no value is published for that tenor. ### Constant-delta interpolation The constant-delta metrics interpolate in two dimensions, first across delta and then across expiration. Calls and puts are processed independently, and put deltas are matched on their signed value, so the `25` in a put metric ID targets a delta of -0.25. Both steps interpolate a squared quantity rather than implied volatility itself, because volatility does not add linearly. They square different things, and the difference is not cosmetic. The delta step interpolates **variance**, $$\sigma^2$$. The expiry step interpolates **total variance**, $$\sigma^2 T$$, which is variance multiplied by the time to expiration. The delta step can leave $$T$$ out because both of its inputs come from the same listed expiry, so the time factor is common to them and cancels. The expiry step is interpolating across two different expiries, so $$T$$ has to be carried explicitly. For a target delta, the two bracketing contracts within a given expiry are the one with the largest delta at or below the target and the one with the smallest delta at or above it. The interpolation runs on variance and is converted back at the end: $$ \sigma\_{\Delta} = \sqrt{ \sigma\_{lower}^{2} \cdot \frac{\Delta\_{upper} - \Delta\_{target}}{\Delta\_{upper} - \Delta\_{lower}} + \sigma\_{upper}^{2} \cdot \frac{\Delta\_{target} - \Delta\_{lower}}{\Delta\_{upper} - \Delta\_{lower}} } $$ That step is applied twice, once within the nearest listed expiry before the target date and once within the nearest listed expiry after it, producing $$\sigma\_1$$ at expiry $$T\_1 < T\_{target}$$ and $$\sigma\_2$$ at expiry $$T\_2 > T\_{target}$$, both at the target delta. The second step interpolates across expiration, on total variance rather than on the plain variance used above. This is the standard choice because total variance is what must increase monotonically with maturity for the surface to stay arbitrage-free, and interpolating it directly preserves that property: $$ V\_1 = \sigma\_1^2 \cdot T\_1 $$ $$ V\_2 = \sigma\_2^2 \cdot T\_2 $$ $$ V\_{target} = \frac{T\_{target} - T\_1}{T\_2 - T\_1}V\_2 + \frac{T\_2 - T\_{target}}{T\_2 - T\_1}V\_1 $$ $$ \sigma\_{target} = \sqrt{\frac{V\_{target}}{T\_{target}}} $$ Times are expressed in years. The result is a smooth curve even when the target tenor does not line up with a listed expiration cycle. Two fallbacks apply when the chain does not bracket the target. If the venue lists no expiry before the target date, the nearest expiry after it is used for both sides of the expiry interpolation, and the reverse applies when nothing is listed after the target. If no contract sits above the target delta within an expiry, the highest available delta is used, and if none sits below, the lowest available is used. In each of these cases the value rests on a single contract rather than on a true bracket, which makes it more sensitive to that one contract. The input snapshot tolerates a short gap. For each calculation time, the most recent quote for each contract within the preceding five minutes is used, so a brief interruption in a venue's feed does not break the series. A contract that has published nothing in that window is absent from the calculation entirely. ### Skew calculation Skew is computed from the constant-delta metrics rather than from the option chain directly. At each delta and tenor it is the call value minus the put value at the same absolute delta: $$ \text{Skew}*{\Delta, T} = \sigma*{\text{call}, \Delta, T} - \sigma\_{\text{put}, \Delta, T} $$ Because the sign convention is call minus put, the sign of the metric reads directly as directional bias: * **Positive skew.** Calls are priced above puts at the same absolute delta. The market is paying a premium for upside exposure. * **Negative skew.** Puts are priced above calls. The market is paying a premium for downside protection, which is the more common state in most option markets. * **Skew near zero.** The market prices upside and downside volatility roughly symmetrically. Both legs must be present at the same timestamp, delta, and tenor for a skew value to be published. Where one side is missing, no skew value is written for that coordinate. ### Entity scope The three groups sit at two entity levels, and the split is deliberate. The constant-delta and skew metrics are published per **exchange-pair**, for example `deribit-btc-usd` and `bybit-btc-usdc`. A single venue can list several distinct option chains on the same underlying that settle in different quote assets, such as a BTC-USDT chain and a BTC-USDC chain on the same exchange. Those chains have their own liquidity and their own surfaces, so keying on the exchange-pair prevents contracts from separate chains being interpolated together. The at-the-money metrics are published per **exchange-asset**, for example `deribit-btc`, aggregated to the base asset across that venue's chains. This means an at-the-money series and a 50-delta series for the same venue and underlying are not the same number and are not interchangeable. They differ in entity level, in the contracts they draw on, and in the interpolation applied. See the [FAQ](#is-the-at-the-money-metric-the-same-as-the-50-delta-metric-at-the-same-tenor). ### Tenor ranges and null values No venue lists option contracts spanning the whole range from one day to one year, so publishing every tenor for every exchange-pair would require extrapolating past the ends of the listed chain. Instead, each exchange-pair carries its own supported tenor range, set from that venue's contract listing policy for that chain and bounded so that targets stay inside the span of contracts the venue actually lists. Requesting a tenor outside an exchange-pair's supported range returns no value for that exchange-pair. The [coverage page](https://coverage.coinmetrics.io/search-results?query=volatility_implied_%2A) shows which tenors are published for each exchange-pair. A value is also withheld, rather than estimated, when the inputs are not there: when no contract for that chain has reported inside the five-minute window, when the delta or expiry brackets cannot be formed at all, or, for skew, when only one of the two legs is available. ### Precision The at-the-money metrics are rounded to seven significant digits. The constant-delta and skew metrics carry substantially more precision, up to sixteen decimal places. This is why an at-the-money value reads as `0.3180286` while a constant-delta value at the same timestamp reads as `0.305449260721611`. Both are exact as returned, and the difference in length does not reflect a difference in the accuracy of the estimate, which is bounded by the venue's own reported values in either case. ## Accessing the Data The metrics are served through two timeseries endpoints, split by entity as described under [Entity scope](#entity-scope): * `/timeseries/exchange-pair-metrics` for the constant-delta and skew metrics * `/timeseries/exchange-asset-metrics` for the at-the-money metrics The tabs below pull the 25-delta 30-day call, put, and skew for the Deribit BTC-USD option chain. {% tabs %} {% tab title="Python Client" %} ```python from coinmetrics.api_client import CoinMetricsClient from datetime import timedelta import os client = CoinMetricsClient(os.environ["CM_API_KEY"]) df = client.get_exchange_pair_metrics( exchange_pairs=["deribit-btc-usd"], metrics=[ "volatility_implied_call_delta_25_30d_expiration", "volatility_implied_put_delta_25_30d_expiration", "volatility_implied_skew_delta_25_30d_expiration", ], frequency="1d", start_time="2026-07-01", end_time="2026-08-01", format="json_stream", ).parallel(time_increment=timedelta(days=7)).to_dataframe() ``` {% endtab %} {% tab title="Shell" %} ```shell curl --compressed "https://api.coinmetrics.io/v4/timeseries/exchange-pair-metrics?exchange_pairs=deribit-btc-usd&metrics=volatility_implied_call_delta_25_30d_expiration,volatility_implied_put_delta_25_30d_expiration,volatility_implied_skew_delta_25_30d_expiration&frequency=1d&start_time=2026-07-01&end_time=2026-08-01&page_size=10000&api_key=$CM_API_KEY" ``` {% endtab %} {% tab title="Python" %} ```python import os import requests response = requests.get( "https://api.coinmetrics.io/v4/timeseries/exchange-pair-metrics", params={ "exchange_pairs": "deribit-btc-usd", "metrics": "volatility_implied_call_delta_25_30d_expiration,volatility_implied_put_delta_25_30d_expiration,volatility_implied_skew_delta_25_30d_expiration", "frequency": "1d", "start_time": "2026-07-01", "end_time": "2026-08-01", "page_size": 10000, "api_key": os.environ["CM_API_KEY"], }, ).json() ``` {% endtab %} {% endtabs %} The at-the-money metrics are requested the same way against the exchange-asset endpoint, using `exchange_assets` in place of `exchange_pairs` and `client.get_exchange_asset_metrics` in place of `client.get_exchange_pair_metrics`. Full parameter reference: see the API Reference for [`/timeseries/exchange-pair-metrics`](https://docs.coinmetrics.io/api/v4/#operation/getTimeseriesExchangePairMetrics) and [`/timeseries/exchange-asset-metrics`](https://docs.coinmetrics.io/api/v4/#operation/getTimeseriesExchangeAssetMetrics). ## Examples ### Example: the surface and skew for one exchange-pair Daily 25-delta call, put, and skew values for the Deribit BTC-USD option chain. The skew value is the call value minus the put value on the same row, and it is negative here because puts are priced above calls at this delta. [Open in browser ↗](https://api.coinmetrics.io/v4/timeseries/exchange-pair-metrics?exchange_pairs=deribit-btc-usd\&metrics=volatility_implied_call_delta_25_30d_expiration,volatility_implied_put_delta_25_30d_expiration,volatility_implied_skew_delta_25_30d_expiration\&frequency=1d\&limit_per_exchange_pair=3\&paging_from=end\&api_key=YOUR_API_KEY) ```json { "data": [ { "exchange_pair": "deribit-btc-usd", "time": "2026-08-05T00:00:00.000000000Z", "volatility_implied_call_delta_25_30d_expiration": "0.305449260721611", "volatility_implied_put_delta_25_30d_expiration": "0.353551260628686", "volatility_implied_skew_delta_25_30d_expiration": "-0.048101999907075" }, { "exchange_pair": "deribit-btc-usd", "time": "2026-08-06T00:00:00.000000000Z", "volatility_implied_call_delta_25_30d_expiration": "0.312614265675119", "volatility_implied_put_delta_25_30d_expiration": "0.357596019964499", "volatility_implied_skew_delta_25_30d_expiration": "-0.04498175428938" }, { "exchange_pair": "deribit-btc-usd", "time": "2026-08-07T00:00:00.000000000Z", "volatility_implied_call_delta_25_30d_expiration": "0.315633473099567", "volatility_implied_put_delta_25_30d_expiration": "0.361658735981361", "volatility_implied_skew_delta_25_30d_expiration": "-0.046025262881794" } ] } ``` ### Example: the at-the-money term structure Daily at-the-money implied volatility at three tenors for Deribit BTC. Read across a row rather than down a column to see the term structure on a given day. [Open in browser ↗](https://api.coinmetrics.io/v4/timeseries/exchange-asset-metrics?exchange_assets=deribit-btc\&metrics=volatility_implied_atm_7d_expiration,volatility_implied_atm_30d_expiration,volatility_implied_atm_90d_expiration\&frequency=1d\&limit_per_exchange_asset=3\&paging_from=end\&api_key=YOUR_API_KEY) ```json { "data": [ { "exchange_asset": "deribit-btc", "time": "2026-08-05T00:00:00.000000000Z", "volatility_implied_atm_7d_expiration": "0.2915667", "volatility_implied_atm_30d_expiration": "0.3180286", "volatility_implied_atm_90d_expiration": "0.3418" }, { "exchange_asset": "deribit-btc", "time": "2026-08-06T00:00:00.000000000Z", "volatility_implied_atm_7d_expiration": "0.2860067", "volatility_implied_atm_30d_expiration": "0.3199607", "volatility_implied_atm_90d_expiration": "0.3424" }, { "exchange_asset": "deribit-btc", "time": "2026-08-07T00:00:00.000000000Z", "volatility_implied_atm_7d_expiration": "0.2878083", "volatility_implied_atm_30d_expiration": "0.3271143", "volatility_implied_atm_90d_expiration": "0.3698806" } ] } ``` ## Coverage Coverage lists every exchange-asset and exchange-pair with implied volatility metrics, the tenors published for each, and the available time range. {% embed url="" %} ## Usage The three groups answer different questions, and most workflows use more than one. * **Read the term structure.** Holding one delta and reading across tenors shows how the market prices near-term against long-term uncertainty. An inverted term structure, where short-dated volatility sits above long-dated, typically signals an imminent event, while an upward-sloping curve is the more usual state. The at-the-money metrics are the most direct way to look at this, since they collapse the surface to one number per tenor. * **Read the volatility smile.** Holding one tenor and reading across deltas shows how the market prices out-of-the-money contracts relative to at-the-money ones. Comparing a 5-delta value against a 50-delta value at the same tenor quantifies how much the market charges for tail exposure. * **Gauge sentiment and positioning.** Skew is the compact form of the smile's asymmetry. A persistently negative 25-delta skew that suddenly steepens is a common signal that the market is bidding for crash protection, and comparing skew across tenors helps distinguish a short-lived scare from a durable shift. * **Measure the volatility risk premium.** Comparing implied volatility at a given tenor against [realized volatility](/market-data/market-data-overview/realized-volatility-metrics.md) over a comparable window measures how much the option market is charging above what actually happened. The comparison is not exact, since implied volatility looks forward over the tenor while realized volatility looks backward over the window, but the spread between them is a standard input for volatility selling and hedging strategies. * **Stay within one venue.** Because the inputs carry each venue's own model, a cross-venue spread mixes a real difference in expectations with a difference in pricing assumptions. Compare a chain against its own history rather than against another venue's. ## Limitations * **Venue-defined inputs.** Both the implied volatility and the delta come from the reporting venue's own option pricing model. Two venues quoting the same economic contract can publish different values, and part of the gap is model choice rather than a real difference in expectations. Compare within a venue rather than across venues. * **Interpolation, not repricing.** These metrics interpolate exchange-reported values. They standardize the maturity and moneyness of a series, but they do not correct or replace the venue's model, and they inherit whatever the venue publishes. * **Tenor ranges differ by exchange-pair.** A tenor that exists for one exchange-pair may be absent for another because the venue does not list contracts that far out. A missing tenor is not necessarily a data gap. See [Tenor ranges and null values](#tenor-ranges-and-null-values). * **Thin wings.** At low deltas the bracketing contracts are often illiquid, and a mark price on an illiquid contract can move on little or no trading. Values at 5 and 10 delta are noisier than values near the money, and skew built from them inherits that noise from both legs. * **Fallback interpolation at the edges.** When the chain does not bracket the target delta or expiry, the nearest available point is used on both sides rather than the value being withheld. Such a value rests on a single contract and is more sensitive to it than a properly bracketed value. * **At-the-money is call-only.** The at-the-money metrics are built from call contracts, so they do not reflect information carried in the put side of the chain. * **Not a cross-family identity.** An at-the-money metric and a 50-delta metric at the same tenor are close in intent but differ in entity level, contract selection, and interpolation. They should not be substituted for one another. ## FAQ ### What units are the implied volatility metrics in? They are annualized standard deviations of returns expressed as decimals rather than percentages. A value of `0.5223685` means 52.23685%. Skew is a difference of two such decimals and is negative whenever puts are priced above calls. ### Is the at-the-money metric the same as the 50-delta metric at the same tenor? No. They are close in intent, since a 50-delta option is approximately at the money, but they are computed differently and published at different entity levels. The at-the-money metric is an exchange-asset series built from call contracts selected by the strike nearest the reference rate spot price, then interpolated across expiry with inverse-distance weights. The 50-delta metrics are exchange-pair series interpolated on variance across delta and on total variance across expiry, separately for calls and puts. Expect them to track each other closely and to differ in the detail. ### Why is a metric null for my exchange-pair or tenor? Most often because the venue does not list contracts far enough out for that tenor on that chain, so the tenor falls outside the exchange-pair's supported range. It can also happen when the venue's feed has published nothing for that chain in the preceding five minutes, when the delta or expiry brackets cannot be formed, or, for skew, when only the call or only the put leg is available. Check the [coverage page](https://coverage.coinmetrics.io/search-results?query=volatility_implied_%2A) to confirm which tenors are published for the exchange-pair. ### Is delta signed in the metric ID? No. The delta in the metric ID is an absolute value scaled by 100, and the option type carries the sign. `volatility_implied_put_delta_25_30d_expiration` targets a put with a delta of -0.25. ### Why does `bybit-btc-usdt` differ from `bybit-btc-usdc`? Because they are separate option chains on the same venue, settling in different quote assets, with their own contracts and their own liquidity. Keying the metrics on the exchange-pair keeps them from being mixed, so differences between the two are real differences between the chains. ### How do these relate to the raw implied volatility data? [Market Implied Volatility](/market-data/market-data-overview/market-implied-volatility.md) serves the per-contract, exchange-reported values that feed these metrics, at market granularity and at up to one observation per minute. Use it when you need a specific contract. Use these metrics when you need a continuous series at a fixed tenor and moneyness. ### Can I get these metrics for futures or spot markets? No. The whole family is derived from option contracts, so it exists only for the exchange-assets and exchange-pairs that have an option chain. ## Related * [Market Implied Volatility](/market-data/market-data-overview/market-implied-volatility.md): the per-contract exchange-reported implied volatility these metrics are interpolated from. * [Realized Volatility Metrics](/market-data/market-data-overview/realized-volatility-metrics.md): backward-looking volatility measured from observed reference rate returns, the usual comparison for the volatility risk premium. * [Market Greeks](/market-data/market-data-overview/market-greeks.md): the exchange-reported delta and other greeks for individual option contracts. * [Market Open Interest](/market-data/market-data-overview/market-open-interest.md): contract-level open interest for the same option markets. * [Reference Rate Metrics](/coin-metrics-prices/coin-metrics-prices/reference-rate-metrics.md): the spot price series the at-the-money strike selection is anchored to. * [Exploring Options, Open Interest, and Volatility Data](/tutorials-and-examples/tutorials/exploring-options-open-interest-and-volatility-data.md): a worked tutorial that builds volatility smiles from this data. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://gitbook-docs.coinmetrics.io/market-data/market-data-overview/implied-volatility-metrics.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.