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 to measure the volatility risk premium.

At a Glance

Data type	Entities	Frequency / cadence	Unit	Primary endpoint	Coverage
Metric	Exchange-pairs (constant delta, skew), exchange-assets (at-the-money)	1h, 1d	Dimensionless (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_<tenor>_expiration

The <tenor> 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 ↗.

Metric	Description	Frequency	Coverage
volatility_implied_atm_1d_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_expiration	The 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_<type>_delta_<delta>_<tenor>_expiration

Component	Values	Meaning
<type>	call, put	The 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, 50	The 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, 1y	The 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.

Coverage for the group: calls ↗ and puts ↗.

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_<delta>_<tenor>_expiration

Component	Values	Meaning
<delta>	05, 10, 15, 20, 25, 30, 35, 40, 45, 50	The 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, 1y	The 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 ↗.

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.

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 and Market Greeks. 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 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.

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 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:

• /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.

Python Client

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()

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"

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()

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 and /timeseries/exchange-asset-metrics.

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 ↗

{
  "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 ↗

{
  "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.

Coin Metrics CoverageCoin Metrics Coverage

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 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.
• 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 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 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: the per-contract exchange-reported implied volatility these metrics are interpolated from.
• Realized Volatility Metrics: backward-looking volatility measured from observed reference rate returns, the usual comparison for the volatility risk premium.
• Market Greeks: the exchange-reported delta and other greeks for individual option contracts.
• Market Open Interest: contract-level open interest for the same option markets.
• Reference Rate Metrics: the spot price series the at-the-money strike selection is anchored to.
• Exploring Options, Open Interest, and Volatility Data: a worked tutorial that builds volatility smiles from this data.