01. E-mini S&P 500 Options Data from Databento#
In this guide
One row is one contract’s settlement on one session. A strike, a right (call or put), an expiration, and a price the exchange assigns to every listed contract at every close, traded that day or not.
Each option is an option on a future. It exercises into an E-mini S&P 500 future, so the chain is read against that future’s price, which put-call parity recovers from the options themselves.
The exchange reaches the crash strikes. Pricing insurance against a 20% fall takes puts struck at 80% of today’s level or lower. The exchange settles puts that deep every day; a vendor’s standard surface, the usual academic data, stops near 92% and fills the rest by assumption. That reach is why this case study uses the exchange’s prices.
Everything in this case study starts from one table: the price of every listed option on the S&P 500 at the close of one session. This guide is about what that table is and how to read it, for readers who have not worked with futures before.
In HW 2 you pulled 30-Day Fed Funds futures from Databento’s CME Globex
feed. Options on futures come from the same feed, and the pull in
src/pull_es_options.py is written for you this time. What is new is the
data: options have a strike and an expiration, so one product is
thousands of contracts, and the price we want is not a trade but a
settlement.
The settlements come under the course’s Databento license, so these guides
show quantities computed from them (one price relative to another, implied
volatilities, probabilities) and never the prices themselves. Your own
pull has every one of them, in _data/es_options_settlements.parquet.
Sections
The future first.
Which options, and how to read a row.
What expires when.
Where the rows come from: settlements and definitions.
One expiration’s chain.
The smile, and the surface.
Where the strikes stop, which is the point of the whole exercise.
from pathlib import Path
import numpy as np
import pandas as pd
import figures
import monitor
import pull_es_options
import pull_fred
import smile
from settings import config
DATA_DIR = Path(config("DATA_DIR"))
pd.set_option("display.width", 120)
pd.set_option("display.max_columns", 20)
options = pull_es_options.load_es_options()
futures = pull_es_options.load_es_futures()
fred = pull_fred.load_fred()
# The newest session the monitor computed a row for (a session it had to
# skip, a rare chain with too few usable strikes, is not shown here either).
computed = set(monitor.load_history()["date"]) & set(options["date"])
latest = max(computed) if computed else options["date"].max()
session = options[options["date"] == latest]
rate = pull_fred.rate_on(fred, latest)
curve = figures.futures_curve(futures, latest)
print(f"{len(options):,} option settlements over {options['date'].nunique()} sessions, "
f"{options['date'].min().date()} to {latest.date()}")
16,393 option settlements over 5 sessions, 2026-10-26 to 2026-10-30
1. The future first#
An E-mini S&P 500 future (CME root ES) is a contract to buy the S&P
500 index on a fixed future date at a price agreed today, at $50 per index
point. No money changes hands when the contract is opened. Instead, every
evening the exchange sets a settlement price for the contract and
moves the day’s gain or loss from one side’s account to the other’s. There
are four expirations a year, on the third Friday of March, June,
September, and December, and a symbol names its expiration with a month
code and the last digit of the year: ESZ6 is December 2026. Here are
the nearest listed contracts at the close of the latest session, each
priced relative to the nearest one (the figure below has all of them):
curve[["symbol", "contract month", "expiration", "days to expiration", "above the nearest (%)"]].head(6).round(2)
| symbol | contract month | expiration | days to expiration | above the nearest (%) | |
|---|---|---|---|---|---|
| 0 | ESZ6 | Dec 2026 | 2026-12-18 | 49 | 0.00 |
| 1 | ESH7 | Mar 2027 | 2027-03-19 | 140 | 0.97 |
| 2 | ESM7 | Jun 2027 | 2027-06-18 | 231 | 1.98 |
| 3 | ESU7 | Sep 2027 | 2027-09-17 | 322 | 3.03 |
| 4 | ESZ7 | Dec 2027 | 2027-12-17 | 413 | 4.16 |
| 5 | ESH8 | Mar 2028 | 2028-03-17 | 504 | 5.22 |
figures.fig_futures_curve(curve, latest, underlyings=session["underlying"].unique()).show()
first, second = curve.iloc[0], curve.iloc[1]
carry = np.log(second["settlement"] / first["settlement"]) / ((second["expiration"] - first["expiration"]).days / 365)
print(f"From {first['symbol']} to {second['symbol']}, the curve rises at {100 * carry:.1f}% a year; "
f"the one-month Treasury yield is {100 * rate:.1f}%")
From ESZ6 to ESH7, the curve rises at 3.9% a year; the one-month Treasury yield is 4.1%
Takeaway. Longer-dated futures settle higher. Agreeing today to buy the index later, instead of buying it now, keeps your cash earning interest and gives up the dividends, so a future’s price is the index carried forward at the interest rate less the dividend yield. The options in this case study exercise into the first few of these contracts (in blue).
Stop and discuss
The contract five years out settles well above the nearest one. Is that the market forecasting that stocks will rise that much? What would have to change for the curve to slope down?
2. Which options, and how to read a row#
CME lists several families of options on the E-mini future. The quarterly
options expire with the future itself, in the morning, and are
American-style. The end-of-month options (root EW) are
European-style and settle at 4:00 p.m. ET, like the SPX options the
academic literature uses. They give an expiration at the end of every
month about seven months out, and then quarterly, which is enough to
bracket a 30-day horizon on every session. That is what we pull.
An option symbol extends a future’s: EWX6 P6900 is root EW, month code
X (November), year digit 6, a put struck at 6,900. A put is
the right to sell, at the strike, and a call the right to buy. Prices are
in index points, like the future’s, at 50 dollars a point.
Here is the decoding for a few of the latest session’s contracts, with the
expiration and the future each one exercises into, which the symbol does
not say:
month_expiry = smile.closest_expiry(session) # the expiration closest to 30 days
chain = session[session["expiration"] == month_expiry]
surface = smile.surface_from_chain(chain, rate)
forward = surface["forward"].iloc[0]
def nearest(expiration, flag, moneyness):
"""The listed contract closest to a given strike, as a fraction of the forward."""
rows = session[(session["expiration"] == expiration) & (session["cp_flag"] == flag)]
return rows.iloc[(rows["strike"] - moneyness * forward).abs().argmin()]
expirations = sorted(session["expiration"].unique())
examples = pd.DataFrame([nearest(month_expiry, "P", 0.90), nearest(month_expiry, "C", 1.03),
nearest(expirations[0], "P", 1.00), nearest(expirations[-1], "P", 0.80)])
decoded = pd.DataFrame([figures.decode_symbol(s, latest) for s in examples["symbol"]])
decoded[["expiration", "underlying future"]] = examples[["expiration", "underlying"]].to_numpy()
decoded
| symbol | root | month code | contract month | right | strike | expiration | underlying future | |
|---|---|---|---|---|---|---|---|---|
| 0 | EWX6 P6850 | EW | X | Nov 2026 | put | 6850.0 | 2026-11-30 | ESZ6 |
| 1 | EWX6 C7850 | EW | X | Nov 2026 | call | 7850.0 | 2026-11-30 | ESZ6 |
| 2 | EWV6 P7615 | EW | V | Oct 2026 | put | 7615.0 | 2026-10-30 | ESZ6 |
| 3 | EWH8 P6100 | EW | H | Mar 2028 | put | 6100.0 | 2028-03-31 | ESM8 |
put = examples.iloc[0]
print(f"Read aloud: {put['symbol']} is the right to sell one {put['underlying']} future at {put['strike']:,.0f} "
f"on {put['expiration']:%B} {put['expiration'].day}, {put['expiration']:%Y}.")
Read aloud: EWX6 P6850 is the right to sell one ESZ6 future at 6,850 on November 30, 2026.
And this is what the table itself looks like: one row per contract per
session, after the pull has joined the price to the contract’s terms. The
price is the settle column, left out here.
chain.drop(columns="settle").sort_values(["strike", "cp_flag"]).iloc[len(chain) // 2:len(chain) // 2 + 6]
| date | symbol | instrument_id | expiration | days_to_expiry | strike | cp_flag | underlying | |
|---|---|---|---|---|---|---|---|---|
| 13880 | 2026-10-30 | EWX6 P7100 | 42807876 | 2026-11-30 | 31 | 7100.0 | P | ESZ6 |
| 13881 | 2026-10-30 | EWX6 C7125 | 43061252 | 2026-11-30 | 31 | 7125.0 | C | ESZ6 |
| 13882 | 2026-10-30 | EWX6 P7125 | 43062132 | 2026-11-30 | 31 | 7125.0 | P | ESZ6 |
| 13883 | 2026-10-30 | EWX6 C7150 | 42791061 | 2026-11-30 | 31 | 7150.0 | C | ESZ6 |
| 13884 | 2026-10-30 | EWX6 P7150 | 42814250 | 2026-11-30 | 31 | 7150.0 | P | ESZ6 |
| 13885 | 2026-10-30 | EWX6 C7175 | 43060802 | 2026-11-30 | 31 | 7175.0 | C | ESZ6 |
3. What expires when#
Each end-of-month option exercises into the nearest quarterly future that expires after it does. In the figure, each row is a future: the diamond is the future’s own expiration, and the dots are the option expirations that exercise into it. Hover for the details.
figures.fig_expiration_calendar(session, curve, latest).show()
Takeaway. On every session, one option expiration falls inside 30 days and the next one beyond it (in red). The monitor computes SVIX for both and interpolates to exactly 30 days, as the VIX does. The table has the same information, with the strike range listed for each expiration:
(session.groupby("expiration")
.agg(days_to_expiry=("days_to_expiry", "first"), contracts=("symbol", "size"),
strikes=("strike", "nunique"), underlying=("underlying", "first"),
lowest_strike=("strike", "min"), highest_strike=("strike", "max")))
| days_to_expiry | contracts | strikes | underlying | lowest_strike | highest_strike | |
|---|---|---|---|---|---|---|
| expiration | ||||||
| 2026-10-30 | 0 | 407 | 407 | ESZ6 | 100.0 | 10800.0 |
| 2026-11-30 | 31 | 330 | 165 | ESZ6 | 100.0 | 10800.0 |
| 2026-12-31 | 62 | 358 | 179 | ESH7 | 100.0 | 11200.0 |
| 2027-01-29 | 91 | 330 | 165 | ESH7 | 100.0 | 11200.0 |
| 2027-02-26 | 119 | 222 | 111 | ESH7 | 1600.0 | 11200.0 |
| 2027-03-31 | 152 | 250 | 125 | ESM7 | 1400.0 | 11200.0 |
| 2027-04-30 | 182 | 216 | 108 | ESM7 | 1600.0 | 11200.0 |
| 2027-06-30 | 243 | 252 | 126 | ESU7 | 1400.0 | 11400.0 |
| 2027-09-30 | 335 | 254 | 127 | ESZ7 | 1400.0 | 11400.0 |
| 2027-12-31 | 427 | 236 | 118 | ESH8 | 1600.0 | 11600.0 |
| 2028-03-31 | 518 | 230 | 115 | ESM8 | 1800.0 | 11600.0 |
4. Where the rows come from: settlements and definitions#
A daily bar (ohlcv-1d, the schema HW 2 used) exists for a contract only
on a day it traded, and most listed strikes do not trade on most days.
What exists for every listed contract every day is the exchange’s
settlement price: the value CME assigns at the close to mark positions,
from the quotes near the money and a model in the wings. It is in
Databento’s statistics schema, as one record type among several
(stat_type 3; the schema also carries open interest, the session high
and low, and others), published twice a day, a preliminary and a final;
the pull keeps the final. The query has the four parameters you know from
HW 2:
pull_es_options.build_queries("2026-10-15", "2026-10-16")["option_statistics"]
{'dataset': 'GLBX.MDP3',
'symbols': ['EW.OPT'],
'stype_in': 'parent',
'start': '2026-10-15',
'end': '2026-10-16',
'schema': 'statistics'}
A statistics record names its contract by instrument_id and symbol,
not by its expiration or strike. The definition schema has those terms,
republished every day for every listed contract, so the pull joins the
same day’s definitions on instrument_id. Parent-symbol queries also
return user-defined spreads, multi-leg strategies traders register during
the day; their instrument_class is not C or P, and they are dropped.
5. One expiration’s chain#
Take the expiration closest to 30 days. Buy the call and sell the put at the same strike \(K\), and at expiration you hold the future’s price less \(K\), whatever the future does. So the call’s price less the put’s is the value today of that forward position. Plot it at every strike. Hover over a point to read it.
future_settle = curve.set_index("symbol").loc[chain["underlying"].iloc[0], "settlement"]
figures.fig_parity(chain, forward, rate).show()
print(f"The parity-implied forward is {forward - future_settle:+.2f} index points from the "
f"{chain['underlying'].iloc[0]} future's own settlement")
The parity-implied forward is +0.04 index points from the ESZ6 future's own settlement
Takeaway. The points fall on a straight line,
\(C - P = e^{-r\tau}(F - K)\): put-call parity. Calls lose value and puts
gain value as the strike rises, and they cost the same where the strike
equals the forward, so the line crosses zero there. The forward it implies
from the options alone matches the future’s own settlement almost to the
point. smile.parity_forward computes it; the engine uses it as the
underlying price.
Stop and discuss
Why do calls fall and puts rise as the strike rises? If the parity-implied forward were 50 points away from the future’s settlement, what would you suspect about the data?
6. The smile, and the surface#
A price is hard to compare across strikes; an implied volatility is not.
smile.surface_from_chain inverts each out-of-the-money settlement, puts
below the forward and calls above it, to the volatility that makes the
Black-76 formula return it (the black_scholes module explains the
formula for options on a future). The strike becomes moneyness,
\(k = K / S\), so that a strike and a gross return are the same number: a
20% drop is \(k = 0.8\).
Not every settlement is usable. CME’s smallest price increment is 0.05
index points, and a far out-of-the-money option that settles at 0.05 is
marked at a floor, not priced; inverting it would give a meaningless
volatility. The pull keeps those rows, since they are what the exchange
published, and surface_from_chain drops them (the grey crosses).
figures.fig_smile(chain, surface, rate).show()
Takeaway. The smile is a smirk: out-of-the-money puts are dearer, in volatility terms, than out-of-the-money calls, because a market fall is what investors insure against. And the exchange settles puts far below a 20% drop, in the shaded region where a vendor’s standard surface has no strikes at all.
Stop and discuss
Who buys a put struck 20% below the market, and who sells it? Why would the seller demand a price that implies a volatility twice the at-the-money one?
Every usable expiration of the same session gives a smile; stacked by days to expiration, they form the volatility surface. Drag to rotate it, and hover for any point.
figures.fig_surface(options, session, latest, rate).show()
Takeaway. The smirk is steepest for the shortest expirations and flattens with time: insurance against a sudden fall is priced dearest over the next few weeks.
7. Where the strikes stop#
This is the reason the case study uses the exchange’s prices. A 20% drop means the index ends at 0.80 of today’s level. Insurance against it is a put struck at 0.80 or below, so a probability of a crash needs prices there.
The standard academic source is OptionMetrics’ volatility surface (the data of guide 04). The vendor fits each day’s smile at fixed deltas, and its deepest point is the 10-delta put, a put with about a one-in-ten chance of finishing in the money. Below that strike the vendor has no data, and the usual convention, Martin and Shi’s Appendix D among them, holds the volatility flat. The figure puts that assumption next to what the exchange actually settles, on this session’s smile:
figures.fig_flat_extrapolation(surface, rate).show()
flat = figures.flat_extrapolation(surface, rate)
print(f"The 10-delta put is at k = {flat['k10']:.3f}. At k = 0.80 the exchange's settlements imply a volatility of "
f"{100 * flat['vol_actual']:.1f}%; the flat assumption, {100 * flat['vol_flat']:.1f}%.")
print(f"Priced at those volatilities, the 0.80 put costs {flat['ratio']:.0f} times less under the flat assumption "
f"than as settled.")
The 10-delta put is at k = 0.919. At k = 0.80 the exchange's settlements imply a volatility of 39.4%; the flat assumption, 24.1%.
Priced at those volatilities, the 0.80 put costs 87 times less under the flat assumption than as settled.
Takeaway. Below the vendor’s last strike, holding the volatility flat prices the deep puts far too cheaply, and so understates the probability of a crash. The exchange’s settlements show what those puts actually cost.
Stop and discuss
Guide 02 reads the probability of a crash off exactly these deep puts. Which way does the flat assumption bias it? Would you expect the bias to be larger in calm markets or in a crisis?
And it is not one lucky session. On every session in the pull, the exchange settled a dozen or more usable puts below the crash threshold:
rows = []
for d, day in options.groupby("date"):
try:
near_d, _ = smile.bracketing_expiries(day)
s = smile.surface_from_chain(day[day["expiration"] == near_d], pull_fred.rate_on(fred, d))
puts = s[s["cp_flag"] == "P"]
rows.append({"date": d.date(), "days": int(s["days_to_maturity"].iloc[0]),
"deepest usable put (K/S)": puts["moneyness"].min(),
"puts below K/S = 0.80": int((puts["moneyness"] <= 0.80).sum())})
except ValueError:
continue
pd.DataFrame(rows).set_index("date")
| days | deepest usable put (K/S) | puts below K/S = 0.80 | |
|---|---|---|---|
| date | |||
| 2026-10-26 | 35 | 0.364383 | 36 |
| 2026-10-27 | 34 | 0.388168 | 37 |
| 2026-10-28 | 33 | 0.412657 | 37 |
| 2026-10-29 | 32 | 0.440036 | 35 |
| 2026-10-30 | 31 | 0.369012 | 34 |
Notes on the discussion questions
The futures curve. No. A future’s price is set by carry, not by a forecast. Buying the future instead of the index leaves your cash earning interest and gives up the dividends, so the future is the index grown at the interest rate less the dividend yield, \(F = S e^{(r - q)T}\). If it were any higher, borrowing to buy the index and selling the future would lock in a riskless profit. The expected return on stocks appears nowhere in that formula. The curve slopes down when the dividend yield is above the interest rate, as it was when short rates sat near zero in 2020 and 2021.
Calls, puts, and parity. A call is the right to buy at the strike, so a higher strike pays less in every state; a put is the right to sell, so a higher strike pays more. Parity is an arbitrage relation, so a forward 50 points off the future’s settlement means the data are wrong, not the market: a contract joined to the wrong future or expiration, a preliminary settlement kept instead of the final, or a rate or time to expiration that is off. That makes the parity check a cheap test of the whole pull.
Who buys and who sells deep puts. Buyers are investors who hold the market and want insurance against a crash: pension funds, asset managers, insurers, tail-risk funds. Sellers are dealers and funds that collect the premium. The seller loses exactly when everyone else does, when capital is scarcest, and cannot hedge the loss smoothly, because prices jump in a crash. Demand for the insurance is steady and willing sellers are few, so the price is high. The smirk is also a lesson the market learned: S&P 500 options showed little of it before the crash of October 1987, and a steep one ever since.
The flat assumption’s bias. Downward. Holding the volatility flat below the last strike prices the deep puts too cheaply, so the density puts too little weight on a crash, and every crash probability built from it, risk-neutral or real-world, comes out too small. The bias is largest in calm markets: with volatility low, the 10-delta put sits close to the money, and the whole stretch from there down to 0.80 is filled by assumption. In a crisis volatility is high, the 10-delta put moves far out, and less of the tail is extrapolated. Guide 04 sees exactly this pattern against Martin’s published series.