DEV Community: tomasz dobrowolski

I Backtested 96 SPY Put Credit Spread Strategies - Here's the Bug Log

tomasz dobrowolski — Wed, 29 Apr 2026 07:55:10 +0000

I built a backtest engine for SPY put credit spreads. 7 years of 1-minute option chains. 96 grid cells across (delta, DTE, profit-target, stop-loss). 16,024 trades that survived validation.

This post is the part most quant tutorials skip: the bugs, the lying simulators, and the one-line feature that humiliated my 3-layer composite signal. If you've ever shipped a backtest with great-looking numbers, you might want to read the bug log section.

The first lesson: mid-fill backtests are lying to you

The naive engine filled at the bid-ask mid. Numbers looked great. Then I implemented what an actual desk does - post a limit at combo_ask + $0.04, wait for someone to cross it, accept rejection - and CAGR dropped 30–60% across the entire grid. Several cells flipped from positive to negative.

Real fill stats from one run:

Run	Posted	Filled	Fill rate	Avg wait	Edge captured
45Δ 30 DTE PT 50% No stop	479	112	23.4%	12.4 min	−$0.04 to −$0.07
45Δ 30 DTE PT 50% SL 100%	633	155	24.5%	12.2 min	−$0.04 to −$0.07
45Δ 30 DTE PT 50% SL 200%	383	64	16.7%	13.3 min	−$0.04 to −$0.07

You fill ~20–25% of orders, after a ~12-minute wait, at 4–7 cents worse than mid. The MM doesn't make money at the fill - they make it over the hold, when theta beats realized vol. Any backtest filling at mid is silently gifting your strategy that 4–7 cents per trade.

If you remember nothing else from this post: build a real fill model.

The single biggest finding: SL=100% IS the strategy

Same cell. Same fills. Same period. Toggle the stop loss:

Configuration	Trades	Return	CAGR	MaxDD	Calmar
10Δ 7 DTE PT 50% No stop	-	−100%	wipeout	breaker	-
10Δ 7 DTE PT 50% SL 100%	460	+5,439%	+66.0%	30.1%	2.19
10Δ 7 DTE PT 75% SL 100%	360	+2,947%	+53.9%	31.1%	1.73
10Δ 7 DTE PT 25% SL 100%	649	+1,752%	+44.6%	30.2%	1.48

+5,439% with a stop. −100% without. Same cell.

A single bad Monday on a no-stop short-vol position takes the account to zero. The stop loss isn't a parameter you sweep - at short DTE it's the entire risk model.

The trap nobody warns you about: SL=200%

I expected SL=200% to be the sensible compromise. Looser than 100% so I don't get noise-stopped, tighter than no-SL so a tail doesn't kill me. Wrong:

SL setting	Trades	Return	CAGR	Sharpe	MaxDD
No stop	112	+30.6%	+3.8%	+0.23	30.1%
SL 100%	155	+28.0%	+3.5%	+0.22	29.3%
SL 200% ← trap	64	−16.5%	−2.5%	−0.17	31.2%

Both no-stop and SL=100% made money. SL=200% lost.

Mechanics: by the time the loss has grown to 200% of credit, you're deep ITM and gamma is doing the marking, not theta. You stop out at the worst possible price, on the worst possible day, after letting the position breathe past the point of recovery. SL=100% stops you before gamma takes over. No SL at least gives you the chance to be bailed out by a recovery.

Pick tight or pick none. Never the middle.

My fancy signal got beaten by a one-liner

I built a 3-layer composite - Premium / Danger / Stabilization scores, z-scored macro inputs, continuous Kelly multiplier. Then I ran t-tests across all 16,024 trades.

The strongest predictor in the entire feature set wasn't my composite. It was a single boolean flag on a free macro series - the kind of thing you write in three lines of pandas:

# pseudocode - the actual flag stays with me
signal_on = (macro_series.diff(5) < 0) & (macro_series < macro_series.rolling(20).mean())

t-stat over 8, on 5,000+ trades. Bonferroni-correct it across the entire feature space and it still wins.

The lesson generalizes: if your "edge" is a 47-feature gradient-boosted model, replace it with the most economically obvious single flag and check how much you actually lose. Often that flag does 80% of the work and your model is overfitting the residual.

Two related findings worth knowing:

The market pays the most right before it bites. Top-quintile VRP days had 66% winrate vs 74% baseline. By the time premium is that rich, something is actually wrong.
Don't sell into rising fear with an inverted term curve. Wait for the curve to normalize OR for the fear to fade. Either is fine. Both being wrong is the worst regime in the data.

Multi-DTE pooling cost me 9pp of CAGR

Seemed obvious: instead of committing to one tenor, rank candidates across 30/45/60-DTE chains every entry, pick the best EV-per-dollar-at-risk:

Tenor selection	Trades	Return	CAGR	Sharpe	MaxDD
Pool 30/45/60 DTE No stop	112	+30.6%	+3.8%	+0.23	30.1%
Pool 30/45/60 DTE SL 100%	155	+28.0%	+3.5%	+0.22	29.3%
Focused 30 DTE No stop	82	+70%	+12.5%	+0.72	27.5%

The ranker correctly picked 30-DTE ~68% of the time. The other ~32% it picked 45-DTE specifically because the 30-DTE chain looked worse than usual that bar - which is the textbook definition of adverse selection.

More degrees of freedom = more ways for the optimizer to be wrong, not more ways to be right.

The bug log

This is the part most quant blogs skip. Every one of these bugs would have inflated the headline numbers. Most were caught only after a code review:

Bug	What it did	Damage
Mid-fill assumption	Filled at bid-ask average always	Flipped multiple losing strategies positive
Look-ahead in signal	Day-D signal used end-of-D data at 10:05 AM entry	Inflated CAGR ~5–10pp on most cells
Stale-quote acceptance	"Fills" at quotes that were no longer real liquidity	~30% of fills had negative edge captured
EV-sorted tiebreak	Higher-EV candidate "filled" first when two crossed same bar	Subtle but real per-trade lift
Warmup sizing bug	Full Kelly applied before signal had any history	Cratered 2018 results
Validation walk-back mismatch	Validator used exact-date lookup, engine walked back 7 days	Bogus regression stats on weekend dates
Walk-the-limit (rejected)	Drop limit a penny each minute if unfilled	Caught before merge - adverse selection

The pre-fix engine on the same data returned −1% to −8% CAGR across every cell. So when post-fix numbers turned positive, that wasn't simulator noise - it was what the bias was masking.

If your backtest looks great on the first run, you have a bug. Find it.

The sizing layer

SIZING = {
    "kelly_default": 0.05,         # half-Kelly, conservative on purpose
    "kelly_max": 0.25,
    "kelly_f_hard_cap": 1.0,       # leveraged math can multiply to 1.25 without it
    "drawdown_breaker_pct": 0.30,  # halts the run, not the position
    "absolute_floor_pct": 0.50,    # secondary backstop
    "warmup_multiplier": 0.0,      # cratered 2018 when this was 1.0
    "vrp_on_mult": 1.0,            # 2.5 in the leveraged stress test
}

Half-Kelly is conservative on purpose. Mean-variance Kelly assumes Gaussian returns; short-vol returns are skewed left with fat tails. The "true" Kelly under fat tails is below the mean-variance Kelly, so half-Kelly isn't lazy - it's roughly correct.

The 30% drawdown breaker doesn't reduce position size or pause for a day. It halts the entire run. If your strategy needs 30% drawdown to work, you don't have a strategy, you have a martingale.

TL;DR

Mid-fill backtests overstate CAGR by 30–60%. Build a real fill model.
Stop loss at 100% of credit IS the game at short DTE. +5,400% with, −100% without.
SL=200% is worse than no stop. Pick tight or pick none.
The strongest signal in 16k trades was a one-line boolean flag.
Multi-DTE pooling cost 9pp of CAGR. Adverse selection.
Higher delta moves equity vol, not alpha.
The market pays the most right before it bites.
If your backtest looks great on the first run, find the bug.

The full write-up with all 96 cells, the leveraged stress preset, and where the Calmar-leader cell sits in the grid is on FlashAlpha: original article.

The actual constraint on reproducing this isn't the engine (the engine is bookkeeping) - it's having minute-resolution SPY chains going back to 2018 with surface-consistent IVs. That's what FlashAlpha's Alpha tier historical API is for.

SPXW 0DTE: What Every Developer Building Options Tools Needs to Know

tomasz dobrowolski — Wed, 29 Apr 2026 07:54:51 +0000

If you've built anything involving options data, you've probably noticed that "SPX 0DTE" is everywhere on fintwit, Discord, and trading blogs. The thing most guides gloss over is that plain SPX doesn't actually have same-day expirations every day. What everyone means when they say "SPX 0DTE" is SPXW — a different ticker with different settlement and different Greeks behavior.

I build an options analytics API, and the distinction matters enough that every developer touching options data should understand it before their dashboard lies to them.

SPX, SPXW, XSP — the one that's actually 0DTE

Three S&P 500 option tickers trade on Cboe. Only one gives you same-day expirations every trading day:

Ticker	Listing cadence	Settlement	Contract size
SPX	Third-Friday AM expirations	AM cash-settled	$100 × index
SPXW	Mon/Tue/Wed/Thu/Fri PM expirations	PM cash-settled	$100 × index
XSP	Mon-Fri PM	PM cash-settled	$10 × index

Plain SPX has no Monday, Tuesday, Wednesday, or Thursday expirations. Only the monthly AM-settled contract. SPXW is where the daily 0DTE volume lives.

Two consequences for anyone modeling it:

No assignment risk. SPXW is European-style and cash-settled. An SPXW put closing $0.05 ITM at 4:00 PM pays cash, not stock. You don't need early-exercise logic in your code.
Cleaner Greeks at close. SPY 0DTE gets fuzzy near 4:00 PM because ITM American contracts can be assigned overnight. SPXW doesn't have that problem — the Greeks you compute at 3:55 PM describe the remaining five minutes exactly.

This is also why SPXW tends to have higher 0DTE gamma concentration than SPY on comparable volume. European-style means every open contract contributes to hedging flow right through 4:00 PM instead of melting off via early exercise.

Why it moves the tape

The mechanical reason is identical to any 0DTE, just larger scale. At-the-money gamma scales as:

Γ_ATM ≈ 1 / (S · σ · √(2π · T))

When T is measured in hours instead of weeks, ATM gamma is 3-10x higher than equivalent weekly contracts, and 10x+ in the final 30 minutes. Dealers short that gamma trade exponentially more shares for the same percentage move in the index.

On a $6,000 SPX with $200B+ in SPXW open interest, this isn't a retail phenomenon. These hedging flows can dominate entire afternoon sessions.

The gamma flip is the switch

Above the 0DTE gamma flip, dealers are net long gamma. They sell into rallies, buy into dips, dampen ranges. Below the flip, they amplify — a routine 20-point oscillation becomes a 60-point move.

The part that burns people: the flip moves intraday. A flip at $5,950 at 10 AM can slide to $5,935 by 2 PM as 0DTE positions decay and roll. A static GEX chart from yesterday's close is worse than useless — you need the current session's 0DTE aggregate.

The four numbers that actually matter

If you're building a 0DTE dashboard, these four values are the entire point:

Gamma regime — positive_gamma or negative_gamma for the session
Pin score (0-100) — probability price gets magnetised to a strike by 4 PM. Composite of OI concentration, magnet proximity, time remaining, and gamma magnitude
Remaining expected move (1σ) — how far price can credibly travel before close. Shrinks in real time — a $40 expected move at 10 AM is a $12 expected move at 2:30 PM
Dealer hedging at ±0.5% — estimated shares dealers must buy or sell for a half-percent move. Absolute value tells you how sharp intraday reactions will be

Read together:

Regime	Pin score	Expected move	Implication
Positive	>70	Small	Classic pin day — range-bound, fade extremes
Positive	<40	Medium	No pin, dampened — drift toward magnet, no breakout
Negative	Any	Large	Trend day risk — dealers amplify, buy breakouts
Negative	Transitioning	Large, widening	Gamma flip breach incoming — highest-risk setup

These combinations replace 80% of the chart patterns most 0DTE traders reach for. Not a crystal ball — a statement about which way dealer hedging flows will push, which is the structural component every chart pattern is a shadow of.

Pulling SPXW 0DTE from an API

Here's how I fetch it. Replace with whatever provider you use, or swap SPXW for SPY, QQQ, NVDA — the shape is the same across symbols:

import requests

r = requests.get(
    "https://lab.flashalpha.com/v1/exposure/zero-dte/SPXW",
    headers={"X-Api-Key": "YOUR_API_KEY"}
)
d = r.json()

print(f"Regime:          {d['regime']['label']}")
print(f"0DTE gamma flip: ${d['regime']['gamma_flip']:.2f}")
print(f"Pin score:       {d['pin_risk']['pin_score']}/100")
print(f"Remaining move:  ±${d['expected_move']['remaining_1sd_dollars']:.2f}")
print(f"Pct of chain:    {d['exposures']['pct_of_total_gex']:.0f}%")

Useful fields if you're building UI on top of this:

regime.label — positive_gamma, negative_gamma, or undetermined
regime.gamma_flip — 0DTE-specific flip level (distinct from the full-chain GEX flip, which matters less intraday)
pin_risk.pin_score — 0 to 100, weighted composite
pin_risk.magnet_strike — the strike being pulled toward
expected_move.remaining_1sd_dollars — shrinking dollar 1σ until close
expected_move.upper_bound / lower_bound — the band you draw on a GEX chart
hedging.spot_up_half_pct / spot_down_half_pct — dealer shares per ±0.5% move (more relevant for 0DTE than ±1%)
decay.gamma_acceleration — 0DTE ATM gamma / 7DTE ATM gamma, typically 2-5x morning, 10x+ near close
strikes[] — per-strike call GEX, put GEX, net GEX, call/put OI

If you're rate-limited on a free tier, cache the regime fields for 60 seconds and only refresh strikes[] on user interaction.

SPXW vs SPY for 0DTE — developer-relevant differences

Both are liquid enough to treat as interchangeable index exposure. For modeling purposes, the practical differences:

Feature	SPXW	SPY
Notional per contract	~10× SPY	1×
US tax treatment	60/40 under §1256	Short-term capital gains
Settlement	Cash (European)	Physical (American, assignment risk)
Bid-ask at ATM 0DTE	~$0.05-0.10 index	~$0.01-0.02 on 1/10-size
Listing days	Mon-Fri	Mon/Wed/Fri (Tue/Thu added 2024)

For any systematic strategy, SPXW is the institutional default. For retail-sized accounts, SPY has finer-grained pricing. For the analytics code you write, the per-strike gamma and pin behavior are identical — just different symbol in the path parameter.

The TL;DR

"SPX 0DTE" on any desk or chat means SPXW. Cash-settled, European-style, same-day expirations every trading day. The four numbers that describe today's session — regime, pin score, remaining expected move, hedging at ±0.5% — change every time the tape moves.

Read them live. Don't cache them.

I maintain FlashAlpha — an options analytics API with pre-computed GEX, DEX, VEX, CHEX and SVI volatility surfaces. Free tier, no card. Happy to answer questions about the data model in the comments.

I Backtested My Own GEX Product Across 8 Years of SPY. Most of It Is Just VIX.

tomasz dobrowolski — Thu, 23 Apr 2026 10:06:56 +0000

I sell a dealer-exposure API. GEX, DEX, VEX, CHEX — the whole Greek-exposure stack. So when I tell you the backtest on my own product is mostly a VIX proxy, that is not a competitive hit piece. It is the result I got when I ran the test honestly, and it is the test I wanted before I bought any of this from anyone else.

Most options dashboards present four dealer-exposure Greeks as four independent signals. The pitch is intuitive: dealers hedge, those hedges create flows, and those flows forecast vol, returns, or IV changes. The mechanical story is real. The predictive story is much thinner once you control for what a trader can already see on a free VIX chart.

I pre-registered the hypotheses. Then I ran the statistics. Here is what 1,972 SPY trading days say.

What I tested

One row per SPY EOD. Each row carries dealer-signed GEX, DEX, VEX, CHEX, gamma flip, VIX, ATM IV, realized volatility, and forward outcomes. Positive exposure means dealers are net long that Greek.

Item	Setting
Universe	SPY only
Window	2018-04-16 to 2026-04-02
Sample	1,972 EOD snapshots; 1,971 usable next-day outcomes
Primary signals	GEX, DEX, VEX, CHEX
Primary outcomes	Next-day realized vol, next-day return, next-day ATM IV change
Controls	VIX, then VIX + ATM IV
Primary tests	Quintile sorts, top-minus-bottom t-tests, Spearman rank correlation

The question is not "do dealer exposures mean anything?" They do. The question is: do they add predictive information after you already know VIX and ATM IV?

Naive GEX looks excellent

Sort every day by GEX into quintiles. Measure next-day realized vol as |log_return| * sqrt(252).

GEX quintile	n	Mean net_gex ($B)	Mean next-day RV (%)	Median next-day RV (%)
Q1 — most negative	395	-7.91	16.97	13.54
Q2 — moderately negative	394	-2.79	18.57	12.91
Q3 — roughly neutral	394	+0.25	12.71	10.29
Q4 — moderately positive	394	+2.97	9.24	6.45
Q5 — most positive	394	+6.50	6.34	4.86

Q5 minus Q1: -10.63 vol points, t = -13.00, p = 1.0e-33. Spearman ρ = -0.36 on n=1,971.

This is the chart that sells a subscription. It is also not enough. A strong raw GEX backtest can still be a volatility-regime proxy — negative-GEX and high-VIX days often describe the same market state.

(Fact check: the Q1/Q2 mean inversion is real. Outlier-heavy COVID-era days; medians are clean. The rank correlation matters more than strict mean monotonicity.)

The control that changes the story

Regress both signal and outcome on the control set, then Spearman-correlate the residuals. Bonferroni significance for the four primary tests is p < 0.0125.

Signal → outcome	Raw ρ (p)	After VIX (p)	After VIX + ATM IV (p)
GEX → next-day RV	-0.36 (4.6e-60)	-0.14 (1.2e-9)	-0.03 (0.18)
DEX → next-day return	-0.03 (0.19)	+0.01 (0.69)	+0.02 (0.40)
VEX → next-day ATM IV change	-0.16 (2.1e-13)	-0.05 (0.02)	-0.01 (0.77)
CHEX → next-day return	-0.05 (0.03)	-0.01 (0.63)	-0.00 (0.93)

The raw signals are mostly volatility signals wearing more sophisticated labels. GEX survives the VIX-only control, but at ~40% of the raw magnitude. Add ATM IV and the GEX residual drops to ρ = -0.03, p = 0.18. DEX, VEX, and CHEX do not carry robust independent predictive information in these residualized rank tests.

GEX top-minus-bottom realized-vol difference tells the same story: -10.63 vol points raw, -3.15 after VIX, -0.99 after VIX + ATM IV (p = 0.25).

The honest result: GEX is not fake. The raw effect is real. The incremental information after VIX and ATM IV is the part that fails. Useful regime descriptor ≠ independent forecasting edge.

GEX × VIX double-sort

Double-sort: first split by VIX quintile, then within each VIX bucket split by GEX. Cells = mean next-day realized vol (%).

VIX \ GEX	Q1 most negative	Q2	Q3	Q4	Q5 most positive
V1 lowest VIX	8.02	7.32	6.62	5.22	5.07
V2	11.70	10.30	8.85	6.48	6.04
V3	12.00	12.05	12.15	9.62	8.56
V4	15.87	15.35	17.18	12.31	8.06
V5 highest VIX	20.57	24.91	37.69	21.71	15.91

V1 and V2 are textbook. V3 and V4 still show much lower RV in positive-GEX buckets, but not strictly monotonic. V5, the highest-VIX bucket, is a non-monotonic mess.

Practical takeaway: GEX's predictive value is mostly a calm-to-moderate phenomenon. In the top VIX quintile, where an extra risk signal would matter most, this double-sort does not show a clean edge.

Exposure verdicts

GEX: weak survivor. Useful as a regime descriptor; modestly incremental over VIX alone; not significant after VIX + ATM IV. Raw backtest is real, but it is mostly a vol-regime backtest.

DEX: dead on arrival. Top-minus-bottom next-day return difference: 0.00%, t = 0.04, p = 0.97. Raw Spearman ρ = -0.03, p = 0.19. DEX does not predict next-day SPY direction in this EOD test.

VEX: mostly a VIX proxy. Raw ρ = -0.16, p = 2.1e-13. But VEX correlates with VIX at +0.72 and with ATM IV at +0.76. After controlling for VIX + ATM IV, residualized VEX falls to ρ = -0.01, p = 0.77.

CHEX: weak and fragile. One interesting raw result — sign agreement between CHEX and next-day return is 54.9% on n=1,967, p = 1.5e-5. But the pre-registered residualized rank test collapses under VIX control (ρ = -0.01, p = 0.63) and under VIX + ATM IV (ρ = -0.00, p = 0.93). A separate OLS spec does show a significant CHEX coefficient after VIX + AR(1) controls, so: CHEX is not robust in the rank/quintile framework used for the primary article claim.

Why they overlap

Spearman rank correlations across all 1,972 observations:

	GEX	DEX	VEX	CHEX	VIX	ATM IV
GEX	+1.00	+0.73	-0.54	+0.59	-0.49	-0.63
DEX	+0.73	+1.00	-0.89	+0.68	-0.58	-0.67
VEX	-0.54	-0.89	+1.00	-0.65	+0.72	+0.76
CHEX	+0.59	+0.68	-0.65	+1.00	-0.39	-0.46
VIX	-0.49	-0.58	+0.72	-0.39	+1.00	+0.91
ATM IV	-0.63	-0.67	+0.76	-0.46	+0.91	+1.00

DEX ↔ VEX = -0.89. VEX ↔ VIX = +0.72. VIX ↔ ATM IV = +0.91. That does not make the exposure Greeks useless, but it makes them dangerous to treat as independent features. If someone sells GEX/DEX/VEX/CHEX as four unrelated predictive signals, this correlation matrix is the rebuttal. They are four views of the same options chain, and much of what they capture is already in volatility level. One-and-a-half signals, not four.

High-VIX regime test

The regime split is where a GEX backtest matters most for real trading decisions. The high-VIX row was pre-registered, not cherry-picked.

Regime	n	Top-minus-bottom RV diff	t	p	ρ
All days	1,971	-10.63	-13.00	1.0e-33	-0.36
Pre-COVID	463	-11.43	-6.78	4.5e-10	-0.41
COVID shock	72	-59.88	-3.88	0.001	-0.50
Post-COVID	1,436	-9.62	-9.58	8.7e-20	-0.32
Low-VIX days	1,478	-8.09	-11.81	3.9e-28	-0.32
High-VIX days	493	-1.89	-0.78	0.44	-0.02

Across all days GEX looks excellent. Inside high-VIX days the effect is statistically absent. That is the trading lesson: GEX is best at labeling calm regimes. It is not a clean crisis detector in this EOD SPY sample.

Train/test stability

A 70/30 chronological split looks impressive at first glance:

Split	Window	n	Top-minus-bottom diff	ρ
In-sample	2018-04 → 2023-11	1,380	-10.77	-0.367
Out-of-sample	2023-12 → 2026-04	591	-10.79	-0.374

Naive read: GEX is exceptionally robust. Cautious read: GEX is proxying a stable volatility-regime variable, and VIX + ATM IV absorb the effect. The residualized controls point to the second explanation.

What traders should do with this

Use GEX as a regime label, not a standalone forecast. Positive GEX describes a calmer market state. It does not, by itself, survive the VIX + ATM IV control as an independent next-day realized-vol signal.
Do not count the exposure stack as four independent factors. DEX and VEX are near mirror images in this sample; VEX is tightly linked to vol level.
Demand orthogonal tests. A vendor chart that beats a coin flip is not enough. The right question is whether the signal adds anything after obvious baselines — VIX, ATM IV, prior return, outcome persistence.
Correlation ≠ tradable PnL. Even GEX's VIX-only residual effect (ρ = -0.14) needs transaction costs, latency, data availability, and execution rules before it is a strategy.

Limitations

EOD panel only. 16:00 ET snapshots vs next-day outcomes. The canonical intraday CHEX claim — charm flow into the last hour — needs a separate minute-level study.
SPY only. Deepest, most-hedged ETF. Single stocks and index options may behave differently.
Linear residual controls. OLS residualization. A nonlinear model could recover interactions not measured here.
Correlation, not PnL. Statistical association, not executable trades after costs.
0DTE deserves its own article. Post-COVID includes the 0DTE era, but this is not a dedicated intraday 0DTE mechanics test.
Dealer-sign convention matters. Positive = dealers net long that Greek. Opposite conventions invert signs but not conclusions.
Stress obs are limited. COVID, 2022, 2025 provide meaningful turmoil, but high-VIX inference still rests on fewer days than calm-market inference.

How to reproduce

Three endpoints on the FlashAlpha Historical API, looped across 1,972 trading days, joined on (ts, symbol), outcomes shifted -1.

# Dealer-exposure summary (GEX, DEX, VEX, CHEX, gamma flip, walls)
curl -H "X-Api-Key: $KEY" \
  "https://historical.flashalpha.com/v1/exposure/summary/SPY?at=2024-06-14T20:00:00Z"

# Stock summary (spot, VIX context, ATM IV, realized vol)
curl -H "X-Api-Key: $KEY" \
  "https://historical.flashalpha.com/v1/stock/SPY/summary?at=2024-06-14T20:00:00Z"

# VRP snapshot (implied-vs-realized spread, regime, harvest score)
curl -H "X-Api-Key: $KEY" \
  "https://historical.flashalpha.com/v1/vrp/SPY?at=2024-06-14T20:00:00Z"

Residualize signals and outcomes on VIX, then on VIX + ATM IV. Re-run the quintile sorts, Spearman tests, and regime splits.

TL;DR

Gamma exposure works at the raw regime level, but the independent GEX edge is much smaller than the marketing version. Across 1,972 SPY days, raw GEX → next-day realized vol is ρ = -0.36. After VIX + ATM IV controls, it is ρ = -0.03 with p = 0.18. DEX has no next-day return signal, VEX is mostly a VIX/IV proxy, and CHEX is fragile in residualized rank tests. Use dealer exposure as context. Do not treat it as four clean standalone alpha signals.

Originally published at flashalpha.com. The full version includes the raw CSVs, pre-registered hypotheses file, and Python re-run scripts for every table above.

I Priced 18 Million SPY Put Spreads Across 8 Years. Every Bucket Was -EV. Every Year Made Money.

tomasz dobrowolski — Wed, 22 Apr 2026 11:42:08 +0000

When a blog post tells you "sell 30-delta puts at 45 DTE with a 50% profit take," you have no way to know whether that rule is near-optimal, arbitrary, or picked because it happens to look good in the author's sample. The only cure for cherry-picking is not to pick — compute the full surface and show where the edge actually lives.

So I did.

For every trading day from 2018-04-16 to 2026-04-02, for every SPY expiry with a usable SVI fit, for every short-strike delta in [0.05, 0.40] and every width in {1, 2, 3, 5, 10, 20}, I priced the theoretical credit spread under Black-Scholes with surface-consistent IVs, then joined each row with the actual SPY close at expiry.

18.3M rows. 1,698 trading days. 1,525 unique expiries. ~48 seconds to rebuild from raw SVI parameters and daily forwards.

Here's what fell out.

The headline numbers

Metric	Value
Average theoretical EV (flat-vol BSM)	-$0.48
Average realized P&L (joined with spot at expiry)	+$0.58
Realized edge (realized − theoretical)	+$1.06
Realized winrate	92.9%
Max-loss rate	5.6%

Every bucket -EV by theory. Every year +P&L by reality. The gap is the variance risk premium plus SPY's structural drift — both invisible to flat-vol pricing.

Finding 1 — Every theoretical bucket is negative EV

Across all 18,307,256 rows, average theoretical EV is -$0.484. There is no slice of the (DTE, delta, width) grid where theoretical EV is positive. Under the flat-vol lens, put credit spreads are net losers in expectation.

Flat-vol pricing is a trap. If it's your only model, the conclusion is clear and wrong: "don't sell put spreads." Flat-vol doesn't price VRP or SPY drift — it only prices the skew the market is literally quoting.

Finding 2 — Realized P&L is positive almost everywhere

Average realized P&L across the full matrix: +$0.577. The skew premium was paid fully, and then some.

Year-by-year breakdown, restricted to a single strategy footprint (width = $5, short delta 0.20-0.30):

Year	n	Theo EV	Realized P&L	Edge	Winrate	Max-loss	Avg IV
2023	119,986	-$0.43	+$0.97	+$1.39	97.8%	1.2%	21.1
2024	124,447	-$0.47	+$0.86	+$1.33	97.5%	1.8%	18.7
2026 Q1	29,114	-$0.57	+$0.86	+$1.43	97.0%	1.9%	25.2
2020	131,318	-$0.51	+$0.84	+$1.35	95.6%	3.7%	32.2
2025	117,429	-$0.54	+$0.77	+$1.31	96.3%	3.1%	21.8
2019	70,470	-$0.40	+$0.50	+$0.91	89.8%	8.3%	19.7
2018 (Apr-Dec)	46,479	-$0.41	+$0.28	+$0.69	84.9%	11.5%	21.2
2021	129,952	-$0.62	+$0.21	+$0.83	85.7%	12.2%	25.5
2022	108,386	-$0.52	+$0.02	+$0.54	78.5%	18.2%	28.5

Every year profitable. Every year's theoretical EV negative. The only year close to breakeven: 2022 — the one true bear year in the sample.

Finding 3 — Capital efficiency flips the verdict on short DTE

Absolute P&L per spread goes up with DTE. Annualized return on capital does not. For short delta 0.20-0.30, width $5:

DTE bucket	Avg credit	Realized P&L	Per-trade ROC	Annualized ROC	Winrate
0-7	$0.68	+$0.042	0.97%	75.3%	83.1%
8-21	$0.74	+$0.069	1.62%	41.0%	84.2%
22-45	$0.76	+$0.121	2.86%	32.1%	85.9%
46-90	$0.79	+$0.255	6.05%	32.7%	88.5%
91+	$1.06	+$0.752	19.1%	17.7%	93.6%

Four caveats that matter:

Fill costs eat the 0-7 DTE number alive. Mid-quote model prices + real bid/ask on 0DTE SPY = most of that $0.04 edge gone. Upper bound, not strategy.
91+ DTE locks capital for 394 days on average. +19% per-trade only annualizes to ~18%.
22-90 DTE is the comfortable zone. ~32-33% annualized, winrates in the high 80s.
No profit takes, no stops, held to expiry. Overlays change everything.

Finding 4 — Risk-adjusted: the best Sharpe isn't where you'd guess

IID Sharpe from the per-trade P&L distribution, 15 representative profiles (one trade per day, closest to target delta):

Profile	Ann Sharpe	Ann ROC	Winrate	Max-loss
45 DTE 40Δ $10 wide	0.49	67.6%	79.5%	12.9%
45 DTE 40Δ $5 wide	0.48	74.8%	78.2%	17.3%
45 DTE 30Δ $5 wide	0.47	57.2%	85.2%	12.1%
180 DTE 25Δ $5 wide	0.46	22.8%	91.0%	8.7%
45 DTE 25Δ $5 wide	0.42	44.3%	87.9%	9.5%
7 DTE 40Δ $5 wide	0.39	142.5%	74.1%	16.1%
30 DTE 40Δ $5 wide	0.35	65.9%	76.9%	20.0%

What Sharpe 0.48 actually means: SPY buy-and-hold over 2018-2026 runs Sharpe ~0.55-0.70. Typical long-only equity strategies: 0.4-0.8. The best put-spread profile here is competitive with passive SPY, not a free lunch. The honest use case is diversification — theta/VRP returns only weakly correlated to daily SPY path, so a small allocation lowers total-portfolio vol.

Finding 5 — IV regime counter-intuitively favors crisis

Bucketing the 22-45 DTE, 20-30Δ, $5-wide set by short-strike IV:

IV regime	Theo EV	Realized P&L	Edge	Winrate	Max-loss	n
crisis (30+)	-$0.42	+$0.54	+$0.95	92.8%	6.1%	15,555
high (22-30)	-$0.42	+$0.16	+$0.59	86.3%	10.6%	26,486
elevated (16-22)	-$0.42	+$0.05	+$0.47	85.1%	11.5%	30,132
normal (12-16)	-$0.38	-$0.10	+$0.28	81.7%	13.1%	17,848
calm (<12 IV)	-$0.37	-$0.66	-$0.30	71.3%	22.6%	1,676

Calm is the worst regime. Crisis is the best. The VRP in one table — highest edge at the point of maximum perceived danger.

Caveats that should be loud

A clean dashboard is seductive. Several assumptions push the real-world numbers down from the model numbers:

No transaction costs. Short-DTE in particular: average $0.11 credit at 7 DTE 40Δ, realistic slippage budget $0.10-0.20. The 142% annualized ROC is a model ceiling, not a target.
Theoretical prices are mid-quote proxies. Reconstructed from SVI + BS. Executable credit closer to bid.
No liquidity filter. Thin strikes where SVI fit ≠ strikes that fill at modeled price.
No stops, no profit takes. Held to expiry.
IID Sharpe is an upper bound. Losses cluster in bear regimes (clearly 2022). Real drawdowns > IID math implies.
Single underlying, structural upward drift. Single-name, earnings-driven underlyings look much worse.
8 years is short. One real bear year. Confidence intervals on "crisis wins" are wide.

None invalidate the shape; all push the magnitude down. The theoretical-vs-realized gap is real; the exact basis-point edge is smaller than this model suggests.

How I reproduced this

Three ingredients: historical SVI surface parameters, daily forwards, SPY spot at expiry. All three via the flashalpha Python package — same surface fits the live product uses, walk-forward by default, no look-ahead.

pip install flashalpha

from flashalpha import Client
import pandas as pd

fa = Client(api_key="...")
surfaces = fa.historical.surface("SPY",
    start="2018-04-16", end="2026-04-02")

# surfaces is a DataFrame: ts, expiry, dte, forward,
# svi_a, svi_b, svi_rho, svi_m, svi_sigma
# From there: reconstruct IV at every strike, price BS puts,
# enumerate spread permutations, join with spot at expiry.

TL;DR

Over 8 years and 18M simulated SPY put credit spreads, the market priced skew premium into every bucket. Flat-vol BSM theoretical EV averaged -$0.48. Actual realized P&L, joined with real spot at expiry, averaged +$0.58. The +$1.06 gap is the variance risk premium plus SPY's drift, paid out in cash. Put selling on SPY is renting the market's fear. The rent has been paid every year in the sample.

Originally published at flashalpha.com. The full version has yearly stress-test breakdowns, delta-by-delta tables at 30-DTE, the full Sharpe math, and a $100k portfolio scaling example with 2022 drawdown stress.

Free GEX Data — Gamma Exposure Levels for 6,000+ US Tickers (No Signup, No Credit Card)

tomasz dobrowolski — Tue, 21 Apr 2026 15:27:10 +0000

Most GEX providers paywall the levels that actually matter. You can find a SPY screenshot on Twitter, but try pulling data for ARM or SLV and you hit a subscription prompt.

I've been building FlashAlpha on a different premise: the computed GEX data is free to view for every US ticker, free via API on the starter tier, and there's no time-limited trial.

This post is a developer-focused walkthrough — the chart, the endpoint, the limits, and what changes when you outgrow the free tier.

What "free" actually means

Three things that don't need a signup:

Interactive GEX charts for any US-listed ticker — per-strike gamma, gamma flip, call/put walls.
GEX-derived key levels surfaced on every ticker analytics page (net GEX, gamma flip, call wall, put wall).
Free API tier — 5 requests/day against the GEX endpoint. Enough to watch a small watchlist daily.

Paid plans buy higher rate limits and adjacent endpoints (DEX, VEX, CHEX, historical, full-chain aggregation). The GEX values themselves are identical across tiers.

Hitting the API

Grab a key at flashalpha.com/profile — no card required.

curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/SPY?expiration=2026-05-16"

The response gives you net GEX, gamma flip price, a regime label, and the per-strike array. If you only want the four headline levels (call wall, put wall, gamma flip, net GEX), there's a separate /v1/exposure/levels/{symbol} endpoint that returns them in one call.

Python SDK

pip install flashalpha

from flashalpha import FlashAlpha

client = FlashAlpha(api_key="YOUR_KEY")
gex = client.exposure.gex("SPY", expiration="2026-05-16")

print(f"Net GEX:    {gex['net_gex']:,}")
print(f"Gamma flip: {gex['gamma_flip']}")
print(f"Regime:     {gex['net_gex_label']}")

Also published as npm install flashalpha for JS/TS, plus C#, Go, and Java packages — same shape across all of them.

One free-tier gotcha

Full-chain GEX (all expirations aggregated into one number) is on the Growth plan. On the free tier, pass ?expiration=yyyy-MM-dd to scope to a single expiry — which is what most intraday work needs anyway.

5 calls/day works out to a morning pre-market scan over SPY, QQQ, and a few names on a watchlist. If you need to sweep a 50-ticker universe every few minutes, that's a Growth use case.

How fresh the data is

A few things worth knowing about how the levels get computed:

Updated intraday. GEX shifts as options open and close. End-of-day snapshots miss the moves that matter most.
Computed from full option chains. Every active strike is included, not a sampled subset.
Dealer-sign convention. Positive GEX = dealers long gamma (suppresses moves). Negative GEX = dealers short gamma (amplifies moves). Matches how SpotGamma and the academic literature report it.
0DTE included. 0DTE strikes contribute to the per-strike profile like any other expiration.

Free vs paid — the honest comparison

	Free	Growth
GEX values (per-strike + net)	Same data	Same data
Ticker coverage	All 6,000+	All 6,000+
Update cadence	Intraday	Intraday
API rate limit	5/day	2,500/day
Full-chain GEX via API	Single-expiry only	All expirations
DEX / VEX / CHEX via API	—	Full access
Historical GEX	—	Available

If all you want is "today's call wall on TSLA," the free tier is the whole answer.

MCP server, if you live in Claude/Cursor

There's also an MCP server at https://lab.flashalpha.com/mcp if you want to query GEX from Claude Desktop, Cursor, or Windsurf without writing code. Same auth, same endpoints.

If you build something with it, tag me — I read every reply.

Originally published on FlashAlpha.

Replay any minute of SPY options back to 2018 - historical GEX, DEX, VEX, CHEX in one API

tomasz dobrowolski — Mon, 20 Apr 2026 17:42:34 +0000

TL;DR

Same JSON as the live FlashAlpha options analytics API. Add one query parameter - at - and you get historical gamma exposure (GEX), delta exposure (DEX), vanna (VEX), charm (CHEX), max pain, VRP, the SVI surface, the 0DTE block, and the full stock summary as they stood at that minute, with no future leakage. 6.7 billion option rows going back to April 2018.

Host: historical.flashalpha.com
Endpoints: every live analytics route, mirrored
Dataset start: 2018-04-16
Resolution: 1 minute for quotes + greeks; EOD for OI, macro, SVI

Why a separate host instead of one URL with `?at=`

So your SDK doesn't need to know anything new. Point your existing client at a different base URL, add at=, done. Same auth header (X-Api-Key), same response shapes, same code path - literally the same analytics service, reading from minute-level archives instead of the live feed.

This matters when you're backtesting. You don't want to port a strategy onto a second set of response parsers just to replay history.

The `at` parameter

It's ET wall-clock. Don't apply a UTC offset.

Format	Example	Meaning
`yyyy-MM-ddTHH:mm:ss`	`2026-03-05T15:30:00`	Minute-level
`yyyy-MM-dd`	`2026-03-05`	Defaults to 16:00 ET (close)

Example: historical GEX at the COVID low

curl -H "X-Api-Key: $FA_KEY" \
  "https://historical.flashalpha.com/v1/exposure/summary/SPY?at=2020-03-16T15:30:00"

{
  "symbol": "SPY",
  "underlying_price": 246.01,
  "as_of": "2020-03-16T15:30:00",
  "gamma_flip": 270.92,
  "regime": "negative_gamma",
  "exposures": {
    "net_gex":  -2633970601,
    "net_dex": -169419489077,
    "net_vex":  152461756844,
    "net_chex":   -13122349
  }
}

Real dealer positioning at 15:30 ET on the day SPY closed -12%. Not a reconstruction - the same greeks that existed on the tape, run through today's analytics.

What moves per minute vs per day

Not every series is worth storing at minute granularity:

Layer	Granularity
Option quotes + greeks (iv, δ, γ, θ, ν, vanna, charm)	1 minute
Stock bid/ask/mid	1 minute
Open interest	EOD
SVI params, forward prices	EOD
VIX / VVIX / SKEW / MOVE / DGS10	EOD

OI barely moves intraday and is dealer-positioning context - so applying one EOD value to every intraday at= on that day is defensible. Intraday exposure shifts are driven by greek + spot changes anyway.

No future leakage on VRP

The /v1/vrp/{symbol} endpoint computes percentile and z-score using only history prior to at. Query VRP at 2020-03-16T15:30 and the percentile is ranked against the distribution as it existed on that day, not against the full 2018–today window.

Backtests don't lie when the data doesn't.

Endpoints

Every live endpoint is mirrored:

/v1/stockquote/{ticker} — bid/ask/mid at a minute
/v1/optionquote/{ticker} — option quote + greeks + OI
/v1/exposure/gex|dex|vex|chex/{symbol} — exposure by strike (historical GEX, DEX, VEX, CHEX)
/v1/exposure/summary/{symbol} — regime, flip, net exposures
/v1/exposure/levels/{symbol} — flip, walls, magnets
/v1/exposure/narrative/{symbol} — verbal regime + prior-day comparison
/v1/exposure/zero-dte/{symbol} — historical 0DTE block
/v1/maxpain/{symbol} — max pain + pin probability
/v1/volatility/{symbol} — RV ladder, IV-RV spread, skew
/v1/adv_volatility/{symbol} — SVI params, variance surface, arbitrage flags
/v1/vrp/{symbol} — VRP dashboard, date-bounded
/v1/stock/{symbol}/summary — everything in one call

Plus one historical-specific route:

/v1/tickers — coverage map (first date, last date, gaps, healthy-day count) per symbol

Honest field coverage gaps

Upfront about what's zero/null vs what's real:

Field	Status	Why
`bidSize`, `askSize`, `volume`	`0`	Minute quotes don't carry sizes
`call_oi_change`, `put_oi_change`	`null`	Prior-day per-strike diff not yet computed
0DTE per-strike greeks	often `0` / `null`	Near-expiry minute greeks still backfilling
`summary.macro.vix_futures`	`null`	CME futures curves aren't archived historically
`optionquote.svi_vol`	`null`	Per-contract SVI derivation not yet exposed — use `/v1/adv_volatility`

Everything else — greeks, IV, exposures, flip, walls, regime, narrative, VRP percentiles, SVI fits, variance surface, arbitrage flags — is real data at at.

Coverage

SPY is fully backfilled 2018-04-16 → 2026-04-02 and extends on every refresh. Additional symbols are backfilled on request. Query the live coverage map anytime:

curl -H "X-Api-Key: $FA_KEY" \
  "https://historical.flashalpha.com/v1/tickers"

Latency

Point-in-time reads are ~50–300 ms typical. Composite endpoints (/v1/adv_volatility, /v1/stock/{symbol}/summary) rebuild surfaces on demand and take ~500–1500 ms cold. Responses are deterministic for a given (symbol, at) tuple - cache indefinitely.

Backtesting Gamma-Exposure Strategies with Minute-Level Historical Data

tomasz dobrowolski — Thu, 16 Apr 2026 18:30:36 +0000

If you've ever read a blog post claiming "short straddles when GEX is positive returns 30% a year" and wondered why the claim evaporates when you try to reproduce it, the answer is usually the same: the backtest cheated somewhere. Either it used data that didn't exist at the decision time, it labelled regimes using end-of-day aggregates that smear across the true intraday flip, or it skipped execution costs that swamp the signal.

FlashAlpha's Historical Analytics API makes the honest version of this backtest easier than the cheat. One at parameter, minute-level regime labels since 2018, leak-free percentiles by design. This article walks through the whole pipeline.

What We're Testing

A simple, well-known hypothesis: SPY mean-reverts intraday when dealers are long gamma and trends when dealers are short gamma. Specifically, we'll test whether short-term (30-minute) returns after 15:30 ET differ by dealer regime. If the hypothesis is real, 15:30-to-close returns should be smaller and more mean-reverting during positive-gamma regimes and larger (in either direction) during negative-gamma regimes.

This is a textbook GEX claim. It's also exactly the kind of thing that looks real in a sloppy backtest and dies in a careful one. Let's do it carefully.

Step 1: Pull the Regime Labels

We need, for every trading day in the test window, the dealer regime at 15:30 ET. That's /v1/exposure/summary/{symbol} with at set to 15:30 on each day.

import httpx, pandas as pd
from tqdm import tqdm

API_KEY = "..."
BASE = "https://historical.flashalpha.com"

dates = pd.bdate_range("2022-01-03", "2025-12-31")
rows = []

with httpx.Client(headers={"X-Api-Key": API_KEY}, timeout=30) as c:
    for d in tqdm(dates):
        ts = d.strftime("%Y-%m-%dT15:30:00")
        r = c.get(f"{BASE}/v1/exposure/summary/SPY", params={"at": ts})
        if r.status_code != 200:
            continue
        j = r.json()
        rows.append({
            "date": d,
            "spot_1530": j["underlying_price"],
            "net_gex": j["exposures"]["net_gex"],
            "net_dex": j["exposures"]["net_dex"],
            "regime": j["regime"],
            "gamma_flip": j["gamma_flip"],
            "zero_dte_pct": j.get("zero_dte", {}).get("pct_of_total_gex", 0),
        })

gex = pd.DataFrame(rows).set_index("date")

About 1,000 business days. At roughly 200ms per call, this runs in ~3 minutes single-threaded. Run it once, cache to parquet, move on.

Leak check: every number in gex is computed from data available at or before 15:30 ET on that date. The net_gex number reflects OI from that morning's EOD load (yesterday's OI) plus minute-level greek recomputation from 15:30 spot and vols. Nothing later than 15:30 ET on the given date contributes.

Step 2: Pull the Forward Returns

For each date, we need the 15:30-to-16:00 ET return. Two stock-quote calls per day: one at 15:30, one at 16:00.

close_rows = []
with httpx.Client(headers={"X-Api-Key": API_KEY}, timeout=30) as c:
    for d in tqdm(dates):
        r = c.get(
            f"{BASE}/v1/stockquote/SPY",
            params={"at": d.strftime("%Y-%m-%dT16:00:00")}
        )
        if r.status_code == 200:
            close_rows.append({"date": d, "spot_close": r.json()["mid"]})

closes = pd.DataFrame(close_rows).set_index("date")
df = gex.join(closes, how="inner").dropna()
df["ret_30min"] = df["spot_close"] / df["spot_1530"] - 1

Leak check: the forward return uses 16:00 ET data to measure performance of a signal generated at 15:30 ET. There's a 30-minute gap, which is the signal window. No feature crosses the signal-to-outcome boundary.

Step 3: Condition on Regime

by_regime = df.groupby("regime")["ret_30min"].agg(
    n="count",
    mean_bps=lambda x: x.mean() * 10000,
    std_bps=lambda x: x.std() * 10000,
    abs_mean_bps=lambda x: x.abs().mean() * 10000,
)
print(by_regime)

The interesting column is abs_mean_bps — the average absolute move. If the mean-reversion hypothesis is right, it should be smaller in positive_gamma than in negative_gamma. If the directional hypothesis is right (short puts in positive gamma), mean_bps should differ too.

Running this against the 2022–2025 window, you'll typically find a real but small effect: absolute 15:30-to-close moves are roughly 30–40% smaller in positive-gamma days. That's enough to matter for an intraday vol-selling strategy and not nearly enough to matter as a directional overlay. This is the kind of nuance that clean backtests produce and messy ones miss.

Step 4: Stratify on GEX Magnitude

The regime label is a coarse cut. The underlying net_gex is continuous. Bucket by deciles and look at the monotone relationship:

df["gex_decile"] = pd.qcut(df["net_gex"], 10, labels=False)
by_decile = df.groupby("gex_decile").agg(
    gex_mean=("net_gex", "mean"),
    n=("ret_30min", "count"),
    abs_move_bps=("ret_30min", lambda x: x.abs().mean() * 10000),
)
print(by_decile)

What you want to see is a monotone curve — low GEX deciles should show larger absolute moves, high GEX deciles smaller. If the curve is flat or non-monotone, the regime signal isn't really tracking what you think it's tracking and the rest of the strategy won't work.

Step 5: Scale Up — Every Minute, Every Day

Once the daily-grid version works, the minute-level version is mechanical. Instead of one sample per day at 15:30, pull every minute from 9:30 to 16:00 and condition on intraday regime changes. That's 390 calls per day × 1,000 days = 390,000 calls.

The minute-level grid lets you answer strictly-better questions:

What happens in the 15 minutes after a regime flip? Filter df to rows where regime[t] != regime[t-1], compute forward returns over varying windows.
Do moves compress as spot approaches the gamma flip? Compute spot_to_flip_pct and stratify.
Is 0DTE GEX a stronger signal intraday than all-expiry GEX? The zero_dte block in the summary gives you both; run the same test on each.

These are the questions the dealer-positioning literature claims to answer but rarely tests at the resolution of the claim. The Historical API makes them runnable.

The Three Traps This Setup Avoids

1. Rolling-Percentile Leakage

If your backtest uses VRP percentile or GEX percentile as a feature, make sure the percentile at time t is computed only from data strictly before t. FlashAlpha's VRP endpoint does this by default. Full write-up →

2. End-of-Day Smearing

Net GEX can flip intraday. A backtest that uses close-of-day GEX to label a 10:30 ET entry is measuring a feature that didn't exist yet. The Historical API's minute resolution removes this problem — you can label each bar with the regime as it stood at that bar's open.

3. Survivorship in Symbol Selection

If you backtest only on SPY, you don't have a survivorship problem. If you start adding single-names later, make sure your universe at each date reflects what was tradable then, not what's listed now. FlashAlpha's coverage endpoint is explicit about which symbols had data when.

Going Beyond Regime Labels

Everything above uses the scalar regime and net GEX as the signal. The full exposure/summary response is richer — it includes net DEX (directional dealer positioning), net VEX (vanna), net CHEX (charm), and interpretation text. For ML workflows, pull the whole response and let the model sort out which fields matter:

def features_at(client, symbol, at_ts):
    s = client.get(
        f"{BASE}/v1/exposure/summary/{symbol}", params={"at": at_ts}
    ).json()
    v = client.get(
        f"{BASE}/v1/vrp/{symbol}", params={"at": at_ts}
    ).json()
    return {
        "spot": s["underlying_price"],
        "net_gex": s["exposures"]["net_gex"],
        "net_dex": s["exposures"]["net_dex"],
        "net_vex": s["exposures"]["net_vex"],
        "net_chex": s["exposures"]["net_chex"],
        "gamma_flip": s["gamma_flip"],
        "spot_to_flip_pct": (
            s["underlying_price"] - s["gamma_flip"]
        ) / s["underlying_price"],
        "zero_dte_pct": s.get("zero_dte", {}).get("pct_of_total_gex", 0),
        "vrp_20d": v["vrp"]["vrp_20d"],
        "vrp_z": v["vrp"]["z_score"],
        "vrp_pct": v["vrp"]["percentile"],
        "atm_iv": v["vrp"]["atm_iv"],
        "hv_20": v["vrp"]["rv_20d"],
    }

That's ~15 features per timestamp with two API calls. For tabular models (XGBoost, LightGBM), this is already in the right shape. For transformers, pull the full nested responses and flatten lazily.

What You Actually Pay For

The cost of this backtest — end-to-end, against 4 years of history — is a function of how many minute-level samples you pull. Daily snapshots across 4 years ≈ 1,000 calls per endpoint per symbol. Minute-level is 390× that.

The alternative — building this dataset yourself — is a 3-to-6 month engineering project: ThetaData subscription, options parquets, BSM pipeline, SVI fitter, columnar store, minute-level partitioning, holidays/half-days handling, coverage reports. FlashAlpha's Historical API is the bought-not-built version of that stack.

Historical API is available on the Alpha tier. Get your free API key to start with the live endpoints.

Look-Ahead Bias in Volatility Backtests — Why Most VRP Percentiles Silently Cheat (and How to Fix It)

tomasz dobrowolski — Wed, 15 Apr 2026 08:29:59 +0000

Ask any quant what kills backtests and you'll get the same short list: survivorship bias, execution costs, overfitting. The one that gets mentioned less often — and is probably the most common in amateur-to-intermediate volatility research — is percentile leakage. It's a specific, boring, easy-to-miss form of look-ahead bias that makes dead strategies look alive, and it's baked into almost every "VRP percentile" or "IV rank" column you'll find in public datasets.

What Is Percentile Leakage in Options Backtesting?

Consider a feature you've seen a hundred times: VRP 20-day percentile. Take the current 20-day VRP, compare it to the distribution of historical VRPs, express as a percentile (0 to 100). High percentile = rich vol premium, time to sell. Low percentile = compressed, stand down.

Now, how did you compute the distribution?

The wrong way: grab all historical VRP values in your dataset (say 2018–2026), sort them, and on any given date t, compute the percentile of VRP[t] against that full sorted list.

That's leakage. In 2019, your "percentile" is scored against a distribution that includes March 2020, August 2024, and every other extreme event that hadn't happened yet. The 2019 percentile a real trader would have seen — using only data before 2019 — is different, often very different.

When you bet on that cheated percentile in your backtest, you are using information that did not exist.

How to Compute Walk-Forward Percentiles Without Look-Ahead Bias

At each date t, compute the percentile of VRP[t] against the distribution of VRP values from strictly before *t. That's a *walk-forward or expanding-window percentile. Every sample is scored against the knowledge available at its own moment, and nothing later.

Straightforward to describe. A minor nuisance to implement correctly:

Store every historical VRP observation with its date.
On each query, filter to observations dated strictly before the query date.
Compute percentile against that filtered set.
Do this efficiently — the naive implementation is O(n) per query across thousands of queries.

Most custom percentile code gets step 2 subtly wrong (off-by-one on the date filter), step 4 badly wrong (recomputing the full distribution per query), or both. A correct implementation shipped behind an API removes the excuse.

How FlashAlpha's Historical VRP API Avoids Look-Ahead Bias

FlashAlpha's Historical VRP endpoint is explicit about this:

VRP percentile and z-score are computed from snapshot rows with date strictly less than the query date, so at any historical point the percentile reflects what was knowable at that moment.

The filter is a SQL predicate in the query itself — not a convention, not a best-effort, not something you can accidentally bypass.

Ask for /v1/vrp/SPY?at=2022-06-14T15:30:00 and the percentile is computed against data before 2022-06-14. Ask for the same symbol at a later date and the percentile changes, because the rolling window includes more data.

curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://historical.flashalpha.com/v1/vrp/SPY?at=2022-06-14T15:30:00"

{
  "symbol": "SPY",
  "vrp": {
    "vrp_20d": 8.11,
    "z_score": 2.84,
    "percentile": 100,
    "history_days": 60
  }
}

That percentile: 100 means this VRP reading is above every observation in the preceding 60-day window — computed honestly, as a trader at 15:30 ET on June 14, 2022 would have actually seen it. Not as a backtest writer looking backwards from 2026 would retroactively assign it.

How Much Does Look-Ahead Bias Inflate Your Sharpe Ratio?

The amplitude of the leakage depends on where in the history you're testing. A backtest across a 2018–2026 window using full-sample percentiles will:

Under-assign extreme percentiles in early history (the extremes that hadn't yet happened are in the denominator).
Over-assign extreme percentiles in late history (mirror image).
Inflate Sharpe ratios for any strategy that triggers on percentile thresholds, because the threshold breaches are non-random in time.

In the VRP case specifically, a short-strangle strategy gated on "VRP percentile > 80" will typically show 15–30% higher Sharpe on full-sample percentiles than on walk-forward percentiles over a 5+ year window. That's enough to turn a live-unviable strategy into a slide-deck-impressive one. It's also exactly the kind of edge that evaporates the moment you try to trade it, because the live version doesn't get to cheat.

Python: Walk-Forward VRP Backtest Using the Historical API

Here's a practical research pattern: pull VRP daily across your test window, and at each date, record the percentile the API returns. That percentile is already walk-forward.

import httpx, pandas as pd
from tqdm import tqdm

API_KEY = "..."
BASE = "https://historical.flashalpha.com"
dates = pd.bdate_range("2020-01-01", "2025-12-31")

rows = []
with httpx.Client(headers={"X-Api-Key": API_KEY}, timeout=30) as c:
    for d in tqdm(dates):
        r = c.get(f"{BASE}/v1/vrp/SPY", params={"at": d.strftime("%Y-%m-%d")})
        if r.status_code != 200:
            continue
        j = r.json()["vrp"]
        rows.append({
            "date": d,
            "vrp_20d": j["vrp_20d"],
            "vrp_pct": j["percentile"],
            "vrp_z": j["z_score"],
            "atm_iv": j["atm_iv"],
            "rv_20d": j["rv_20d"],
        })

vrp = pd.DataFrame(rows).set_index("date")
# vrp["vrp_pct"] is walk-forward by construction — no leakage
entries = vrp[vrp["vrp_pct"] > 80]

That entries dataframe is the set of honest trigger days for a "short strangle when VRP percentile > 80" study. Join forward returns (next-day or next-20-day underlying path / straddle P&L), measure edge. If it works with the walk-forward percentile, it has a chance of working live. If it only works with a full-sample percentile, you're looking at a statistical artifact.

Other Options Backtesting Features That Leak the Future

Percentiles are the most common case, but the same class of look-ahead bias hides in:

Rolling z-scores with expanding-window means and standard deviations. Same walk-forward fix required. FlashAlpha's z_score is computed from the same date-bounded snapshot set as the percentile.
Regime labels ("normal" vs "elevated") derived from thresholds on historical distributions. If the thresholds come from the full dataset, early samples get labelled against knowledge that didn't exist.
Volatility-of-volatility features. Any derived statistic that rolls over the entire history is a candidate for leakage.
Cross-asset signals that blend SPY and another underlying's history. The leakage compounds across instruments.

For anything you compute yourself on top of the Historical API's raw outputs, the rule is the same: at time t, use only data with timestamps strictly less than t. For percentile and z-score on VRP specifically, the endpoint handles it for you.

Why Look-Ahead Bias Is Worse for Machine Learning Models

For ML workflows, leakage is a larger problem because your model learns whatever signal exists — including whatever cheating signal the features leak. If VRP percentile is a feature and it's computed against the full dataset, the model will learn that "high percentile" is more informative in early history than it actually was, because the labelling itself encodes future information. Gradient boosters in particular are excellent at exploiting these micro-leaks.

Using the Historical API's walk-forward percentile as a feature removes that failure mode for VRP. Apply the same discipline to your other derived features, and your cross-validated metrics start matching your paper-trading metrics — which is the whole point.

The Real Point: Make the Right Thing Frictionless

Calculator correctness gets a lot of ink in quant writing. Leakage discipline gets much less. But leakage is where most real-world research gets quietly ruined — not in the calculator, but in the feature pipeline that feeds it.

The reason FlashAlpha's Historical VRP is notable isn't that percentiles are hard to compute. It's that shipping a historical API where the percentiles are honest by default means every user starts from a correct baseline. Research quality is defined by the lowest-friction option; make the right thing frictionless and most people will do the right thing.

Historical Options Data API for Backtesting — Replay GEX, VRP & Dealer Positioning at Any Minute Since 2018

tomasz dobrowolski — Wed, 15 Apr 2026 08:29:40 +0000

Every serious options project eventually hits the same wall: the live API shows you now, but the questions that actually matter — does this strategy work? what did dealers do during the last drawdown? how did VRP behave before earnings? — all require historical options data.

And historical options data, especially pre-computed historical analytics, is the one thing nobody sells.

FlashAlpha's Historical API changes that. The contract is simple: every live analytics endpoint, replayable at any minute since 2018-04-16, returned in the same response shape. One query parameter — at — and you get what GEX, DEX, VEX, CHEX, VRP, max pain, dealer regime, or the full stock summary looked like at that exact minute in history.

Why Historical Options Analytics Don't Exist Anywhere Else

Go look at the other options data providers. Polygon, ThetaData, ORATS, Intrinio, Tradier — all of them ship raw ticks or end-of-day snapshots. You can reconstruct parts of the analytics layer yourself if you have the time and the pipeline, but you will spend six months writing the join, the BSM pass, the SVI fit, the per-strike aggregation, the regime classifier, the leak-free percentile calculator — and you will still end up with something that only resembles the live product on a good day.

FlashAlpha's Historical API collapses that work into one HTTP call. The same ExposureCalculator, NarrativeBuilder, VrpCalculator, VolatilityAnalyzer, and AdvancedVolatilityCalculator classes that power the live endpoints also power the historical service. Calculator bug-fixes land in both services simultaneously. What you see live, you see historically — exactly the same shape, exactly the same methodology.

Pre-computed historical options analytics require minute-level options quotes with greeks for every strike and expiration, anchored to forward prices, joined to end-of-day open interest, fitted with SVI, and cross-referenced against macro (VIX, VVIX, SKEW, MOVE) — all aligned to the exact timestamp you ask for. The dataset behind it: 6.7 billion option rows, 2 million+ stock minute-bars, daily SVI fits, daily macro. Nobody else assembled this stack.

How the Historical Options API Works: The `at` Parameter

Every analytics endpoint takes one required query parameter: at. That's your as-of timestamp. Pass it and you get the response as it would have been computed at that minute.

Format	Example	Semantics
`yyyy-MM-ddTHH:mm:ss`	`2026-03-05T15:30:00`	Minute-level as-of. ET wall-clock.
`yyyy-MM-dd`	`2026-03-05`	Defaults to 16:00 ET (session close).

Option greeks, bid/ask, stock spot, and everything derived from them are truly intraday — one value per minute from 9:30 to 16:00 ET. Open interest, SVI parameters, and macro are EOD-stamped.

curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://historical.flashalpha.com/v1/exposure/summary/SPY?at=2020-03-16T15:30:00"

One call. Full exposure dashboard — net GEX, net DEX, net VEX, net CHEX, gamma flip, regime label, interpretations, ±1% hedging estimates, 0DTE contribution — as of 15:30 ET on March 16, 2020. The day SPY closed -12%.

Full List of Replayable Historical Options Endpoints

This is not a subset. The Historical API mirrors the live API endpoint-for-endpoint:

Category	Endpoint	What you replay
Market data	`/v1/stockquote/{ticker}`	Stock bid/ask/mid/last at the minute
Market data	`/v1/optionquote/{ticker}`	Contract-level quotes + BSM greeks + OI
Market data	`/v1/surface/{symbol}`	50×50 implied-vol surface grid
Exposure	`/v1/exposure/gex/{symbol}`	Historical gamma exposure by strike
Exposure	`/v1/exposure/dex/{symbol}`	Historical delta exposure by strike
Exposure	`/v1/exposure/vex/{symbol}`	Historical vanna exposure by strike
Exposure	`/v1/exposure/chex/{symbol}`	Historical charm exposure by strike
Exposure	`/v1/exposure/summary/{symbol}`	Full composite dashboard + regime + hedging
Exposure	`/v1/exposure/levels/{symbol}`	Gamma flip, call wall, put wall, max gamma
Exposure	`/v1/exposure/narrative/{symbol}`	Verbal analysis + prior-day GEX delta + VIX context
Exposure	`/v1/exposure/zero-dte/{symbol}`	0DTE regime, pin risk, expected move, decay
Max pain	`/v1/maxpain/{symbol}`	Pain curve, pin probability, dealer alignment
Composite	`/v1/stock/{symbol}/summary`	Price, vol, flow, exposure, macro — one response
Volatility	`/v1/volatility/{symbol}`	RV ladder, IV-RV spread, skew, term structure
Volatility	`/v1/adv_volatility/{symbol}`	SVI params, forwards, total variance, arb flags
VRP	`/v1/vrp/{symbol}`	Full VRP dashboard with leak-free percentiles
Coverage	`/v1/tickers`	Loaded symbols and date ranges

No Look-Ahead Bias: Leak-Free Historical Percentiles

The feature that most historical options data services get wrong is the one that matters most for backtesting: no future leakage. If you ask FlashAlpha for VRP percentile at 2022-06-14T15:30:00, the percentile is computed only from rows dated before 2022-06-14. The percentile at that moment reflects what was knowable at that moment.

Most backtests silently cheat. If your "historical VRP percentile" uses a percentile computed against the full 2018–2026 dataset, every 2019 observation is scored against knowledge that didn't exist in 2019. That's look-ahead bias. It inflates Sharpe ratios. It makes dead strategies look live.

FlashAlpha's Historical API makes the honest version the default — it's actually harder to cheat than to do it right. Deep dive on leak-free percentiles →

How to Backtest a GEX-Regime Options Strategy With Python

Every strategy that conditions on dealer positioning ("short premium when dealers are long gamma", "fade gaps when GEX is negative", "buy straddles when we cross gamma flip") needs historical regime labels per minute. That's /v1/exposure/summary/{symbol} replayed across your training window.

import httpx, pandas as pd

API_KEY = "..."
dates = pd.bdate_range("2022-01-01", "2024-12-31")
rows = []
for d in dates:
    ts = d.strftime("%Y-%m-%dT15:30:00")
    r = httpx.get(
        "https://historical.flashalpha.com/v1/exposure/summary/SPY",
        params={"at": ts},
        headers={"X-Api-Key": API_KEY},
    ).json()
    rows.append({
        "date": d,
        "net_gex": r["exposures"]["net_gex"],
        "regime": r["regime"],
        "gamma_flip": r["gamma_flip"],
        "spot": r["underlying_price"],
    })

df = pd.DataFrame(rows)
# Join next-day returns, condition on regime, measure edge

That's the full research dataframe. Join forward returns, condition on regime, measure the edge.

Using Historical Dealer Positioning as ML Features

For machine-learning workflows, the Historical API is the feature store you were about to build yourself. Every minute of SPY since 2018-04-16 gives you net GEX, gamma flip distance, VRP z-score, net DEX, 0DTE contribution, vol surface shape, macro regime — about 40 dealer-positioning features per timestamp, all aligned to a single at key.

The numbers:

8 years × 252 trading days × 390 minutes ≈ 786K minute-level sample rows for SPY alone
~40 features per row → roughly 31 million feature observations
Walk-forward percentiles and z-scores included — no leakage in your training set

Pull the grid you want — daily close, half-hourly, or every minute — dump to parquet, and feed into XGBoost, a tabular transformer, or whatever architecture you prefer. Before FlashAlpha, assembling this with correct greeks and leak-free percentiles was a multi-engineer, multi-quarter project. Now it's a weekend script.

Historical Options Data Coverage and Pricing


Symbols	SPY (more backfill on request)
Date range	2018-04-16 → today (extended each pipeline run)
Option rows	6.7 billion
Stock minute-bars	2 million+
Intraday granularity	1 minute (quotes + greeks + spot)
EOD layer	Open interest, SVI params, forwards, macro
Minimum tier	Alpha ($1,499/mo)
Base URL	`https://historical.flashalpha.com`

Authentication uses the same X-Api-Key as the live API. GET /v1/tickers returns loaded symbols, date ranges, and any pipeline gaps — self-describing coverage so you never waste a call.

Validate Historically, Deploy Live — Same Response Shape

The historical and live services share the calculator layer. When a bug gets fixed, it's fixed in both places the same day. When a field gets added to the live response, it appears historically too.

That means you can validate strategies historically and deploy them live without a rewrite. Same response shape, same field names, same regime labels, same interpretation text. The deploy is a config flip: swap the base URL from historical.flashalpha.com to api.flashalpha.com and change at to "now."

Known Gaps in Historical Coverage

A small number of live fields aren't reconstructible historically:

Minute-level volume: not stored; volume fields return 0. Greeks, bid/ask, and OI all populated normally.
VIX futures and CNN Fear & Greed: external sources not archived; return null.
Option bid/ask sizes: not carried at minute resolution. Bid/ask prices are populated.
Prior-day OI diffs in narrative.top_oi_changes: not computed yet; empty array.
svi_vol per contract in /v1/optionquote: SVI params are at the expiry level; implied_vol (BSM) is populated.

None of these affect the core exposure, VRP, or volatility surface workflows.

Get Started With Historical Options Data

📄 Full Historical API Spec
🔍 Check Symbol Coverage
💰 Pricing & Upgrade to Alpha
📊 Leak-Free VRP Percentiles — methodology deep dive
🧪 GEX Backtesting Walkthrough
📉 SPY March 16, 2020 — COVID crash replay

Originally published at flashalpha.com.

Max Pain in Options: The Math, the Mechanics, and How to Query It via API

tomasz dobrowolski — Thu, 09 Apr 2026 06:18:15 +0000

If you've ever watched SPY drift inexplicably toward a specific strike on expiration Friday — no news, no catalyst — you've seen max pain in action.

This post explains what max pain is, how it's calculated, why it works mechanically, and how to pull it programmatically.

What Is Max Pain?

Max pain is the strike price where the total intrinsic value paid out across all open option contracts is minimised. In other words: the settlement price where dealers keep the most premium.

The calculation iterates over every possible settlement price and sums the payouts:

Pain(K) = Σ max(K - K_put, 0) × OI_put + Σ max(K_call - K, 0) × OI_call

The strike K that minimises Pain(K) is max pain. The inputs are just open interest by strike — calls and puts separately.

Why Does Price Move Toward It?

Delta hedging. When dealers sell options, they hedge by trading the underlying. Near expiration, gamma spikes — delta changes rapidly with small price moves, so dealers must rebalance aggressively.

In positive gamma, this creates mean-reversion: dealers buy dips, sell rallies. The net effect pulls price toward the highest-OI strike cluster, which tends to be max pain.

Not a conspiracy. An emergent outcome of mechanical hedging.

Querying Max Pain via API

FlashAlpha computes max pain in real time for 6,000+ US equities and ETFs. One call gives you everything:

curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/maxpain/SPY"

Response:

{
  "max_pain_strike": 545,
  "distance": { "percent": 0.61, "direction": "above" },
  "dealer_alignment": {
    "alignment": "converging",
    "gamma_flip": 546,
    "call_wall": 555,
    "put_wall": 538
  },
  "pin_probability": 68,
  "regime": "positive_gamma",
  "pain_curve": [ ... ],
  "max_pain_by_expiration": [
    { "expiration": "2026-04-11", "max_pain_strike": 547, "dte": 2, "total_oi": 520000 },
    { "expiration": "2026-04-17", "max_pain_strike": 545, "dte": 8, "total_oi": 1840000 }
  ]
}

Python Example

import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://lab.flashalpha.com"

resp = requests.get(
    f"{BASE}/v1/maxpain/SPY",
    headers={"X-Api-Key": API_KEY}
)
data = resp.json()

print(f"Max Pain: ${data['max_pain_strike']}")
print(f"Distance: {data['distance']['percent']:.1f}% {data['distance']['direction']}")
print(f"Pin Probability: {data['pin_probability']}/100")
print(f"Alignment: {data['dealer_alignment']['alignment']}")
print(f"Regime: {data['regime']}")

# Single expiry
resp = requests.get(
    f"{BASE}/v1/maxpain/SPY?expiration=2026-04-17",
    headers={"X-Api-Key": API_KEY}
)
print(f"April 17 Max Pain: ${resp.json()['max_pain_strike']}")

Install the SDK

pip install flashalpha

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
mp = fa.maxpain("SPY")
print(f"Max Pain: {mp['max_pain_strike']}, Pin: {mp['pin_probability']}/100")

Key Fields Explained

pin_probability (0–100): Combines OI concentration (30%), proximity to current price (25%), time to expiry (25%), and gamma magnitude (20%). Above 70 = strong pin conditions.

dealer_alignment: Shows whether max pain converges with GEX levels (gamma flip, call/put walls). "Converging" is the strongest signal — hedging flows and payout minimisation point the same direction.

pain_curve: The full payout curve across all strikes. A steep V = strong pin. Flat = weak pin. Asymmetric = directional skew in the pinning pressure.

max_pain_by_expiration: Per-expiry breakdown. The expiry with the most OI has the strongest gravitational pull. Useful for spotting step-downs when weeklies roll off.

Combining With Other Endpoints

Max pain is most useful layered with exposure data:

Endpoint	What It Adds
`/v1/exposure/gex`	Per-strike gamma — where hedging pressure concentrates
`/v1/exposure/levels`	Gamma flip, call/put walls — confirms or contradicts the pin
`/v1/exposure/zero-dte`	0DTE pin risk and expected move on expiration day
`/v1/exposure/summary`	Regime (positive/negative gamma), net dealer exposures

When Max Pain Doesn't Work

Negative gamma regime — dealers amplify moves instead of dampening them
Earnings / FOMC / CPI — directional flow overwhelms hedging
Low OI — small caps with thin chains won't pin
OI shifts — max pain from Monday can be stale by Thursday; always use fresh data

Free vs. Growth

The free tier (/v1/exposure/levels) includes the max pain strike — just the number. The Growth plan ($299/mo, 2,500 req/day) unlocks the full /v1/maxpain endpoint: pain curve, pin probability, dealer alignment, multi-expiry calendar, and expected move context.

The difference: knowing max pain is $545 vs. knowing it's $545 with a 72/100 pin probability, converging dealer alignment, and price within the expected move.

Links:

FlashAlpha | Options Analytics API - Greeks, Exposure & Vol Surfaces

Real-time options analytics API - Greeks, gamma exposure, SVI vol surfaces for 6,000+ underlyings. Free tier available.

flashalpha.com

Volatility Surface API: How to Build, Visualize, and Trade the IV Surface with Code

tomasz dobrowolski — Wed, 08 Apr 2026 20:14:23 +0000

Black-Scholes assumes one volatility number applies to every option on a stock. That's wrong. A $500 SPY put expiring Friday trades at 65% IV. A $700 call expiring in six months trades at 22%. Same underlying, wildly different volatilities.

The volatility surface captures this reality — a 3D map of implied volatility across strike prices and expiration dates. If you trade anything beyond naked calls and puts, you need it. It's the single most important data structure in options.

What the Surface Looks Like

Three slices have names you've probably heard:

Volatility skew — IV across strikes at one expiry. For equities, OTM puts trade at higher IV than OTM calls because institutions buy downside protection.
Term structure — ATM IV across expirations. Usually upward-sloping (contango). When it inverts, the market is screaming "event ahead."
The full surface — the complete 3D object. What SVI models fit, what arbitrageurs scan, and what every vol desk monitors in real time.

Why It Changes How You Trade

Find mispriced options. The SVI model fits a smooth curve through noisy market IVs. Any contract significantly above the curve is rich — sell it. Below the curve — buy it. A 3-vol-point residual on a 30-DTE SPY option translates to roughly $0.50 of edge per contract.

Time your calendar spreads. The term structure tells you when near-term vol is cheap relative to far-term. Steep contango = sell the front month, buy the second month.

Read fear in real time. 25-delta skew above 6 vol points = the market is paying up for crash protection. Above 9 = extreme fear. Below 3 = complacency.

How a Vol Surface Is Constructed

Step 1: Pull the raw option chain

You need every listed contract with live bid/ask quotes, open interest, and volume. Last-trade prices are useless — options are illiquid.

import requests

resp = requests.get(
    "https://lab.flashalpha.com/optionquote/SPY",
    headers={"X-Api-Key": "YOUR_API_KEY"}
)
chain = resp.json()
print(f"{len(chain)} contracts loaded")
# Output: 13710 contracts loaded

Each contract returns enriched with Greeks, IV (from mid price), and SVI-fitted IV.

Step 2: Solve for implied volatility

Newton-Raphson root-finding on Black-Scholes: "what volatility produces this market price?" Edge cases that trip up every team:

Deep ITM options — almost no extrinsic value, solver converges to garbage. Use OTM only.
Penny options (bid=0, ask=$0.01) — can't meaningfully solve. Require bid > 0.
Forward price vs. spot — using spot instead of dividend-adjusted forward makes near-ATM call IVs systematically wrong. The #1 implementation bug.

Step 3: Filter the noise

Filter	Threshold	Why
Zero bid	bid = 0	No real market
Wide spread	spread/mid > 50%	Too much uncertainty
Low OI	OI < 10	Price may be stale
Extreme moneyness	\	delta\
ITM options	Use OTM only	Solver instability

Step 4: Fit SVI

Raw IVs are still noisy. You need a smooth, arbitrage-free curve through them.

SVI: The Industry Standard

The Stochastic Volatility Inspired model was introduced by Jim Gatheral in 2004. Five parameters, each with clear intuition:

w(k) = a + b * ( rho * (k - m) + sqrt( (k - m)^2 + sigma^2 ) )

Parameter	What It Controls
`a`	Overall variance level
`b`	Wing steepness
`rho`	Skew direction (negative = put skew)
`m`	Horizontal shift of minimum variance
`sigma`	ATM curvature

Why SVI dominates:

Arbitrage-free by construction with Gatheral's constraints
Extrapolation to unlisted strikes
5 parameters vs. 50+ knots for cubic splines
SSVI extension handles the full surface across expiries

Get SVI parameters from an API

resp = requests.get(
    "https://lab.flashalpha.com/v1/adv_volatility/SPY",
    headers={"X-Api-Key": "YOUR_ALPHA_KEY"}
)
data = resp.json()

for s in data["svi_parameters"][:5]:
    print(f"  {s['expiry']} ({s['days_to_expiry']:>3d} DTE): "
          f"a={s['a']:+.5f}  b={s['b']:.5f}  rho={s['rho']:+.3f}  "
          f"m={s['m']:+.5f}  sigma={s['sigma']:.5f}  "
          f"ATM_IV={s['atm_iv']:.1f}%")

Symbol: SPY, Spot: $658.29
  2026-04-09 (  2 DTE): a=-0.00021  b=0.00920  rho=+0.032  ATM_IV=37.5%
  2026-04-10 (  3 DTE): a=+0.00012  b=0.00781  rho=-0.041  ATM_IV=32.1%
  2026-04-14 (  7 DTE): a=+0.00089  b=0.00534  rho=-0.187  ATM_IV=26.4%
  2026-04-17 ( 10 DTE): a=+0.00112  b=0.00478  rho=-0.231  ATM_IV=24.8%

Notice rho gets more negative at longer tenors — put skew steepens as DTE increases.

Build a Vol Surface in 15 Lines of Python

import requests
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Public endpoint - no API key required
resp = requests.get("https://lab.flashalpha.com/v1/surface/SPY")
s = resp.json()

M, T = np.meshgrid(s["moneyness"], s["tenors"])
iv = np.array(s["iv"]) * 100

fig = plt.figure(figsize=(14, 8))
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(M, T, iv, cmap='plasma', alpha=0.85, edgecolor='none')
ax.set_xlabel('Log-Moneyness (k)')
ax.set_ylabel('Tenor (years)')
ax.set_zlabel('IV (%)')
ax.set_title(f'SPY Implied Volatility Surface')
ax.view_init(elev=25, azim=-45)
plt.tight_layout()
plt.savefig('spy_vol_surface.png', dpi=150)
plt.show()

The /v1/surface endpoint returns a 41-point moneyness grid × 37 tenor slices, SVI-fitted and interpolated. No filtering, no calibration, no edge cases.

Common Pitfalls

Using spot instead of forward price — OTM call IVs near ATM will be systematically wrong by 5-15 vol points. The #1 bug in homegrown SVI code.
Fitting ITM options — a $100 ITM call with $0.50 of time value breaks the IV solver.
Oversmoothing short-dated slices — 0-3 DTE options need special handling.
Ignoring calendar arbitrage — independent per-expiry SVI fits can produce total variance that decreases in time.
Not filtering by open interest — a strike with 2 contracts of OI will have meaningless IV.

Reading the Surface

Steep put skew (>6 vol points) = fear or hedging demand
Flat surface = complacency, usually precedes vol expansion
Term structure inversion = event premium (earnings, FOMC)
Large SVI residuals = mispricing candidates for vol arb

Five Strategies Powered by the Surface

Skew trades — sell rich OTM puts, buy cheap OTM calls when skew is extreme
Calendar spreads — sell front month in contango, buy second month
Vol arb from SVI residuals — buy contracts below the fitted curve, delta-hedge
Iron condors — flat skew + contango + positive gamma regime = ideal setup
Vanna-informed directional — vol compression + large positive vanna = mechanical bid for the underlying

The FlashAlpha Volatility API returns SVI parameters, gridded surfaces, skew metrics, and arbitrage flags for 6,000+ US equities and ETFs. The public /v1/surface endpoint requires no API key.

Originally published on flashalpha.com

0DTE Options Scanner API — Screen Same-Day Contracts by Delta, OI, and Gamma Regime

tomasz dobrowolski — Mon, 06 Apr 2026 15:13:21 +0000

0DTE options have become the dominant force in intraday market structure. On any given day, same-day expiry contracts on SPY alone can account for 40–50% of total options volume. The problem: scanning for actionable 0DTE setups across dozens of symbols requires pulling chains, filtering by delta and OI, checking gamma regime, and doing it all before the contracts decay to nothing.

I built this with one POST request.

Scanner vs endpoint — different questions

FlashAlpha has a dedicated 0DTE analytics endpoint that returns pin risk, expected move, and gamma regime for one symbol at a time. That's the right tool when you know which name you're trading.

A scanner answers a different question: which symbols have 0DTE setups worth looking at right now?

Instead of looping through 20+ symbols and merging client-side, one screener POST returns only the symbols — and only the contracts within those symbols — that match your criteria.

The key: cascading filters

When you combine stock-level, expiry-level, and contract-level conditions inside an AND group, the server cascades the filter downward. Non-matching children get pruned at each level, and symbols with zero survivors are dropped entirely.

For 0DTE, you set expiries.days_to_expiry = 0 to isolate same-day, then layer contract-level conditions on top:

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "expiries.days_to_expiry", "operator": "eq",  "value": 0 },
      { "field": "contracts.type",          "operator": "eq",  "value": "C" },
      { "field": "contracts.delta",         "operator": "gte", "value": 0.3 },
      { "field": "contracts.oi",            "operator": "gte", "value": 1000 }
    ]
  },
  "select": ["*"]
}

The response contains, for every symbol in your universe: only the 0DTE expiry, only the call contracts, only the ones clearing the delta and OI floor. No other expiries, no puts, no low-delta noise. The response is already shaped like the answer.

Five 0DTE scanner recipes

1. 0DTE call seller (positive gamma only)

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "regime",                   "operator": "eq",  "value": "positive_gamma" },
      { "field": "expiries.days_to_expiry",  "operator": "eq",  "value": 0 },
      { "field": "contracts.type",           "operator": "eq",  "value": "C" },
      { "field": "contracts.delta",          "operator": "gte", "value": 0.3 },
      { "field": "contracts.oi",             "operator": "gte", "value": 1000 }
    ]
  },
  "select": ["*"]
}

The regime = positive_gamma condition means you're only selling calls where dealers are dampening moves, not amplifying them. Rich theta, friendly regime, liquid contracts.

2. 0DTE put scanner

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "expiries.days_to_expiry",  "operator": "eq",      "value": 0 },
      { "field": "contracts.type",           "operator": "eq",      "value": "P" },
      { "field": "contracts.delta",          "operator": "between", "value": [-0.5, -0.2] },
      { "field": "contracts.volume",         "operator": "gte",     "value": 500 }
    ]
  },
  "select": ["*"]
}

Finds 0DTE puts that are actually trading (volume ≥ 500) in the 20–50 delta range. Useful for protective puts or speculative directional bets on names showing intraday weakness.

3. Negative-gamma 0DTE scanner (amplified move risk)

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "regime",                   "operator": "eq", "value": "negative_gamma" },
      { "field": "expiries.days_to_expiry",  "operator": "eq", "value": 0 }
    ]
  },
  "sort":   [{ "field": "net_gex", "direction": "asc" }],
  "select": ["symbol", "price", "regime", "net_gex", "gamma_flip", "zero_dte_net_gex", "zero_dte_pct_of_total"]
}

Surfaces names where 0DTE dealer gamma is negative, sorted by most-negative GEX. These are the names where intraday moves will be amplified by dealer hedging. Avoid selling premium here — or use them as breakout candidates where you buy directional 0DTE options and ride the gamma amplification.

4. ATM 0DTE straddle scanner

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "expiries.days_to_expiry",  "operator": "eq",      "value": 0 },
      { "field": "contracts.delta",          "operator": "between", "value": [-0.55, 0.55] },
      { "field": "contracts.oi",             "operator": "gte",     "value": 2000 },
      { "field": "atm_spread_pct",           "operator": "lte",     "value": 0.03 }
    ]
  },
  "select": ["*"],
  "limit": 10
}

The atm_spread_pct ≤ 0.03 stock-level filter prunes names with bad microstructure before the contract-level cascade runs. This is your 0DTE iron condor scanner: find which names have the liquidity for a same-day structure.

5. 0DTE + high GEX concentration

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "zero_dte_pct_of_total", "operator": "gte", "value": 0.3 },
      { "field": "expiries.days_to_expiry", "operator": "eq",  "value": 0 },
      { "field": "contracts.oi",            "operator": "gte", "value": 500 }
    ]
  },
  "sort":   [{ "field": "zero_dte_pct_of_total", "direction": "desc" }],
  "select": ["symbol", "price", "zero_dte_pct_of_total", "zero_dte_net_gex", "regime"]
}

Surfaces names where 0DTE options account for 30%+ of total gamma. These are the most "0DTE-driven" symbols today — pin risk is elevated, gamma acceleration is concentrated, and theta decay is extreme.

Python workflow: scan then drill

The pattern that works best: screener finds candidates, then the per-symbol 0DTE endpoint gives you pin risk and expected move for the ones you want to trade.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Step 1: scan for 0DTE call-selling candidates
scan = fa.screener(
    filters={
        "op": "and",
        "conditions": [
            {"field": "regime",                  "operator": "eq",  "value": "positive_gamma"},
            {"field": "expiries.days_to_expiry",  "operator": "eq",  "value": 0},
            {"field": "contracts.type",           "operator": "eq",  "value": "C"},
            {"field": "contracts.delta",          "operator": "gte", "value": 0.3},
            {"field": "contracts.oi",             "operator": "gte", "value": 1000},
        ],
    },
    select=["symbol", "price", "regime", "zero_dte_net_gex"],
    limit=5,
)

# Step 2: drill into top candidates
for row in scan["data"]:
    sym = row["symbol"]
    dte = fa.zero_dte(sym)
    print(f"\n{sym}:")
    print(f"  Pin risk:      {dte['pin_risk']['score']}/100")
    print(f"  Expected move: {dte['expected_move']['range_1_sigma']}")
    print(f"  Regime:        {dte['gamma_regime']['regime']}")

Two requests instead of N. The screener finds the best candidates; the 0DTE endpoint gives you pin risk, expected move, and dealer hedging detail for each one.

SDK support

The screener method is available in all five FlashAlpha SDKs (Python, JavaScript, .NET, Java, Go). No need to build the HTTP POST yourself.

# Python
fa.screener(filters=..., select=...)

// JavaScript
fa.screener({ filters, select })

// .NET
await client.ScreenerAsync(new ScreenerRequest { ... })

Full spec: Live Screener docs. More recipes: Screener Cookbook. Per-symbol 0DTE analytics: 0DTE endpoint.

The Live Screener is part of the FlashAlpha Real-Time Options Analytics API. Growth gives you 20 symbols with cascading 0DTE filters. Alpha unlocks ~248 symbols, formulas, and strategy scores. Free tier at 5 requests/day. Compare plans.

DEV Community: tomasz dobrowolski

I Backtested 96 SPY Put Credit Spread Strategies - Here's the Bug Log

The first lesson: mid-fill backtests are lying to you

The single biggest finding: SL=100% IS the strategy

The trap nobody warns you about: SL=200%

My fancy signal got beaten by a one-liner

Multi-DTE pooling cost me 9pp of CAGR

The bug log

The sizing layer

TL;DR

SPXW 0DTE: What Every Developer Building Options Tools Needs to Know

SPX, SPXW, XSP — the one that's actually 0DTE

Why it moves the tape

The gamma flip is the switch

The four numbers that actually matter

Pulling SPXW 0DTE from an API

SPXW vs SPY for 0DTE — developer-relevant differences

The TL;DR

I Backtested My Own GEX Product Across 8 Years of SPY. Most of It Is Just VIX.

What I tested

Naive GEX looks excellent

The control that changes the story

GEX × VIX double-sort

Exposure verdicts

Why they overlap

High-VIX regime test

Train/test stability

What traders should do with this

Limitations

How to reproduce

TL;DR

I Priced 18 Million SPY Put Spreads Across 8 Years. Every Bucket Was -EV. Every Year Made Money.

The headline numbers

Finding 1 — Every theoretical bucket is negative EV

Finding 2 — Realized P&L is positive almost everywhere

Finding 3 — Capital efficiency flips the verdict on short DTE

Finding 4 — Risk-adjusted: the best Sharpe isn't where you'd guess

Finding 5 — IV regime counter-intuitively favors crisis

Caveats that should be loud

How I reproduced this

TL;DR

Free GEX Data — Gamma Exposure Levels for 6,000+ US Tickers (No Signup, No Credit Card)

What "free" actually means

Hitting the API

Python SDK

One free-tier gotcha

How fresh the data is

Free vs paid — the honest comparison

MCP server, if you live in Claude/Cursor

Replay any minute of SPY options back to 2018 - historical GEX, DEX, VEX, CHEX in one API

TL;DR

Why a separate host instead of one URL with ?at=

The at parameter

Example: historical GEX at the COVID low

What moves per minute vs per day

No future leakage on VRP

Endpoints

Honest field coverage gaps

Coverage

Latency

Links

Backtesting Gamma-Exposure Strategies with Minute-Level Historical Data

What We're Testing

Step 1: Pull the Regime Labels

Step 2: Pull the Forward Returns

Step 3: Condition on Regime

Step 4: Stratify on GEX Magnitude

Step 5: Scale Up — Every Minute, Every Day

The Three Traps This Setup Avoids

1. Rolling-Percentile Leakage

2. End-of-Day Smearing

3. Survivorship in Symbol Selection

Going Beyond Regime Labels

What You Actually Pay For

Related

Look-Ahead Bias in Volatility Backtests — Why Most VRP Percentiles Silently Cheat (and How to Fix It)

What Is Percentile Leakage in Options Backtesting?

How to Compute Walk-Forward Percentiles Without Look-Ahead Bias

How FlashAlpha's Historical VRP API Avoids Look-Ahead Bias

How Much Does Look-Ahead Bias Inflate Your Sharpe Ratio?

Why a separate host instead of one URL with `?at=`

The `at` parameter

How the Historical Options API Works: The `at` Parameter