What Is VIX1D? The 1-Day Volatility Index

VIX1D is Cboe's 1-Day Volatility Index, and it measures the S&P 500 volatility the options market is pricing into the current trading day, calculated from SPX options that expire in that same session. It is quoted the way the VIX is quoted, as an annualized percentage, and that shared scale is what trips people up. A VIX1D of 20 and a VIX of 20 are two different statements about the market.

What VIX1D actually measures

Cboe introduced VIX1D in 2023, after same-day-expiry options had grown into a large share of S&P 500 option activity. The construction follows the VIX recipe: take a strip of out-of-the-money SPX puts and calls and back out the variance priced across it, with each contract weighted by its price and by the spacing between strikes. The one substantive difference is which expiration goes into the strip. The VIX reads contracts with 23 to 37 days of life left and interpolates them to a constant 30-day horizon. VIX1D reads the contracts expiring today.

Both come out annualized. Annualizing answers a hypothetical question: if the market kept moving at this pace every session for a year, how far would it travel? For a one-session index that is a strange sentence, and it is worth sitting with. VIX1D takes a single session of expected movement and scales it up to a yearly figure so the print can sit on the same axis as the VIX. The scaling is a unit conversion. It does not stretch the horizon, which stays one session.

Why a VIX1D of 20 is not a VIX of 20

Implied volatility is a curve across expirations, not a single number. The IV term structure walks the whole curve, and VIX1D and the VIX simply read two different points on it. SPX and SPY options track the same index and share the same daily expiration cycle, so the shape of that curve is easy to see on SPY contracts. The panel below averages implied volatility for SPY contracts within 2% of the money over the last 180 sessions, bucketed by days left to expiry.

SELECT
    multiIf(
        days_to_expiry = 0,   '0 (today)',
        days_to_expiry = 1,   '1',
        days_to_expiry <= 3,  '2-3',
        days_to_expiry <= 7,  '4-7',
        days_to_expiry <= 14, '8-14',
        days_to_expiry <= 21, '15-21',
        days_to_expiry <= 30, '22-30',
        days_to_expiry <= 60, '31-60',
                              '61-90')      AS dte_bucket,
    round(avg(implied_volatility) * 100, 1) AS spy_iv_pct
FROM global_markets.options_greeks
WHERE underlying_symbol = 'SPY'
  AND date >= today() - 180
  AND iv_converged = 1
  AND volume > 0
  AND days_to_expiry <= 90
  AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.02
GROUP BY dte_bucket
ORDER BY min(days_to_expiry)

The same-day bucket averaged 20.4%, and the 31-60 day bucket, the neighbourhood the VIX reads, averaged 16.2%. Those are different horizons measured on one scale. The front of the curve is also the fastest-moving part of it, since a same-day contract's value hangs on the hours still in front of it. Two things follow for anyone reading the print. Compare VIX1D against its own history rather than against the VIX, and expect the two indexes to spend long stretches far apart without either one being wrong.

The intraday roll, and why VIX1D does not fall to zero

A same-day option runs out of life over the course of the session. If VIX1D only ever read contracts expiring at today's close, the measured window would shrink toward nothing through the afternoon and the print would collapse to zero at the bell every single day. It does not do that. As the session runs down, the calculation time-weights the next session's expiration into the strip, keeping the measured horizon a full trading day forward. In the morning the reading is essentially today's contracts. By late afternoon the weight has largely handed over, and the number on the screen is mostly a statement about tomorrow's session. This is the most misread feature of the index.

The contracts that get weighted in are already trading by then. Same-day and next-day expirations are both live all day on the S&P 500 complex, and our guides on 0DTE options and when 0DTE options trade cover that calendar. The panel below pins one past session, Wednesday June 17 2026, and splits SPY option volume between the expiration dated that day and the one dated the next, in half-hour buckets on the New York clock.

SELECT
    formatDateTime(
        toStartOfInterval(toTimeZone(window_start, 'America/New_York'), INTERVAL 30 MINUTE),
        '%H:%i')                                                     AS et_time,
    sumIf(volume, startsWith(ticker, 'O:SPY260617'))                 AS expiring_today_volume,
    sumIf(volume, startsWith(ticker, 'O:SPY260618'))                 AS expiring_next_day_volume,
    round(100 * toFloat64(sumIf(volume, startsWith(ticker, 'O:SPY260617')))
              / toFloat64(sum(volume)), 1)                           AS today_share_pct
FROM global_markets.options_minute_aggs
WHERE (startsWith(ticker, 'O:SPY260617') OR startsWith(ticker, 'O:SPY260618'))
  AND window_start >= '2026-06-17 04:00:00'
  AND window_start <  '2026-06-18 04:00:00'
GROUP BY et_time
HAVING sum(volume) >= 50000
ORDER BY et_time

In the first half-hour bucket the tape prints, 09:30, 81% of the volume across those two expirations sat in contracts expiring that afternoon. By the 16:00 bucket the same-day share was 16.6%, with the remainder already in the next session's expiry. Tomorrow's contracts are liquid through the afternoon, which is what makes the roll possible in the first place.

Turning a reading into a dollar figure for the day

Getting from an annualized index back down to one session uses the square-root scaling in our rule of 16 post. Volatility scales with the square root of time, a year holds roughly 252 trading sessions, and the square root of 252 is a shade under 16. Divide an annualized reading by 16 and the result is the one-session, one-standard-deviation move, in percent.

Say the index prints 20. That is 20 / 16 = 1.25% for the day. On a $10,000 position tracking the index, 1.25% is $125. On $250,000 it is about $3,125. One standard deviation covers roughly 68% of outcomes under a normal curve, so the plain reading is that about two sessions in three would land inside that band. Index returns carry fatter tails than the normal curve, so two-in-three is a frame rather than a guarantee.

Does the divide-by-16 step survive contact with data? The panel below runs it month by month on SPY: the 20 to 45 day implied volatility divided by 16, set against what the sessions in that month actually did.

WITH iv AS
(
    SELECT
        toStartOfMonth(date)          AS month,
        avg(implied_volatility) * 100 AS iv_pct
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'SPY'
      AND date >= toStartOfMonth(today() - 400)
      AND iv_converged = 1
      AND volume > 0
      AND days_to_expiry BETWEEN 20 AND 45
      AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.05
    GROUP BY month
),
daily AS
(
    SELECT
        date,
        close_f / prev_close - 1 AS ret
    FROM
    (
        SELECT
            date,
            close_f,
            lagInFrame(close_f) OVER (ORDER BY date ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_close
        FROM
        (
            SELECT date, avg(toFloat64(close)) AS close_f
            FROM global_markets.stocks_daily_aggs
            WHERE ticker = 'SPY'
              AND date >= toStartOfMonth(today() - 400) - 10
            GROUP BY date
        )
    )
    WHERE prev_close > 0
),
realized AS
(
    SELECT
        toStartOfMonth(date)  AS month,
        stddevSamp(ret) * 100 AS stdev_pct,
        avg(abs(ret)) * 100   AS avg_abs_pct
    FROM daily
    GROUP BY month
    HAVING count() >= 15
)
SELECT
    toString(i.month)                AS month,
    formatDateTime(i.month, '%b %Y') AS month_label,
    round(i.iv_pct / 16, 2)          AS implied_daily_move_pct,
    round(r.stdev_pct, 2)            AS realized_stdev_pct,
    round(r.avg_abs_pct, 2)          AS realized_avg_move_pct
FROM iv AS i
INNER JOIN realized AS r ON i.month = r.month
ORDER BY i.month

In Jul 2026, implied volatility divided by 16 came to 0.92% a session, alongside a realized daily standard deviation of 0.76% and an average absolute daily move of 0.59%. Compare like with like: the implied line belongs against the realized standard deviation line. The average absolute move is a different statistic, and for a normal distribution it runs near 0.8 of a standard deviation, so those two realized lines are not meant to coincide.

How to read an elevated VIX1D

A high reading is commonly cited as a cue to sell option premium, on the reasoning that richer pricing pays the seller more. Be precise about what the number is. It is the price of same-day optionality, quoted in volatility units, and it says what the market charges to carry today's move. Whether that charge turns out to be generous depends on the move the session goes on to print, which is unknown while a position is open. Elevated readings commonly arrive on sessions that end up moving a lot. The mechanics of a rich number deflating after a scheduled event sit in IV crush, and the broader question is taken apart in is high implied volatility good.

The size of an ordinary session is the other half of the picture. The panel below takes every SPY session since 2019 and reports the median absolute daily move next to the 90th percentile, year by year.

WITH daily AS
(
    SELECT
        date,
        abs(close_f / prev_close - 1) * 100 AS abs_move_pct
    FROM
    (
        SELECT
            date,
            close_f,
            lagInFrame(close_f) OVER (ORDER BY date ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS prev_close
        FROM
        (
            SELECT date, avg(toFloat64(close)) AS close_f
            FROM global_markets.stocks_daily_aggs
            WHERE ticker = 'SPY'
              AND date >= '2018-12-01'
            GROUP BY date
        )
    )
    WHERE prev_close > 0
)
SELECT
    toString(toYear(date))                                                         AS year,
    round(quantileDeterministic(0.5)(abs_move_pct, toUInt32(toYYYYMMDD(date))), 2) AS median_move_pct,
    round(quantileDeterministic(0.9)(abs_move_pct, toUInt32(toYYYYMMDD(date))), 2) AS p90_move_pct,
    count()                                                                        AS sessions_count
FROM daily
WHERE date >= '2019-01-01'
GROUP BY year
ORDER BY year

In 2026, across 159 sessions, the median session moved 0.51% and the 90th percentile session moved 1.52%. The distance between those two figures is why a single-session index travels so far. Most days are quiet, a few are not, and an index built on today's expirations has to price both every morning.

FAQ

What does VIX1D measure?

VIX1D is Cboe's 1-Day Volatility Index. It measures the volatility the options market is pricing for the S&P 500 over the current trading day, calculated from SPX options expiring in that session, and it is published as an annualized percentage.

Is VIX1D the same as the VIX?

No. They share a method and a scale. The VIX measures a constant 30-day horizon and VIX1D measures the current session, so an identical level on each describes a different window of time.

Why does VIX1D not drop to zero at the close?

As the session runs down, the calculation time-weights the next session's expiration into the option strip. The measured horizon stays a full trading day forward, so the reading keeps describing a whole session instead of the minutes left on today's contracts.

How do I convert VIX1D into an expected move?

Divide the reading by 16, the square root of the roughly 252 trading days in a year. A reading of 20 works out to about 1.25% for the session, one standard deviation, which is $125 on a $10,000 position.

Can you trade VIX1D directly?

VIX1D is an index, a number calculated from option prices rather than a security with a bid and an offer. An index level and the price of any instrument referencing it are separate quantities, a gap taken apart in why VIX options do not track the VIX.

Every panel above carries the exact SQL that produced it, one expander away. To run the same measurement on a different symbol or a different session, ask for it in plain English on the Strasmore terminal.