In partnership with
Learn AI in 5 minutes a day
What’s the secret to staying ahead of the curve in the world of AI? Information. Luckily, you can join 1,000,000+ early adopters reading The Rundown AI — the free newsletter that makes you smarter on AI with just a 5-minute read per day.
🚀 Your Investing Journey Just Got Better: Premium Subscriptions Are Here! 🚀
It’s been 4 months since we launched our premium subscription plans at GuruFinance Insights, and the results have been phenomenal! Now, we’re making it even better for you to take your investing game to the next level. Whether you’re just starting out or you’re a seasoned trader, our updated plans are designed to give you the tools, insights, and support you need to succeed.
Here’s what you’ll get as a premium member:
Exclusive Trading Strategies: Unlock proven methods to maximize your returns.
In-Depth Research Analysis: Stay ahead with insights from the latest market trends.
Ad-Free Experience: Focus on what matters most—your investments.
Monthly AMA Sessions: Get your questions answered by top industry experts.
Coding Tutorials: Learn how to automate your trading strategies like a pro.
Masterclasses & One-on-One Consultations: Elevate your skills with personalized guidance.
Our three tailored plans—Starter Investor, Pro Trader, and Elite Investor—are designed to fit your unique needs and goals. Whether you’re looking for foundational tools or advanced strategies, we’ve got you covered.
Don’t wait any longer to transform your investment strategy. The last 4 months have shown just how powerful these tools can be—now it’s your turn to experience the difference.
The options market tells you what traders will pay to insure against a crash.
With the right methodology, you can turn these prices into a probability estimate for a major drop.
For example, given option’s market consensus, you can estimate:
“what is the probability of a 15% fall in the S&P 500 over the next 6 months.”
This article shows you how. We’ll discuss how to estimate risk-neutral crash odds using options and a proven technique from financial theory.
The complete Python notebook for the analysis is provided below for paid subs only.
1. How to Extract Implied Crash Probabilities
Implied crash probabilities show what the market believes about tail risk.
It can be used to estimate in real-time the probability traders assign to a severe selloff.
Why It Matters
Markets underreact or overreact to risks and relying on backward-looking data will miss shifts in sentiment.
Therefore, we need a foward looking measure to derive implied probabilities.
When crash risk rises, the options market shows it before headlines or economic releases.
Find your customers on Roku this Black Friday
As with any digital ad campaign, the important thing is to reach streaming audiences who will convert. To that end, Roku’s self-service Ads Manager stands ready with powerful segmentation and targeting options. After all, you know your customers, and we know our streaming audience.
Worried it’s too late to spin up new Black Friday creative? With Roku Ads Manager, you can easily import and augment existing creative assets from your social channels. We also have AI-assisted upscaling, so every ad is primed for CTV.
Once you’ve done this, then you can easily set up A/B tests to flight different creative variants and Black Friday offers. If you’re a Shopify brand, you can even run shoppable ads directly on-screen so viewers can purchase with just a click of their Roku remote.
Bonus: we’re gifting you $5K in ad credits when you spend your first $5K on Roku Ads Manager. Just sign up and use code GET5K. Terms apply.
The Theory
This approach uses a key result from options pricing:
You can extract the market’s entire probability distribution for future prices from the shape of option prices across strikes.
Breeden-Litzenberger Formula
For this, we use the Breeden-Litzenberger formula:
Here, f(K) is the risk-neutral probability density at strike K, C is the call price, r is the risk-free rate, and T is time to expiration.
The second derivative with respect to strike translates the curve of call prices into an implied probability distribution.
This distribution reflects the market’s collective expectations, under the risk-neutral measure, of where the underlying asset could settle at expiry.
Put-Call Parity (for Consistency)
To construct a smooth call price curve, put-call parity allows conversion between put and call prices:
P(K): European put price at strike K
S0: Current spot price
Crash Probability Integration
Once you have the risk-neutral density, the probability of a crash (terminal price falling below the crash threshold Kcrash) is:
Kcrash=(1−p)⋅S0, where p is the desired crash percentage (e.g. 0.15 for a 15% drop).
How to Do It and Steps Involved
Gather Option Prices: Collect out-of-the-money call and put prices for a chosen expiry. Clean the data to remove illiquid or unreliable quotes.
Standardize Prices: Convert all quotes to equivalent call prices using put-call parity. This ensures a smooth, continuous set of data across strikes.
Smooth the Curve: Fit a cubic spline to the stitched call price data. This step reduces noise and enables stable differentiation.
Compute the Risk-Neutral Density: Take the second derivative of the spline-fitted price curve. Apply the Breeden-Litzenberger adjustment for discounting.
Calculate Crash Probability: Integrate the risk-neutral density from zero up to the “crash strike”. The result is the market-implied odds of that drop or worse by expiry.
2. Extracting Crash Odds in Python
Step 1: Set Your Parameters
Let’s start by setting the parameters in one place.
A few are self-explanatory (e.g. ticker, crash percent).
Here’s what matters for the less obvious controls:
SMOOTH_S: This sets how aggressively the spline smooths the fitted option price curve. A higher value forces the spline to ignore more local noise, creating a gentler, less jagged curve. This makes the second derivative more stable but may flatten out real features in the price data.
DX: This is the spacing between strike prices in the numerical grid for density calculations. Smaller DX means more points, higher resolution, and smoother-looking results, but it slows down computation.
N_SAMPLES: This is the number of simulated prices you draw from the risk-neutral density for the histogram plot. More samples yield a more reliable histogram at the cost of computation time and memory.
import numpy as np
import pandas as pd
import yfinance as yf
from scipy.interpolate import UnivariateSpline
from scipy.integrate import trapezoid
import matplotlib.pyplot as plt
TICKER = "SPY" # Underlying ticker (e.g., "AAPL", "QQQ")
TARGET_MONTHS = 6 # Expiry horizon in months (higher = longer-term risk)
CRASH_PCT = 0.10 # Crash threshold as percent drop (higher = deeper crash)
RISK_FREE = 0.04 # Annual risk-free rate (affects discounting)
SMOOTH_S = 1e4 # Spline smoothness (higher = smoother fit)
DX = 1.0 # Strike grid step (lower = finer detail)
BID_ASK_MAX = 1.5 # Max bid-ask spread allowed (lower = stricter filtering)
MIN_BID = 0.05 # Minimum mid-quote (higher = exclude cheap, illiquid options)
N_SAMPLES = 40000 # Simulated samples (higher = smoother histogram)Step 2: Select Expiry and Fetch Option Chain
Select the expiry closest to the target maturity and download the option chain. The function below does that based on the target_months param.
def pick_expiration(tkr: yf.Ticker, target_months: float) -> str:
today = pd.Timestamp.today().normalize()
best = None
best_diff = 1e9
for exp in tkr.options:
dt = pd.to_datetime(exp)
if dt <= today:
continue
days = (dt - today).days
months = days / 30.4375
diff = abs(months - target_months)
if diff < best_diff:
best_diff = diff
best = exp
if best is None:
raise ValueError("No valid expirations found.")
return best
tkr = yf.Ticker(TICKER)
expiry = pick_expiration(tkr, TARGET_MONTHS)
chain = tkr.option_chain(expiry)Step 3: Get Spot Price and Time to Expiry
Get the spot price and calculate the expiry horizon in years and months.
S0 = tkr.history(period="1d")["Close"].iloc[-1]
today = pd.Timestamp.today()
dt_exp = pd.to_datetime(expiry)
days = (dt_exp - today).days
T = max(days, 1) / 365.0
months = days / 30.4375200+ AI Side Hustles to Start Right Now
AI isn't just changing business—it's creating entirely new income opportunities. The Hustle's guide features 200+ ways to make money with AI, from beginner-friendly gigs to advanced ventures. Each comes with realistic income projections and resource requirements. Join 1.5M professionals getting daily insights on emerging tech and business opportunities.
Step 4: Clean Option Quotes and Build OTM Call Grid
This step filters noisy market data and constructs a consistent, liquid set of OTM call prices across strikes.
Clean inputs are very important for a stable risk-neutral density.
Next, we convert OTM puts to their equivalent call values (via put-call parity), to get a continuous set of option prices.
def clean(df: pd.DataFrame) -> pd.DataFrame:
df = df.copy()
df["mid"] = np.where(
(df["bid"] > 0) & (df["ask"] > 0),
0.5 * (df["bid"] + df["ask"]),
np.nan
)
spread = (df["ask"] - df["bid"]) / np.where(df["mid"] > 0, df["mid"], np.nan)
out = (
df[(df["mid"] >= MIN_BID) & (spread < BID_ASK_MAX)]
.loc[:, ["strike", "mid"]]
.dropna()
.sort_values("strike")
.reset_index(drop=True)
)
return out
def parity_put_to_call(put_mid: float, K: float, S0: float, r: float, T: float) -> float:
return put_mid + S0 - K * np.exp(-r * T)
def build_otm_calls(chain, S0, r, T):
calls_raw = clean(chain.calls)
puts_raw = clean(chain.puts)
calls_otm = calls_raw[calls_raw["strike"] >= S0].copy()
puts_otm = puts_raw[puts_raw["strike"] < S0].copy()
if not puts_otm.empty:
puts_otm["mid"] = puts_otm.apply(
lambda row: parity_put_to_call(row["mid"], row["strike"], S0, r, T), axis=1
)
merged = pd.concat([puts_otm, calls_otm]).sort_values("strike").reset_index(drop=True)
return merged["strike"].values, merged["mid"].values
strikes, prices = build_otm_calls(chain, S0, RISK_FREE, T)
if len(strikes) < 5:
raise ValueError("Not enough OTM quotes after cleaning.")Step 5: Fit a Cubic Spline to Call Prices
Noisy or gapped option prices produce unstable derivatives.
A cubic spline creates a smooth, twice-differentiable curve through the cleaned call price grid.
The SMOOTH_S parameter controls how closely the spline fits the data.
def smooth_spline(strikes, prices, s_val):
fixed = prices.copy()
for i in range(1, len(fixed)):
if fixed[i] > fixed[i-1]:
fixed[i] = fixed[i-1]
return UnivariateSpline(strikes, fixed, s=s_val, k=3)
sp = smooth_spline(strikes, prices, SMOOTH_S)Step 6: Compute the Risk-Neutral Density
Now extract the market-implied probability distribution for future prices using the fitted spline.
Take the second derivative of the spline-fitted call price curve, then scale by the discount factor.
This implements the Breeden-Litzenberger formula:
sp.derivative(n=2)(k_grid): Numerically estimates the curvature of call prices across strikes, giving sensitivity to extreme moves.
np.exp(r * T): Applies the risk-neutral discount for time value.
q[q < 0] = 0.0: Sets negative densities to zero as these are numerical artifacts, not real probabilities.
Normalization: Ensures total integrated probability is exactly one.
def density_from_spline(sp, k_grid, r, T):
second = sp.derivative(n=2)(k_grid)
q = np.exp(r * T) * second
q[q < 0] = 0.0
return q
k_grid = np.arange(strikes.min(), strikes.max(), DX)
q = density_from_spline(sp, k_grid, RISK_FREE, T)
integral = trapezoid(q, k_grid)
q /= integral # Normalize
total_prob = trapezoid(q, k_grid)Step 7: Calculate the Crash Probability
Integrate the risk-neutral density up to the crash threshold to get the market-implied probability of a large drop by expiry.
Crash threshold:
For example, with a 15% crash and spot at 500, this is 425.
Formula:
f(K) is the risk-neutral density from Step 6.
Implementation:
Build a mask for all strikes less than or equal to the crash threshold.
Integrate the density over this range using the trapezoidal rule.
Output the crash probability and key summary statistics.
def crash_probability(k_grid, q, k_crash):
mask = k_grid <= k_crash
return trapezoid(q[mask], k_grid[mask])
k_crash = (1 - CRASH_PCT) * S0
p_crash = crash_probability(k_grid, q, k_crash)
print(f"Expiration: {expiry}")
print(f"∫q dK = {total_prob:.3f} (should be ~1)")
print(f"Spot: {S0:.2f}")
print(f"Crash strike: {k_crash:.2f}")
print(f"Risk-neutral crash prob: {p_crash:.2%}")
print(f"Days to expiration: {months:.2f} months ({days} days)")Expiration: 2026-01-30
∫q dK = 1.000 (should be ~1)
Spot: 627.97
Crash strike: 565.17
Risk-neutral crash prob: 6.30%
Days to expiration: 5.82 months (177 days)Step 8: Simulate the Terminal Price Distribution
Sample possible expiry prices based on the risk-neutral density.
This creates a histogram to visualize the full range of market-implied outcomes.
Why simulate?
The density f(K) tells you the probability of each possible terminal price, but a histogram makes the distribution and crash region easier to interpret.
How it works:
Convert the continuous density into a discrete probability mass function (PMF) over the strike grid:
Normalize the PMF so it sums to one.
Draw N_SAMPLES random terminal prices from k_grid, using this PMF as the probability of each strike.
width = k_grid[1] - k_grid[0]
pmf_raw = q * width
pmf = pmf_raw / pmf_raw.sum()
samples = np.random.choice(k_grid, size=N_SAMPLES, p=pmf)Step 9: Three Plots to Show Everything
Finally, plot the results:
# plots
fig, axes = plt.subplots(3, 1, figsize=(16, 12))
# subplot 1: call prices
k_dense = np.linspace(strikes.min(), strikes.max(), 400)
axes[0].scatter(strikes, prices, s=15, label="OTM mids")
axes[0].plot(k_dense, sp(k_dense), lw=1.2, label="spline")
axes[0].axvline(S0, ls="--", lw=0.8, color="cyan", label="spot $S_0$")
axes[0].axvline(k_crash, ls="--", lw=0.8, color="red", label="crash $K$")
# title with expiry, T, spot, crash strike & pct drop
axes[0].set_title(
f"{TICKER} call prices ({expiry}, T={months:.2f} mo ({days} d), "
f"S₀={S0:.2f}, K₍crash₎={k_crash:.2f} (-{CRASH_PCT:.0%}))"
)
# annotate percent drop at crash strike
ymax = axes[0].get_ylim()[1]
axes[0].text(
k_crash, ymax * 0.85,
f"-{CRASH_PCT:.0%}",
rotation=90, va="center", ha="right",
color="red", fontsize=9,
bbox=dict(facecolor="#222222", edgecolor="none", alpha=0.7)
)
axes[0].set_ylabel("Call price")
axes[0].legend(frameon=False)
# subplot 2: risk-neutral density
axes[1].plot(k_grid, q, lw=1)
axes[1].fill_between(k_grid, 0, q, where=(k_grid <= k_crash), alpha=0.3, color="red")
axes[1].axvline(k_crash, ls="--", lw=0.8, color="red")
axes[1].axvline(S0, ls="--", lw=0.8, color="cyan")
axes[1].text(
0.98, 0.95,
f"P_crash = {p_crash:.2%}\n∫q dK = {total_prob:.3f}",
transform=axes[1].transAxes,
va="top", ha="right", fontsize=9,
bbox=dict(facecolor="#222222", edgecolor="#444444", alpha=0.8)
)
axes[1].set_title("Risk-neutral density $f(S_T)$")
axes[1].set_ylabel("Density")
axes[1].set_xlabel("Terminal price")
# subplot 3: simulated terminal distribution
bins = 50
hist_vals, bin_edges = np.histogram(samples, bins=bins, density=True)
centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
width = centers[1] - centers[0]
axes[2].bar(centers, hist_vals, width=width, alpha=0.4, label="RN sample")
mask = centers <= k_crash
axes[2].bar(
centers[mask], hist_vals[mask], width=width,
color="red", alpha=0.6,
label=f"Crash region ({p_crash:.2%})"
)
axes[2].axvline(k_crash, ls="--", lw=0.8, color="red")
axes[2].axvline(S0, ls="--", lw=0.8, color="cyan")
axes[2].text(
0.98, 0.95,
f"S₀ = {S0:.2f}",
transform=axes[2].transAxes,
va="top", ha="right", fontsize=9,
bbox=dict(facecolor="#222222", edgecolor="#444444", alpha=0.8)
)
axes[2].set_title("Simulated terminal price distribution")
axes[2].set_xlabel("Terminal price")
axes[2].set_ylabel("Density")
axes[2].legend(frameon=False)
plt.tight_layout()
plt.show()
Figure 1. Market-implied crash risk from options pricing. Top: Fitted OTM call price curve with the crash threshold marked in red.Middle: Risk-neutral density, with the probability mass for a 10% or greater drop highlighted in red. Bottom: Simulated terminal price distribution, emphasizing the crash region and its risk-neutral probability.
3. Real-World Applications and Extensions
Market-implied crash probabilities have practical uses well beyond academic curiosity.
Risk Monitoring: Track market-implied crash odds daily or weekly. Spikes in the implied probability of a major drop often precede market stress.
Portfolio Hedging: Quantify what the market is charging for crash protection. If crash risk looks cheap relative to historical events, buying tail hedges may be more attractive.
Strategy Backtesting: Integrate real-time crash probability signals into allocation models. For example, scale down risk or add hedges when the market’s implied crash odds exceed a set threshold.
Comparing Across Assets and Time: Run the extraction on different tickers, sectors, or countries to spot where crash risk is highest or changing fastest.
Stress Testing and Scenario Analysis: Translate risk-neutral crash odds into scenarios. If the market implies a 7% chance of a 20% drop in six months, check how your portfolio responds under that scenario.
Extensions:
Multiple Expiries: Track the term structure of crash risk by repeating the process for several maturities.
Custom Thresholds: Adjust CRASH_PCT to extract probabilities for milder corrections or more extreme events.
Alternative Densities: Test other smoothing or interpolation methods (e.g. kernel density, piecewise polynomials) for robustness.
Real Probability Adjustments: Apply adjustments for risk premia to convert risk-neutral probabilities into subjective or “real-world” odds.
4. Limitations
We use mid‐quotes. That biases the density if bid/ask is wide.
We filter by spread and minimum bid. Good for cleanliness, but we lose strikes.
We apply a spline. That smooths noise but can distort tail behavior.
We force monotonicity. That avoids arbitrage kinks but may misstate local curvature.
We ignore dividends and early exercise. That shifts the forward price.
We assume a constant rate. Real rates can vary over months.
We derive risk‐neutral density, not real‐world density. Crash prob differs in practice.
We sample IID from the density. That skips path‐dependence and volatility dynamics.
We fix crash strike as (1–CRASH_PCT)·S₀. That ignores skew beyond available strikes.
We normalize the density. Good check, but edge effects can alter ∫q.
Concluding Thoughts
Risk-neutral crash probabilities won’t predict every selloff, but they show how much uncertainty the market is pricing in right now.
These numbers reflect crowd psychology as much as fundamental risk and shift before news or economic data does.
The full end-to-end workflow is available as a Google Colab notebook 👇
Subscribe to our premium content to get the full code snippet.
Become a paying subscriber to get access to this post and other subscriber-only content.
Upgrade