DEV Community: tomasz dobrowolski

How Much Does IV Drop After Earnings? Real Crush Numbers by Name

tomasz dobrowolski — Tue, 04 Aug 2026 07:54:53 +0000

If you are asking how much does IV drop after earnings, the honest answer is: it depends on the name, and the difference is measurable. This post puts real numbers on earnings IV crush using event-history data, then explains the mechanics that make META's crush three times NVDA's.

IV crush, defined in one paragraph: implied volatility before earnings contains a one-time jump premium for the announcement. The moment results are out, that uncertainty is resolved and the jump premium evaporates - ATM implied volatility drops discontinuously, typically at the next open. The size of the drop is the share of total option-implied variance that the event itself represented.

The measured distributions

From GET /v1/earnings/iv-crush/{symbol} on 2026-08-03, which returns the live expected-crush estimate plus the distribution over up to 20 past events:

Symbol	Median crush	P25	P75	Best event	Events	Next earnings
META	42.5%	41.0%	43.4%	46.5%	6	2026-10-27
AAPL	23.2%	20.4%	27.5%	28.6%	6	2026-10-28
NVDA	14.8%	14.1%	15.5%	16.8%	4	2026-08-26

Crush here is the percentage drop in ATM IV from the last pre-event reading to the first post-event reading, front expiry.

Honest footnotes: the samples are the platform's covered event history (four to six events per name at the time of writing, growing each quarter), and a zero in a distribution's worst column - both AAPL and META carry one - marks an event where the measured crush did not materialise in the data. The interquartile range is the robust read, not the extremes.

Why META crushes 3x harder than NVDA

Pre-event IV is a blend of two components: baseline diffusion (the vol the stock runs on ordinary days) and the event jump. The crush percentage is essentially the event's share of total implied variance. Two things drive it:

How large the expected jump is relative to baseline vol. META's post-earnings moves have repeatedly been double-digit percent against a baseline vol in the 30s - the event dominates the front expiry, so resolving it removes most of the IV. NVDA runs a high baseline vol (around 37% in early August 2026, three weeks before its report) with an implied move that is large in dollars but smaller relative to that baseline, so the event share - and the crush - is smaller.
Days to expiry at the event. The shorter the expiry, the larger the event's share of remaining variance, the more violent the crush. Weeklies crush hardest; a 60-day option barely notices.

The expected-move endpoint performs exactly this decomposition - splitting the front-expiry straddle into jump and diffusion using the pre/post-event term structure - which is what makes a live crush estimate possible before the event.

The ramp: expected crush grows into the event

Three weeks before NVDA's 2026-08-26 report, the live estimate read a modest expected crush (about 4% at the front expiry, pre-IV 42.5 against post-IV 40.8) - far below the 15% the distribution says the event delivers.

That is not a contradiction; it is the ramp. Event variance concentrates into the front expiry as the calendar rolls toward the report: with three weeks of ordinary trading days still in the expiry, the jump is a small share of total variance. By the week of the event, the front expiry is mostly jump, and the expected crush converges toward the historical distribution.

Watching the live estimate ramp against the historical median is the cleanest way to see whether this quarter's event premium is building rich or cheap relative to the name's own history.

Trading implications, honestly stated

Crush is not free money. The stock moves at the same moment the IV collapses, and whether short-premium structures win depends on implied vs realised move, not on the existence of crush. Measured separately across 70 events: the median event harvested a third of the implied move with a 67% win rate and a fat left tail.

The per-name crush distribution adds the structure-selection layer. Names with large, reliable crush and modest realised moves favour short-vega structures; names where the crush is small relative to gap risk favour defined-risk or long-gamma-into-ramp structures.

Pulling it yourself

import requests

for sym in ["AAPL", "META", "NVDA"]:
    r = requests.get(
        f"https://lab.flashalpha.com/v1/earnings/iv-crush/{sym}",
        headers={"X-Api-Key": KEY},
    ).json()
    est, dist = r["current_estimate"], r["distribution"]
    print(sym, r["earnings_date"],
          f"expected {est['expected_crush_pct']}%",
          f"median {dist['median']}%  p25 {dist['p25']}  p75 {dist['p75']}")

Per-event detail - EPS and revenue surprises, implied vs actual moves, realised crush per event - comes from the companion /v1/earnings/history/{symbol} endpoint, and the upcoming calendar from /v1/earnings/calendar.

FAQ

How much does IV drop after earnings on average?
Across the names measured here, median crush ranges from about 15% (NVDA) through 23% (AAPL) to 43% (META) of pre-event ATM IV at the front expiry. There is no useful single average: the number is a per-name property driven by the event's share of total implied variance, and it is stable enough per name to be worth looking up rather than guessing.

When exactly does IV crush happen?
At the resolution of the uncertainty: effectively instantaneous at the first quotes after the announcement (the next open for after-close reporters). The decay into the event is a separate, slower effect - the jump premium itself holds until the news is out.

Can you profit from IV crush by selling options before earnings?
Only when the implied move overprices the realised move - the crush and the gap arrive together. The measured base rate: about two-thirds of events pay the seller something, the median event pays a third of the implied move, and the tail events cost multiples of it.

Does IV crush affect all expirations equally?
No. Crush concentrates in the front expiry, where the event is the dominant share of remaining variance. Back-month IV barely moves, which is why calendar structures are one of the standard earnings expressions and why measuring crush requires expiry-matched pre/post readings.

Wrapping up

IV crush is real, large, and - the part almost nobody quantifies - radically different across names: the same mega-cap quarter produced a 15% median crush in NVDA and a 43% median crush in META. The distribution for any covered name is one API call, and the live estimate ramps against it into each event.

Originally published at flashalpha.com.

Gamma Scalping: The Complete Guide to Delta-Hedged Straddle P&L

tomasz dobrowolski — Tue, 04 Aug 2026 07:54:41 +0000

If you searched for gamma scalping - or for why your delta-hedged straddle made money on a day the market barely closed changed - this is the complete mechanical picture: the identity, the breakeven, the hedging tradeoffs, the entry conditions, and the data to run it on.

Gamma scalping, defined in one paragraph: gamma scalping is delta-hedging a long-gamma options position (typically an ATM straddle) so that each move in the underlying forces profitable re-hedges - buying dips and selling rips mechanically - while paying theta for the privilege. It converts an options position into a trade of realised volatility against the implied volatility you paid.

The identity that runs the whole strategy

Delta-hedge a long option continuously and the direction drops out. What remains, per small time step, is the canonical P&L decomposition:

dP&L ≈ ½ Γ S² (σ²realised − σ²implied) dt

Read it term by term. ½ΓS² is dollar gamma - how much delta the position manufactures per squared move. The bracket is the variance spread - realised variance delivered minus implied variance paid (the theta you bleed is the implied leg).

Everything about gamma scalping falls out of this line. You are not "trading options"; you are long realised variance and short implied variance, sized by dollar gamma. The strategy wins if, and only if, the underlying realises more than the options implied over the holding period. Re-hedging is merely the collection mechanism.

The same identity with the sign flipped is every premium seller's income statement, which is why realised vs implied is the spread that runs the entire volatility complex.

The breakeven, with live numbers

The intuitive version of the identity: each day, the position must move enough to pay that day's theta. For an ATM straddle the breakeven daily move is approximately:

breakeven ≈ S × IV / √252

On 2026-08-03, SPY closed at 758.34 with 30-day ATM implied vol around 13%. That prices a breakeven daily move of roughly 0.82%, or about 6.2 SPY points. Days that move more than that earn the long-gamma book money; days that move less bleed it.

And the regime context said bleed: VIX stood at 15.86 against an SPX 20-day realised of 12.48 - implied comfortably above realised, the normal volatility-risk-premium state in which the average long-gamma day loses. That single comparison is the entry gate for the whole strategy, and it is one API call (below).

The payoff curve is quadratic, because P&L tracks variance rather than the move itself.

Hedging frequency: the tradeoff nobody escapes

Hedge continuously and P&L converges to the identity with minimal noise - but transaction costs scale with the number of hedges and eat the edge.
Hedge rarely (daily, or at fixed delta bands) and costs drop, but P&L picks up path noise: you can realise high vol and still lose if the path whipsaws between your hedge points. The expected value is unchanged; the variance of outcomes grows.
Band-based hedging (re-hedge when delta drifts past a threshold) is the standard practical compromise, with bands widened as costs rise. On index products with tight markets the costs are manageable; on single names the spread cost per hedge is a first-order input.

One practical asymmetry: scalping into a gap is not optional. Overnight gaps deliver realised variance with no opportunity to hedge along the way - which is precisely why gap-heavy names (earnings season, biotech) are where long gamma pays best, and why realised-vol estimators that ignore overnight moves mislead. Use an estimator that handles the open.

When long gamma actually pays

The identity says: when realised beats implied. The measurable states where that happens:

Negative VRP episodes. The volatility risk premium is positive most of the time (that is the premium), but it inverts around shocks and regime breaks. A negative or deeply compressed VRP z-score is the systematic entry flag.
Pre-event ramps. Into earnings, implied rises but realised rises with it through the ramp; the post-event crush is the exit, not the trade.
Short-gamma dealer regimes. When the dealer complex is short gamma, forced hedging amplifies moves - realised vol runs hot relative to quiet-regime pricing.

The biggest gamma scalper in the market is the dealer complex

Here is the connection that makes gamma scalping more than a niche strategy. When dealers are net long gamma, the entire market-making complex is running this exact playbook at index scale - buying every dip and selling every rally to stay delta-neutral.

That mechanical flow is why long-gamma regimes pin and dampen markets, and why GEX - the aggregate dollar gamma of that complex, by strike - predicts intraday behaviour. When you gamma scalp, you are joining (or opposing) the largest systematic vol trader in existence, and the signed polarity of dealer gamma tells you which side they are on today.

Running the numbers on the API

import requests

BASE, H = "https://lab.flashalpha.com", {"X-Api-Key": KEY}

vrp = requests.get(f"{BASE}/v1/vrp/SPY", headers=H).json()
rv  = requests.get(f"{BASE}/v1/volatility/SPY", headers=H).json()

# The gate: is implied trading rich or cheap to realised?
# vrp payload carries the IV-RV spread, z-score and percentile;
# volatility payload carries the realised-vol estimators.
print(vrp)
print(rv)

The volatility endpoint carries the implied and realised series for the comparison. The VRP dashboard adds the z-score and percentile that place today's spread against the name's own history - the systematic version of the VIX-vs-realised eyeball test - and its historical counterpart replays the series point-in-time for backtests (SPY minute data from 2017-01-03). For per-strike dollar gamma to size the position, the greeks endpoint serves the chain live.

FAQ

What is gamma scalping in simple terms?
Buy a straddle so you make money if the stock moves either way. As it moves, keep flattening your directional exposure - selling some stock after rallies, buying after dips. Each flatten locks in profit from the move. If the stock moves around a lot, the locked-in profits exceed the daily cost of owning the options; if it goes quiet, they do not.

Is gamma scalping profitable?
Only when realised volatility exceeds the implied volatility you paid - which is the exception, not the rule, because implied usually carries a premium. Profitability is a timing question: the strategy pays around shocks, events, and short-gamma dealer regimes, and bleeds in the long calm stretches. Measure the spread before entering; do not run it as a permanent posture.

How often should you re-hedge?
There is no free choice: frequent hedging reduces path noise but multiplies transaction costs; infrequent hedging is cheaper but noisier. Delta bands with band width scaled to the name's spread cost is standard practice. The expected P&L is set by realised-vs-implied either way - hedging style mainly chooses your variance around it.

Is it the same as what market makers do?
Mechanically yes - dealers delta-hedge their books continuously, and when they are net long gamma the whole complex is gamma scalping against the market, which dampens volatility. The difference is intent: dealers hedge inventory they were paid a spread to carry; a gamma scalper chooses the position to express a realised-vol view.

Wrapping up

Gamma scalping is the cleanest expression of the only question in volatility trading: will realised beat implied? The identity ½ΓS²(RV²-IV²) decides the outcome, the breakeven daily move (about 0.82% for SPY at August 2026 pricing) makes it concrete, and the implied-vs-realised spread that gates the trade is one volatility call away.

Originally published at flashalpha.com.

I Charted 8 Years of SPY Skew History. The Folklore Is Backwards.

tomasz dobrowolski — Fri, 24 Jul 2026 07:09:17 +0000

The 25-delta skew is the implied volatility of the 25-delta put minus the implied volatility of the 25-delta call. In one number it tells you how much more the market is paying for downside protection than for upside participation. It is the cleanest single measure of the price of crash insurance.

You can look up today's value in about four seconds. Charting its history is close to impossible, and that is the interesting part.

To know what skew was on 13 March 2020 you need the whole option chain as it stood at that timestamp: strikes, quotes, and enough of the smile to interpolate to the 25-delta wings on both sides. Not a daily close, not a settlement file. The chain, at a minute, eight years ago. That data is rare enough that "what does skew normally do around selloffs" has stayed a folklore question rather than a data question.

So I rebuilt the series. Every Friday close from May 2018 through March 2026, 413 weeks. Then I tested the folklore, and it failed in a way that turns out to be more useful than if it had passed.

Method

Sample: 413 Friday closes (Thursday on holiday weeks), 2018-05-04 to 2026-03-27.
Source: GET /v1/stock/SPY/summary?at={date}, reading the volatility.skew_25d block, which carries the 25-delta put IV, the 25-delta call IV, and their difference on the front expiry, all derived from real point-in-time quotes.
Flavour: this is front-expiry skew, typically 2-5 DTE. It is the most reactive skew gauge there is. A 30-60 DTE series moves the same direction with smaller amplitude.
Forward returns: SPY close four weeks later against the sampling close.

Here is what one observation actually looks like, from the single most extreme week in the sample:

{
  "as_of": "2020-03-13T16:00:00",
  "price": { "mid": 270.96 },
  "volatility": {
    "skew_25d": {
      "expiry": "2020-03-16",
      "days_to_expiry": 3,
      "put_25d_iv": 87.19,
      "call_25d_iv": 59.87,
      "skew_25d": 27.32,
      "smile_ratio": 1.456
    }
  },
  "macro": { "vix": { "value": 57.83 } }
}

87 vol points bid for the put wing, 60 offered on the call wing, VIX at 57.8. That is what maximum fear looks like as a number.

Eight years of skew, by year

Year	Median skew (vol pts)	90th percentile	Regime
2018 (May+)	2.12	4.96	Vol-normalizing, Q4 bear
2019	1.82	3.93	Grind higher
2020	3.21	7.71	Covid crash and recovery
2021	2.72	5.00	Bull with crash memory
2022	2.36	4.72	Bear market
2023	1.22	1.96	Skew collapse, 0DTE era
2024	1.30	2.21	Grind, brief August shock
2025	2.55	4.14	Tariff shock and recovery
2026 (Q1)	3.20	4.99	Elevated hedging demand

Two regime stories fall out of this table immediately.

The 2023-24 skew collapse is the one nobody talks about. Median front skew halved against every earlier year in the sample. That is the fingerprint of the 0DTE era: systematic call overwriting and relentless daily premium selling compressed the put wing's relative price for two full years. Crash insurance was on sale, and it stayed on sale long enough that people stopped noticing.

And 2026 Q1's median of 3.20 is running at essentially Covid-year levels. That is the market's standing bid for downside protection right now.

The ten most extreme prints, 2018-2026

Date	Skew (vol pts)	VIX	Context
2020-03-13	27.32	57.8	Covid crash, pre -12% Monday
2020-03-20	13.71	66.0	Crash week 4
2020-03-06	11.26	41.9	Crash week 2
2021-01-29	10.76	33.1	Meme-stock degrossing week
2025-04-04	9.24	45.3	Tariff shock
2020-10-30	8.07	38.0	Pre-election hedging peak
2018-10-26	8.03	24.2	October 2018 selloff
2020-03-27	7.95	65.5	First rebound week
2020-02-28	7.82	40.1	Crash week 1
2020-04-03	7.29	46.8	Bottom week

Read the Context column and notice what is missing. There is not one quiet week in this table. Every extreme print landed during a stress event, never before one.

That observation is what the next section formalizes.

The folklore test

The received wisdom is that elevated skew is a warning. Smart money is buying puts, position accordingly.

I split all 413 weeks at the 90th skew percentile and measured SPY's return over the following four weeks:

Condition	Weeks	Median 4-week forward return
Top-decile skew	42	+2.74%
All other weeks	371	+1.61%

The folklore fails, and it fails informatively. Extreme skew did not predict drawdowns. It marked weeks where fear was already fully priced, which pushed forward returns higher, not lower.

The mechanism is obvious once you have looked at the top-10 table. Skew explodes when everyone is bidding for puts simultaneously, and that happens mid-panic, near capitulation. By the time crash protection is historically expensive, most of the crash has already happened. You are not being warned. You are being billed.

Rebuild it

One call per date:

curl -H "X-Api-Key: $FLASHALPHA_KEY" \
  "https://historical.flashalpha.com/v1/stock/SPY/summary?at=2020-03-13"

The whole series plus the forward-return split:

import requests
import pandas as pd

HEADERS = {"X-Api-Key": "YOUR_API_KEY"}
BASE = "https://historical.flashalpha.com/v1"


def week_row(date: str) -> dict:
    s = requests.get(
        f"{BASE}/stock/SPY/summary",
        params={"at": date},
        headers=HEADERS,
    ).json()

    skew = s["volatility"]["skew_25d"]
    return {
        "date": date,
        "skew": skew["skew_25d"],
        "put_25d_iv": skew["put_25d_iv"],
        "call_25d_iv": skew["call_25d_iv"],
        "dte": skew["days_to_expiry"],
        "close": s["price"]["mid"],
        "vix": s["macro"]["vix"]["value"],
    }


dates = pd.date_range("2018-05-04", "2026-03-27", freq="W-FRI").strftime("%Y-%m-%d")
df = pd.DataFrame([week_row(d) for d in dates])

df["fwd_4w"] = df["close"].shift(-4) / df["close"] - 1

cut = df["skew"].quantile(0.90)
top, rest = df[df["skew"] >= cut], df[df["skew"] < cut]

print(f"cutoff:           {cut:.2f} vol pts")
print(f"top-decile weeks: {len(top):>3}  median 4w fwd {top.fwd_4w.median():+.2%}")
print(f"all other weeks:  {len(rest):>3}  median 4w fwd {rest.fwd_4w.median():+.2%}")
print(df.nlargest(10, "skew")[["date", "skew", "vix"]].to_string(index=False))

Obvious extensions, all one-line edits: resample to daily instead of weekly to catch intraweek spikes, swap in a fixed-DTE expiry from iv_term_structure for a less twitchy series, or condition the forward-return split on VIX regime rather than skew percentile.

What skew history is actually for

Since it does not warn you, here is what it does do.

Hedge-cost timing. The yearly table is a price chart for protection. Buying puts in 2023 (median 1.22) cost half what the same insurance cost in 2021. The time to own hedges is when skew is compressed, which is precisely when nobody wants them.

Contrarian context at extremes. Top-decile skew has historically been a better moment to start scaling into risk than out of it. Not a signal on its own. Useful context against a signal you already have.

Regime identification. A persistent shift in median skew, like 2023's collapse or 2026's elevation, says the options market has structurally re-priced tail risk. Strategy mix should follow.

Put-spread design. When skew is fat, put spreads that sell the inflated lower wing beat outright puts. When skew is flat, outright puts are the better hedge. The history tells you which regime you are standing in.

Honest limitations

Weekly Friday sampling misses intraweek skew spikes that resolved by the close. Front-expiry skew is deliberately twitchy; a 30-60 DTE series shows the same regimes with smaller amplitudes. And the forward-return split is descriptive, not a hypothesis test: 42 extreme weeks clustered into a handful of episodes is nowhere near 42 independent observations. March 2020 alone contributes five of the top ten.

I would rather state that plainly than dress up a five-episode sample as statistics.

Conclusion

Eight years of history replaces two pieces of folklore with two usable facts.

Skew does not warn. It confirms, loudly, at the worst possible price.

And skew regimes persist for years, which makes the level chart actionable in a way the daily print never is: cheap-skew years are when hedges should be accumulated, fat-skew weeks are when they should be monetized or spread.

Both facts were invisible until the history existed. Pull any week and check.

Originally published at flashalpha.com. Endpoint docs here; the archive replays any minute back to January 2017.

Are 0DTE Straddles Overpriced? I Replayed 193 SPY Sessions to Find Out

tomasz dobrowolski — Fri, 24 Jul 2026 06:59:04 +0000

"0DTE straddles are overpriced" is the most repeated claim in options trading since daily expirations took over SPY volume. It is also completely testable, and almost nobody tests it, because doing so needs something awkward: the state of the option chain at a specific minute on thousands of past days. Daily OHLC bars will not do it. You need point-in-time quotes.

So I replayed 193 Wednesday sessions from July 2022 through April 2026, snapshotting the SPY same-day straddle at 10:00 ET and comparing what it implied against what SPY actually did into the close.

Here is the method, the numbers, and a script that reproduces the whole thing.

Method

Sample: every Wednesday from 2022-07-06 to 2026-04-01 with a SPY 0DTE expiry and complete data. 193 sessions, holidays excluded.
Snapshot: GET /v1/exposure/zero-dte/SPY?at={date}T10:00:00, which returns the ATM straddle price and the implied 1-sigma move built from real minute-level NBBO quotes.
Realized: the 16:00 ET quote mid against the 10:00 spot. That is the move the 10:00 straddle actually had to survive.
Benchmarks: this is the part people skip. A fairly priced 1-sigma move contains the close about 68.3% of the time, and the median absolute move of a normal variable is about 0.674 sigma. Richness gets measured against those numbers, not against zero.

That last point matters. A straddle that "contains the close 71% of the time" sounds like nothing until you know the fair-value number is 68.3%.

The headline numbers

Metric	Measured	If fairly priced
Close inside the 10:00 implied 1-sigma band	71.0% of sessions	~68.3%
Sessions where realized move exceeded implied 1-sigma	25.9%	~31.7%
Median of realized move / implied move	0.589	~0.674
Median implied 1-sigma move (10:00 ET)	0.72% of spot	-
Median absolute realized move (10:00 to close)	0.37%	-

Every line points the same way. The 10:00 straddle priced in slightly more movement than SPY delivered. Realized moves ran roughly 13% below the fair-value benchmark (0.589 against 0.674), the band held about 3 points more often than chance, and breaches happened about 6 points less often than fair pricing implies.

That is a volatility risk premium, alive and measurable at the daily horizon. It is also small. Anyone selling you a "0DTE is free money" course is describing a 13% markup.

Is the edge stable?

The obvious follow-up: 0DTE volume exploded over this window. Did the premium get arbitraged away?

Year	Sessions	Hit rate (inside 1-sigma)	Median implied	Median abs realized
2022 (H2)	26	69.2%	1.17%	0.73%
2023	52	69.2%	0.73%	0.49%
2024	50	70.0%	0.60%	0.32%
2025	52	71.2%	0.62%	0.39%
2026 (Q1)	13	84.6%	0.71%	0.26%

No. The hit rate sits in a tight 69-71% band across four genuinely different vol regimes: the 2022 bear, the 2023-24 grind, the 2025 tariff shock. The absolute level of implied vol moved a lot. The markup did not.

The caveat that pays for everything

The worst session in the sample was April 9, 2025. Here is the actual snapshot, unedited:

{
  "symbol": "SPY",
  "underlying_price": 499.84,
  "as_of": "2025-04-09T10:00:00",
  "time_to_close_hours": 6,
  "expected_move": {
    "implied_1sd_dollars": 17.5691,
    "implied_1sd_pct": 3.5149,
    "straddle_price": 13.47,
    "atm_iv": 1.290367,
    "upper_bound": 516.7198,
    "lower_bound": 482.9602
  }
}

A 3.51% one-sigma move. Already enormous, ATM IV at 129%, mid tariff panic. The market was not asleep.

SPY closed at 543.44 on the tariff-pause headline. That is +8.72%, roughly 2.5x the implied move, and about 27 points above the upper bound the chain had priced at 10:00.

A naked short straddle sized to "collect the premium" that morning gave back weeks of harvest in one afternoon.

This is the whole seller's bargain in one line: about 74% of sessions the implied move is too big, about 26% it is too small, and a handful of those are catastrophically too small. The premium exists precisely because someone has to hold that tail. Selling it naked is a leverage decision, not an edge decision. Defined-risk structures (iron flies, condors) monetize the same overpricing with a worst case you survive.

Reproduce it

Two calls per session. First the 10:00 snapshot, then the close:

curl -H "X-Api-Key: $FLASHALPHA_KEY" \
  "https://historical.flashalpha.com/v1/exposure/zero-dte/SPY?at=2025-04-09T10:00:00"

curl -H "X-Api-Key: $FLASHALPHA_KEY" \
  "https://historical.flashalpha.com/v1/stockquote/SPY?at=2025-04-09T16:00:00"

The full study is about thirty lines:

import requests
import pandas as pd

HEADERS = {"X-Api-Key": "YOUR_API_KEY"}
BASE = "https://historical.flashalpha.com/v1"


def session_row(date: str):
    zd = requests.get(
        f"{BASE}/exposure/zero-dte/SPY",
        params={"at": f"{date}T10:00:00"},
        headers=HEADERS,
    ).json()

    if zd.get("no_zero_dte"):
        return None  # no same-day expiry, skip

    close = requests.get(
        f"{BASE}/stockquote/SPY",
        params={"at": f"{date}T16:00:00"},
        headers=HEADERS,
    ).json()

    spot_10 = zd["underlying_price"]
    implied_pct = zd["expected_move"]["implied_1sd_pct"]
    realized_pct = (close["mid"] - spot_10) / spot_10 * 100

    return {
        "date": date,
        "implied_pct": implied_pct,
        "realized_pct": realized_pct,
        "ratio": abs(realized_pct) / implied_pct,
        "inside_band": abs(realized_pct) <= implied_pct,
    }


dates = pd.date_range("2022-07-06", "2026-04-01", freq="W-WED").strftime("%Y-%m-%d")
df = pd.DataFrame([r for d in dates if (r := session_row(d))])

print(f"sessions:     {len(df)}")
print(f"hit rate:     {df.inside_band.mean():.1%}   (fair value 68.3%)")
print(f"median ratio: {df.ratio.median():.3f}   (fair value 0.674)")
print(f"worst miss:   {df.ratio.max():.2f}x on {df.loc[df.ratio.idxmax(), 'date']}")

The interesting variations are one-line edits:

Change T10:00:00 to T11:30:00 or T14:00:00 and measure how the premium decays across the session. time_to_close_hours is computed from your timestamp, so the maths stays consistent.
Split by vol_context.vix to see whether the markup is regime-dependent.
Swap W-WED for B to cover every business day instead of one per week.

Honest limitations

Wednesdays only, so one session per week. That avoids weekday-mix effects but samples less than it could. The close is measured against the 10:00 spot, not the intraday high and low that a gamma scalper actually cares about. Quote mids, no fees or slippage. 2026 is a partial year, and its 84.6% hit rate is 13 sessions, so read it as noise until it is not.

FOMC Wednesdays stay in the sample. Worth noting on its own: straddles on Fed days priced roughly double the neighbouring weeks, and the market largely respected them.

The conclusion

The 0DTE volatility risk premium is real, stable, and small. The market pays about a 13% markup on daily movement, session after session, year after year, and that markup is fully earned by whoever eats the April 9ths.

If you trade this, the practical output is a number rather than a slogan: the implied move is wide about 74% of the time, and the way to collect that without donating it back is defined risk and honest sizing.

Rerun it, change the snapshot hour, slice it by VIX regime. Every endpoint replays back to January 2017.

Originally published at flashalpha.com. The historical replay endpoints are documented here.

12 Things You Can Do with a Minute-Level Historical Options Data API

tomasz dobrowolski — Tue, 21 Jul 2026 19:13:09 +0000

Originally published on flashalpha.com.

What can you actually do with historical options data? In practice: backtest strategies against real bid/ask quotes, measure whether 0DTE straddles are systematically overpriced, rebuild IV rank and skew history, test whether GEX walls and max pain actually hold, and replay crisis days minute by minute.

FlashAlpha Historical stores 80+ billion minute-level option rows across 200+ symbols — 26 of them fully analytics-ramped (SPY, QQQ, SPX/SPXW, XSP, IWM, TSLA, NVDA and more) — plus 23M+ stock minute-bars, with coverage from January 2017 onward. Every live analytics endpoint can be replayed at any minute in that window via a single at= parameter.

Here are 12 projects, most impactful first, each with the exact endpoint behind it.

1. Pull the full option chain as it looked at any minute since 2017

The foundational primitive: /v1/optionquote returns every SPY contract's bid, ask, mid, implied vol, full BSM greeks (delta, gamma, theta, vega, rho, vanna, charm), and open interest exactly as they stood at any minute between 09:30 and 16:00 ET on any trading day since January 3, 2017. No reconstruction on your side — one call, one as-of chain.

curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://historical.flashalpha.com/v1/optionquote/SPY?at=2026-03-05T15:30:00&expiry=2026-03-06&strike=680&type=C"

Everything else on this list is built on top of this call.

2. Backtest strategies against real bid/ask quotes, not theoretical fills

Most options backtests die on fills: they price entries at a theoretical mid that never existed, on a dead contract with a $2 wide market. Because the archive stores the actual NBBO at minute resolution, you can enter at the real ask and exit at the real bid.

Two filters, maxSpreadPct and maxSpreadAbs, drop wide "ghost quotes" on illiquid contracts before they poison your fill model, and structurally invalid quotes (crossed or one-sided markets) are always removed. The X-Filtered-Out response header tells you exactly how many contracts were vetoed.

# Liquidity gauntlet: max 8% relative spread AND max $0.25 absolute spread
curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://historical.flashalpha.com/v1/optionquote/SPY?at=2026-03-05T15:30:00&expiry=2026-03-06&maxSpreadPct=0.08&maxSpreadAbs=0.25"

Worked example on this data: SPY Put Credit Spread Matrix: 8-Year Backtest — theoretical vs realized P&L across strikes and DTEs.

3. Test whether 0DTE straddles are systematically overpriced

The most-asked 0DTE question has a testable answer. /v1/exposure/zero-dte returns the same-day straddle price and the implied 1-sigma expected move at any minute — and time_to_close_hours is computed from your at= timestamp, so the remaining expected move is accurate to the minute.

Pull it at 10:00 ET every day for a few years, compare the implied move to the realized close-to-close move, and you have a distribution of implied-vs-realized 0DTE moves: the raw material for deciding whether selling (or buying) the same-day straddle carries edge, and at which time of day. The same endpoint returns pin risk, magnet strikes, OI concentration, and 0DTE share of total gamma for every historical session.

We ran this exact study across 193 sessions: Are 0DTE Straddles Overpriced?

4. Replay March 16, 2020 minute by minute

The best read in the archive. At 15:30 ET on the day SPY closed down 12%, the historical API shows spot at 246.01, dealers short gamma with net GEX at -$2.8B, net delta exposure at -$173B, and vanna exposure at +$154B — the exact mechanical setup that amplified every move into the close.

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

Replaying days like this — Covid, the 2022 bear legs, the August 2024 vol shock — is the cheapest regime-recognition training a discretionary trader can buy: you watch positioning deteriorate in real data instead of reading about it afterward.

5. Build an ATM IV time series and IV rank history

Walk at= forward one trading day at a time (a bare date defaults to the 16:00 ET close) against /v1/stock/{symbol}/summary and you get ATM IV, HV20, HV60, VRP, and skew in one call per day — an instant IV time series without stitching vendors together. IV rank and IV percentile history fall out in a few lines of pandas:

import httpx, pandas as pd
from tqdm import tqdm

API_KEY = "..."
BASE = "https://historical.flashalpha.com"
dates = pd.bdate_range("2019-01-01", "2026-06-30")

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/stock/SPY/summary", params={"at": d.strftime("%Y-%m-%d")})
        if r.status_code != 200: continue
        v = r.json()["volatility"]
        rows.append({"date": d, "atm_iv": v["atm_iv"], "hv_20": v["hv_20"], "vrp": v["vrp"]})

iv = pd.DataFrame(rows).set_index("date")
iv["iv_rank_252d"] = iv["atm_iv"].rolling(252).apply(
    lambda w: (w.iloc[-1] - w.min()) / (w.max() - w.min()) * 100)
# rolling window only sees the past: the rank series is walk-forward by construction

The same loop, pointed at a 10:00 ET timestamp instead of the close, gives you a morning IV series — useful for entry-time studies. You can finally answer "was 18 vol actually cheap in March 2026?" with data instead of memory.

6. Reconstruct a 25-delta skew history

The same daily walk gives you skew_25d — put wing IV minus call wing IV at 25 delta — straight from the summary response, or per-expiry skew profiles from /v1/volatility. Chart it through 2018–2026 and every stress regime is visible — though when we ran the study across 413 weeks, the "early warning" folklore failed in an interesting way: SPY 25-Delta Skew History.

7. Build a volatility cone from 8 years of realized vol

A volatility cone needs one thing: a long, clean daily price history. /v1/stock/{symbol}/prices returns up to 2000 daily OHLC bars per call, and /v1/volatility serves the realized-vol ladder (5/10/20/30/60-day) computed on it at any historical date. Compute rolling realized vol at each horizon, take percentile bands, and you have the cone: today's IV plotted against where realized vol has actually lived at that horizon. The fastest sanity check for "is vol cheap or rich right now."

Published result: The SPY Volatility Cone: 8 Years of Realized Vol Percentiles.

8. Backtest GEX regimes and test whether walls hold

Everyone quotes the GEX thesis — positive gamma dampens, negative gamma amplifies — but almost nobody tests it, because historical GEX barely exists as a product. With /v1/exposure/gex and /v1/exposure/levels you can pull the net GEX, gamma flip, call wall, and put wall for every session since 2017 and measure it directly: conditional next-day realized vol by regime, wall touch-and-reject rates, flip-cross behavior.

We ran a version ourselves: GEX, DEX, VEX, CHEX: 8-Year SPY/VIX Backtest.

9. Harvest the volatility risk premium with leak-free percentiles

The classic premium-selling rule — "sell when VRP percentile is above 80" — is only testable if the percentile at each historical date uses only data available at that date. /v1/vrp is date-bounded by construction: percentiles and z-scores at at= are computed exclusively from snapshots strictly before that date. No lookahead, no quiet inflation of your backtest Sharpe.

The endpoint also returns IV-RV spreads at four horizons, term VRP, GEX-conditioned harvest scores, and strategy scores per structure.

10. Watch the whole vol surface reprice through events

/v1/surface builds a 50×50 implied-vol grid over tenor and log-moneyness at any minute, and /v1/adv_volatility exposes the daily SVI parameters, forward prices, arbitrage flags, and variance-swap fair values behind it. Sample the surface at successive minutes through an event — a Fed day, an earnings-adjacent macro shock, the Covid crash — and you can animate how the smile twists and the term structure inverts in real time.

For vol researchers, per-expiry SVI parameter history (a, b, rho, m, sigma) since 2017 is a calibration dataset that is genuinely hard to find anywhere.

11. Measure whether max pain actually pins

Max pain is a theory with a testable prediction: price gravitates toward the strike that minimizes option-holder payout into expiration. /v1/maxpain returns the max pain strike, full pain curve, pin probability, and dealer alignment at any historical minute — so you can check the prediction against every expiry since 2017, split by OPEX vs daily expirations, and by whether dealer positioning agreed.

Published 534-day sample: SPY Max Pain History by Date.

12. Turn term-structure inversion into a risk signal

The IV term structure spends most of its life in contango; inversion is the market pricing near-term stress. The historical stock summary carries the VIX term structure (VIX9D / VIX / VIX3M / VIX6M with slope and contango/backwardation label) as EOD macro context, and /v1/volatility serves SPY's own per-expiry IV term structure at any minute.

Build the daily series, flag inversions, and test the obvious rule: de-risk when the front inverts, re-risk when contango restores. We tested it across 37 inversion episodes — the answer surprised us: VIX Term Structure Inversions Since 2018.

More ideas worth an afternoon

FOMC vol-crush event studies — pull ATM IV and vanna/charm exposure at 13:55 and 14:30 ET on every Fed day; measure the crush and the dealer-flow shift minute by minute.
Greeks P&L attribution on past trades — reprice any historical position minute by minute from /v1/optionquote and decompose its P&L into delta, gamma, theta, and vega contributions. The honest post-mortem tool.
Charm-into-close and OPEX-week studies — test the "charm flows support the close" folklore with /v1/exposure/chex across years of sessions.
Liquidity regime mapping — use the spread filters plus the X-Filtered-Out header to measure when SPY option spreads blow out: open, close, crash days.

Coverage, resolution & access

Coverage: 26 fully-ramped symbols, most from January 2017 to present; minute-level option archives for 200+ symbols. Additional symbols backfilled on demand — /v1/tickers reports the live coverage map, per-table health, and known gaps.
Resolution: option quotes, greeks, and stock spot at 1-minute granularity (09:30–16:00 ET); open interest, SVI fits, and macro (VIX, VVIX, SKEW, MOVE, DGS10) applied at end of day.
No lookahead by design: every endpoint answers as-of at=; VRP percentiles are date-bounded to strictly earlier snapshots.
Access: same X-Api-Key as the live API, base URL https://historical.flashalpha.com. Full conventions in the historical API overview.

Conclusion

Every project on this list reduces to the same primitive: ask the market a question as of a specific minute, and trust that the answer only uses what was knowable then. That's what makes minute-level, as-of historical options data different from EOD aggregates or raw tick dumps — the analytics arrive already point-in-time correct.

Pick the project closest to how you trade, pull the endpoint behind it, and let the data argue with your priors. The complete endpoint guide is the reference.

Questions or a symbol you'd like backfilled? Find us on Discord or GitHub.

Flow-Signed GEX: Are Dealers Long or Short Gamma From Today's Tape?

tomasz dobrowolski — Sat, 11 Jul 2026 08:40:00 +0000

TL;DR: Every GEX tool signs gamma the same way: calls positive, puts negative. That answers "what is the market's structural gamma?" It does not answer "are dealers actually long or short gamma from today's flow?" FlashAlpha's new ?polarity=flow mode answers the second question by signing each strike from the measured dealer position on today's classified tape. Untraded strikes contribute exactly zero. Defaults unchanged.

Originally published on FlashAlpha Research.

Two ways to sign dealer gamma

Every gamma exposure number rests on one hidden choice: what sign to attach to each strike's gamma. Almost every tool makes the same choice, and it smuggles in an assumption: that dealers sit on the opposite side of all customer positioning in one fixed way, forever.

Mode	How each strike is signed	What it answers
`convention` (default)	Calls positive, puts negative	What is the market's structural gamma?
`flow`	Measured dealer position from today's classified session trades	Are dealers actually long or short gamma today?

The first is a property of open contracts. The second is a property of the live tape. You want both, and now the same endpoints serve either, selected with one parameter. Omit it (or pass ?polarity=convention) and you get the existing behaviour, byte for byte. Anything else returns 400 {"error":"invalid_polarity"}.

How flow polarity is computed

The computation is deliberately simple and fully mechanical. For each strike, on both the call and put side:

dealer_pos = -(customer_buys - customer_sells)
           = customer_sells - customer_buys

GEX_strike = dealer_pos * gamma * multiplier * spot^2 * 0.01

where the multiplier is 100 for equity options and the 0.01 scales to a 1% move.

The logic is the market-maker's mirror. When customers buy options, dealers end up short those options, and short gamma. When customers sell, dealers end up long, and long gamma. So dealer_pos is simply the negative of net customer buying, accumulated from the 09:30 ET open, starting at zero.

How trades are classified

Buy/sell tagging is a quote-rule aggressor classification against the concurrent NBBO, a Lee-Ready-style method:

A print near the ask is buyer-initiated
A print near the bid is seller-initiated
A print in the middle of the spread is indeterminate and excluded

There is no tick-rule fallback and no midpoint imputation. If the aggressor is ambiguous, the trade simply does not contribute.

What it explicitly does NOT use

Not used	Why it matters
Open interest	The surface is built from classified volume alone. No settled OI, no effective-OI simulator, no open/close confidence weights.
Opening-position estimates	Dealer position starts from zero at the open and accumulates only measured trades. Nothing is assumed about yesterday's book.
Decay heuristics	Nothing ages or re-weights past trades within the session. It is a straight running sum.

Three clean properties fall out:

Untraded strikes contribute exactly 0. No classified session trades means dealer_pos = 0 and zero gamma contribution.
Midpoint trades are dropped, not guessed.
Position is session-cumulative from the open, so it measures the day's dealer inventory change, not the absolute book.

That is the whole point: the signal moves when dealers actually trade, not when a model decides positions should have changed. One practical consequence worth knowing: because only traded strikes count, the flow-signed surface can look sparser than the convention surface on quiet names or early in the session. That sparseness is information, not a bug.

Reading net_gex

Once each strike is signed by dealer position, the sign of the aggregate live_net_gex is the whole message.

net_gex > 0, dealers net LONG gamma. Dealers hedge against the move: sell rallies, buy dips. Volatility compresses and price tends to pin around the gamma flip. The classic mean-reverting, low-realised-vol regime.

net_gex < 0, dealers net SHORT gamma. Dealers hedge with the move: chase price up, sell it down, amplifying the trend. Volatility expands and larger directional moves become more likely.

The label is echoed as live_net_gex_label ("positive" or "negative") so you never re-derive the sign in client code. The same signing flows through the levels endpoint, re-signing the gamma flip and the call and put walls.

The endpoints, precisely scoped

Endpoint	What flow mode changes	Tier
`GET /v1/flow/gex/{symbol}`	Full re-signed surface, aggregate as `live_net_gex`, plus per-strike dealer diagnostics	Growth and above
`GET /v1/flow/levels/{symbol}`	Re-signs `live_gamma_flip`, `live_call_wall`, `live_put_wall`. `live_max_pain` intentionally stays OI-based	Growth and above
`GET /v1/flow/live/{symbol}`	Re-signed aggregate gamma as `live_gex`. DEX and dealer-risk in the bundle stay convention-signed	Alpha and above

Scope notes that will save you a support ticket: the five other simulation-aware flow endpoints (summary, pin-risk, dex, dealer-risk, oi) do not accept polarity. And flow polarity is independent of the effective-OI simulator the default flow surface uses; that is a separate mechanism.

Coverage is 6,000+ US equities and ETFs, plus ES and NQ index futures. Because the default is unchanged, every existing integration keeps working exactly as before. Flow mode is strictly additive.

Calling it

import requests

BASE = "https://lab.flashalpha.com"
HEADERS = {"X-Api-Key": "YOUR_KEY"}

# Flow-signed GEX: sign each strike by measured dealer position
r = requests.get(f"{BASE}/v1/flow/gex/SPY",
                 params={"polarity": "flow"}, headers=HEADERS).json()

print(f"Polarity:        {r['polarity']}")
print(f"Net dealer GEX:  {r['live_net_gex']:,}  ({r['live_net_gex_label']})")
print(f"Gamma flip:      {r['live_gamma_flip']}")

if r["live_net_gex"] < 0:
    print("Dealers net SHORT gamma - moves amplify, vol expands")
else:
    print("Dealers net LONG gamma - moves dampen, price pins")

# Inspect where the position came from, strike by strike
for s in r["strikes"][:3]:
    print(f"  {s['strike']}: dealer calls {s['call_dealer_pos']:+}, "
          f"dealer puts {s['put_dealer_pos']:+}, net_gex {s['net_gex']:,}")

In flow mode the response adds a top-level polarity: "flow" marker plus four per-strike diagnostics: call_net_customer and put_net_customer (customer buys minus sells, in contracts) and call_dealer_pos and put_dealer_pos (their negatives). Settled call_oi / put_oi are still returned per strike for reference, but play no part in the signed gamma.

An illustrative API-shape sample (not live data):

{
  "symbol": "SPY",
  "polarity": "flow",
  "live_net_gex": -4200000000,
  "live_net_gex_label": "negative",
  "live_gamma_flip": 596.00,
  "strikes": [
    {
      "strike": 595.0,
      "call_gex": -145000000,
      "put_gex": 62000000,
      "net_gex": -83000000,
      "call_net_customer": 2150,
      "put_net_customer": -1890,
      "call_dealer_pos": -2150,
      "put_dealer_pos": 1890,
      "call_oi": 15820,
      "put_oi": 12340
    }
  ]
}

Read the strike: customers net bought 2,150 calls, so dealers are short 2,150 calls and short gamma on that side. Customers net sold 1,890 puts, so dealers are long those puts and long gamma there. Net across the surface is negative: dealers are net short gamma and moves are likely to amplify.

The divergence trade

Convention and flow polarity are complementary, not competing. Use convention GEX for the structural backdrop and the flip level, then watch flow polarity intraday to catch when the day's order flow pushes dealers into a genuinely different gamma posture than the OI-based picture implies. When the two disagree, the disagreement is the signal: structural gamma says pin, real positioning says amplify.

import requests

BASE = "https://lab.flashalpha.com"
H = {"X-Api-Key": "YOUR_KEY"}

# Same endpoint, two signings
conv = requests.get(f"{BASE}/v1/flow/gex/SPY", headers=H).json()
flow = requests.get(f"{BASE}/v1/flow/gex/SPY",
                    params={"polarity": "flow"}, headers=H).json()

structural_long = conv["live_net_gex"] > 0
dealer_long     = flow["live_net_gex"] > 0

if structural_long and not dealer_long:
    print("Structural gamma long, but today's flow has dealers SHORT - expect amplification")
elif dealer_long:
    print("Dealers genuinely long gamma from the tape - fade extremes toward the flip")
else:
    print("Both agree: dealers short gamma - respect trends")

Pair it with net dealer premium, the premium-sign counterpart, for a fuller read of dealer positioning.

Backtesting with no lookahead bias

Flow polarity works on the point-in-time historical API too. Add ?at=<timestamp>&polarity=flow to reconstruct the flow-signed surface as it stood at any minute, using only the classified tape up to that instant, with greeks repriced at that moment's spot. Historical replay covers /v1/flow/gex and /v1/flow/levels on the Alpha-tier historical API (the historical live bundle does not take the parameter).

import requests, pandas as pd

BASE = "https://historical.flashalpha.com"
HEADERS = {"X-Api-Key": "YOUR_KEY"}

rows = []
for day in pd.bdate_range("2026-05-01", "2026-05-31"):
    at = f"{day:%Y-%m-%d}T18:00:00Z"   # 14:00 ET snapshot
    r = requests.get(f"{BASE}/v1/flow/gex/SPY",
                     params={"at": at, "polarity": "flow"},
                     headers=HEADERS).json()
    rows.append({"date": day.date(),
                 "net_gex": r["live_net_gex"],
                 "label": r["live_net_gex_label"]})

df = pd.DataFrame(rows)
print(df)   # daily flow-signed dealer gamma regime, no lookahead

Because each snapshot only consumes the tape up to at, the series is usable for genuine signal research on dealer-positioning regimes.

What flow polarity is not

Not the effective-OI simulator. The default flow surface estimates intraday OI change with a confidence weight and signs by convention. Flow polarity ignores that machinery and builds gamma from classified volume alone.
Not an absolute dealer book. dealer_pos is the net position accumulated today, from zero at the open. It is what dealers traded into during the session, not their full inventory including prior days.
Not a modification of anything else. Convention output, settled exposure endpoints, DEX and dealer-risk are untouched. Only the three endpoints above change, and only when you ask.

One honest caveat: flow polarity is a derived signal off the classified options tape, not exchange-audited dealer accounting. The dealer side is inferred from quote-rule NBBO aggressor classification. Read the sign and its intraday shifts as a relative signal.

Try it

The full reference, including response schemas, an FAQ, and the same call in Python, JavaScript, C#, Go and cURL, is in the original article. The interactive playground has the endpoints live if you want to poke at them without writing code.

Questions on the classification method or the maths welcome in the comments.

Backtesting Futures Gamma (ES & NQ): Historical GEX Done Right

tomasz dobrowolski — Wed, 08 Jul 2026 13:40:29 +0000

"Can I backtest futures gamma?" is one of the most common questions we get from quant desks, and the honest answer has two parts.

First: FlashAlpha serves live gamma exposure on ES and NQ futures today, computed properly on the options-on-futures chains. Second: the historical replay engine does not yet cover the futures symbols, so /v1/exposure/gex/ES=F?at=... returns no data. That is a real limitation — and this article is about the fact that it is not the blocker it looks like.

The reason is structural. The dealer gamma that pins or unpins ES is the gamma of the entire S&P 500 options complex — SPX index options, SPY ETF options, and the ES options-on-futures — hedged by the same desks against the same index. That complex has a deep, clean, minute-resolution history. So the rigorous move is to backtest the regime on the cash-index history and trade it on the live future, rather than wait for a thin native futures tape.

TL;DR — the split:

Phase	Host	Symbols
Research / backtest	`historical.flashalpha.com`	`SPY` (for ES), `QQQ` (for NQ), since April 2018
Live execution	`lab.flashalpha.com`	`ES=F`, `NQ=F`

Same response shape on both hosts, so the same code path works for backtest and live.

Why There Is No Native Futures GEX History (Yet)

Computing historical gamma exposure needs a point-in-time options chain with open interest, strikes, and quotes at every past minute. For US equities and index options that history is deep and well-kept, which is why FlashAlpha can replay SPY, SPX, QQQ, and thousands of names back to 2018. Options-on-futures history is a different, sparser story across the industry, and FlashAlpha's replay engine does not yet ingest it. Concretely:

Live ES=F and NQ=F exposure works now — /v1/exposure/gex/ES%3DF returns the full live surface.
Historical ES=F / NQ=F does not — a ?at= replay on a futures symbol returns no_data.
The cash-index proxies — SPY, SPX, QQQ, NDX — replay cleanly at minute resolution since 2018-04-16.

Rather than pretend otherwise, the workflow below leans on what is actually true and testable.

The Cash-Index Proxy: ES Is the SPX Complex, NQ Is the NDX Complex

An ES future is a financed claim on the S&P 500; an NQ future is a financed claim on the Nasdaq-100. The options that hedge them belong to the same index complex, so the gamma regime — positive versus negative dealer gamma, where the flip sits, where the walls cluster — is shared. That is what makes the proxy sound: you are not substituting an unrelated instrument, you are reading the same dealer book from its most liquid, best-recorded venue.

ES ← SPY / SPX. The E-mini S&P 500 tracks the same index as SPY and SPX. Historical SPY (or SPX) gamma regime is the ES gamma regime, minus a basis on the price axis.
NQ ← QQQ / NDX. The E-mini Nasdaq-100 tracks the same index as QQQ and NDX. Historical QQQ (or NDX) gamma regime is the NQ gamma regime, minus a basis.

What transfers cleanly: gamma regime (positive/negative), the timing of flips, relative wall placement, dealer-hedging direction, and the shape of the exposure profile. These are properties of the index dealer book, not of one venue.

What needs a translation: the price of each level. Cash-index strikes are on the index; ES/NQ trade at a basis to cash. A level is correct in regime terms but must be shifted onto the futures price before you act on it.

Translating Levels Through the Basis

The only adjustment the proxy needs is on the price axis. The future trades at a basis to the cash index:

F = S + Basis        (Basis = F − S)

where F is the ES (or NQ) future and S is the cash index (SPX or NDX). The basis reflects financing minus dividends to the contract's expiry and drifts toward zero into the quarterly roll. So a gamma flip your backtest found at an SPX level maps to an ES level by adding the current basis:

ES level = SPX level + Basis(now)

If you backtest on SPY rather than SPX, first scale by roughly ten (SPY is about 1/10th of SPX) to reach index points, then apply the basis. The /futures/es page prints the live basis so you do not have to compute it by hand, and the ES fair value and basis explainer covers the mechanics in depth.

Why this is enough: dealer gamma is a statement about where hedging flips sign, which is a property of the index, not the wrapper. The basis moves the number on the x-axis; it does not change whether dealers are long or short gamma. Get the regime from the deep cash history, get the exact price from the live future and its basis.

How To Backtest It: Signal on the Cash History

The historical host mirrors the live exposure endpoints and adds an ?at= timestamp (ET). Pull SPY (for ES) or QQQ (for NQ) at any past minute and you get the same response shape as live — net_gex, the gamma flip, the walls, and the per-strike breakdown:

# Replay SPY dealer gamma at a past timestamp (ET) - the ES proxy
curl -H "X-Api-Key: YOUR_KEY" \
  "https://historical.flashalpha.com/v1/exposure/gex/SPY?at=2026-06-13T15:55:00"

# NQ backtests off QQQ
curl -H "X-Api-Key: YOUR_KEY" \
  "https://historical.flashalpha.com/v1/exposure/gex/QQQ?at=2026-06-13T15:55:00"

To build a strategy signal, walk a date range and tag each day's dealer-gamma regime from the sign of net GEX. That regime series is your ES signal:

import requests

HOST = "https://historical.flashalpha.com/v1/exposure/gex/SPY"
HEADERS = {"X-Api-Key": "YOUR_KEY"}

def net_gex_at(day):
    r = requests.get(HOST, params={"at": f"{day}T15:55:00"}, headers=HEADERS)
    r.raise_for_status()
    return r.json()["net_gex"]

# Tag each session's regime - the signal you would have traded ES on
for day in ["2026-06-08", "2026-06-09", "2026-06-10"]:
    g = net_gex_at(day)
    regime = "positive-gamma (pin)" if g > 0 else "negative-gamma (trend)"
    print(day, regime, f"net_gex={g:,.0f}")

From there it is an ordinary backtest: join the regime series to ES returns, test the rule (for example, "fade range in positive gamma, stand aside or follow trend in negative gamma"), and measure the edge. Because the historical and live responses are identical in shape, the same parsing code you write here runs unchanged against the live future in production. For the general historical-GEX backtesting workflow and field reference, see the historical GEX API guide.

The workflow in five steps:

Pick the proxy. SPY (or SPX) for ES, QQQ (or NDX) for NQ.
Replay the regime. Loop ?at= over your test window and record net GEX, the flip, and the walls at each point.
Build the signal. Turn the exposure series into your rule — regime sign, distance to flip, proximity to a wall.
Join to futures returns. Test the rule against ES/NQ price action; the regime is shared, so the signal transfers.
Translate levels for execution. Shift any price level onto the future with the current basis.

Execute on the Live Futures Book

When the backtested rule fires today, read the actual dealer gamma off the live future — this is where the options-on-futures chain, Black-76 pricing, and the correct CME multiplier ($50/pt for ES, $20/pt for NQ) matter for the exact levels:

# Live ES gamma for the current session (URL-encode '=' as %3D)
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/ES%3DF"

# Live NQ
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/NQ%3DF"

So the division of labour is clean: the cash history gives you the tested edge, the live future gives you the exact, execution-grade levels on the instrument you actually trade. The live ES and NQ surfaces are documented in GEX on ES & NQ futures, and the two books are compared side by side in ES futures vs SPY/SPX gamma.

What The Proxy Can and Cannot Tell You

Being explicit about the edges keeps the backtest honest:

It is not the ES options-on-futures tape. ES has its own open interest and its own 0DTE behavior. The regime transfers; the exact ES per-strike OI in the past does not. For strategies that hinge on ES-specific micro-positioning, treat the proxy as regime context, not ground truth.
The overnight session is only on the future. ES gamma is live through the near-24-hour Globex session; the cash proxy is a regular-hours book. Backtest the regime on RTH cash, but remember the live future is what is active at 4 a.m. ET.
The basis is time-varying. Use the basis as of each point in time, not a constant, especially across a quarterly roll.
Native futures replay is on the roadmap. When options-on-futures history lands in the replay engine, the same ?at= pattern will work directly on ES=F / NQ=F and this proxy step becomes optional.

Wrapping Up

Backtesting futures gamma is a solved problem if you frame it correctly: options-on-futures history is thin, but ES gamma is the S&P 500 complex's gamma and NQ gamma is the Nasdaq-100's, so you research the edge on the deep cash-index history (SPY/SPX for ES, QQQ/NDX for NQ, minute-resolution since April 2018), translate levels through the basis, and execute on the live ES=F / NQ=F book.

See live futures gamma on /futures/es and /futures/nq, and the API docs for the full field reference on both hosts.

Questions on the replay engine or the proxy approach? Drop a comment or find us on Discord.

Trading ES & NQ Futures with FlashAlpha: The Complete GEX, Flow & Levels Handbook

tomasz dobrowolski — Tue, 16 Jun 2026 20:04:07 +0000

Most "futures gamma" you find online is SPY or SPX equity gamma with the label swapped. FlashAlpha computes dealer positioning directly on the ES and NQ options-on-futures chains, priced with Black-76 on the live forward, with dollar exposure scaled by the real CME contract multiplier ($50/point for ES, $20/point for NQ). That distinction is the whole point of this handbook: the levels you trade should come from the book that actually hedges the contract you're trading.

Who this is for

Discretionary ES/NQ day traders, premium sellers and 0DTE traders on the index futures, systematic desks building an automated futures dealer-flow monitor, and anyone currently proxying ES off SPX gamma who wants the futures-native read. It assumes you already know what gamma exposure is. If you don't, start with what gamma exposure measures.

1. What FlashAlpha computes on ES & NQ

Everything that works for an equity works for the futures by swapping the symbol to ES=F or NQ=F:

Gamma exposure (GEX). Net dealer gamma, by strike and full-chain, with the gamma flip, call wall and put wall. See it on /futures/es/gamma and /futures/nq/gamma.
DEX, VEX, CHEX. Delta, vanna and charm exposure, on the same dollar conventions.
Key levels. Gamma flip (the regime boundary), call and put walls (resistance and support), max pain, and the highest-OI strike.
Expected move. The options-implied 1-day, 1-week and 1-month range from live ATM IV.
Volatility. ATM IV, the 25-delta skew, term structure, realized vol, VRP, and the SVI volatility surface.
Flow analytics. The same exposures recomputed on intraday effective open interest, so the dealer book updates through the session (the flow GEX read).
0DTE. Pin risk, expected move, gamma acceleration and theta decay for same-day ES/NQ expiries.
Basis. The live ES−SPX and NQ−NDX carry basis, i.e. futures "fair value."

The rendered live views are /futures/es and /futures/nq; the futures hub shows both side by side.

2. Symbology & access

Futures are served under the familiar =F convention so they never collide with same-named equities: ES=F (E-mini S&P 500) and NQ=F (E-mini Nasdaq-100), each resolving to the continuous front-month contract. In REST paths, URL-encode the = as %3D, for example /v1/exposure/gex/ES%3DF. The SDKs take the raw ES=F. CME index futures and the flow analytics are Growth-tier features.

3. Why the numbers are right: Black-76 & the multiplier

An option on a future is priced on the forward, not a drifting spot. FlashAlpha uses Black-76, which is Black-Scholes-Merton evaluated on the forward (S = F) with carry q = r, so delta, gamma, vega, theta, vanna and charm all come out correct for the futures contract. Dollar exposure then carries the real multiplier: $50 per index point for ES, $20 for NQ, not the 100x equity-option multiplier. Get the model or the multiplier wrong and every exposure number is off by a constant. Full detail in the futures and index methodology.

4. The four levels every futures trader reads

These are the actionable outputs. On any futures page they render in the Quick-Stats and on the GEX chart:

Gamma flip. The price where net GEX crosses zero. Above it, dealers are long gamma and dampen moves: they buy dips and sell rips, so price tends to mean-revert. Below it, they're short gamma and amplify them: trends run and ranges widen. This is the single most important regime read.
Call wall. The strike of greatest call gamma above price. It acts as resistance as dealer hedging caps advances.
Put wall. The strike of greatest put gamma below price. It acts as support.
Max pain. The OI-weighted settlement strike that minimizes total option-holder payout, a soft magnet into expiry. See ES max pain.

Alongside them, the expected move (price × ATM IV × √(days/252)) frames the day's plausible range, and the basis tells you how the futures levels sit relative to the cash index.

5. Settled vs flow GEX: the intraday read

Settled GEX is built on the exchange's once-daily settlement open interest. It's accurate, but it's stamped to the prior close and sits static all session. Flow GEX recomputes the same dealer book on intraday effective OI (settled OI plus a flow-classified estimate of today's net opening trades), so the regime, the flip and the walls move during the session. On a contract that trades nearly 24 hours, that's the difference between a stale snapshot and a live read. Full mechanics in flow GEX on futures.

6. The daily playbook (session by session)

ES and NQ trade almost around the clock on CME Globex, so the workflow spans four windows:

Pre-market. Check the overnight flow gamma regime (did a flip form overnight?), the basis to cash (the "fair value" gap), the gamma flip, and the call and put walls bracketing the overnight range. Note the expected move for the session.
Cash open (09:30 ET). Confirm whether price is above or below the gamma flip. That sets your bias toward mean reversion (long gamma) or trend (short gamma). Watch the put wall as support and the call wall as resistance.
Midday into the close. 0DTE gamma and charm take over. Use 0DTE analytics for pin risk around the magnet strike and the remaining-session expected move; max pain becomes a stronger draw as OI decays.
Overnight (Globex). Flow GEX keeps updating on Asia and Europe trade, so a regime shift on an overnight headline is visible hours before the US open.

7. The basis & the roll ("fair value")

Futures and cash are bound by cost of carry:

F = S \cdot e^{(r - q) T}, Basis = F - S

The basis (future minus cash index) is what desks call "fair value." A positive basis (contango) is the normal, financing-positive state, and it drifts toward zero into each quarterly roll (Mar/Jun/Sep/Dec). Because ES strikes and walls live on the futures price, they're offset from the equivalent SPX cash levels by the basis. FlashAlpha shows the live ES−SPX and NQ−NDX basis on the futures pages, and surfaces a per-expiry forward basis in the advanced-volatility analytics.

8. ES vs SPY/SPX: why trade the futures-native read

If you trade ES, the ES options book is what hedges ES, not the SPY or SPX book. Three reasons the futures-native read matters: (1) levels are basis-offset from cash, so SPX walls are in the wrong place for an ES stop; (2) dollar gamma uses the $50 multiplier, not 100x, so magnitudes differ; (3) ES hedges overnight on Globex when SPY is closed, so the gamma regime can shift outside US hours. Use the cash read as context, but trade the contract's own book.

9. Automate it: the API

Every endpoint takes the futures symbol directly (encode the = as %3D):

# Full-chain gamma exposure by strike on ES futures
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/ES%3DF"

# Key levels (gamma flip, call/put wall, max pain) on NQ
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/levels/NQ%3DF"

# Intraday flow-adjusted GEX on ES
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/flow/gex/ES%3DF"

# The whole summary (price, IV, exposure, basis context) for ES
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/stock/ES%3DF/summary"

The response schema is identical to the equity endpoints, so existing code works by swapping the symbol. See the GEX, flow and 0DTE docs, and the full reference. Official SDKs cover Python, JavaScript, .NET, Go and Java.

10. What to keep in mind

Dealer positioning is an assumption (calls dealer-long gamma, puts dealer-short), not observed inventory. The metrics are a structural lens on hedging pressure, not a measurement.
Levels are heuristics, not forecasts. Walls, flip and max pain describe where hedging concentrates, not where price has to go.
Liquidity matters. The analytics are strongest where the options-on-futures chains are liquid (ES and NQ). Thin overnight books make levels noisier.
Not investment advice. Futures trading carries substantial risk of loss.

FAQ

Does FlashAlpha compute gamma on ES/NQ futures, or proxy it from SPY/SPX?
Directly on the ES and NQ options-on-futures chains. Options are priced with Black-76 on the live futures forward, and dollar exposure uses the real CME multiplier ($50/point ES, $20/point NQ). It isn't SPY/SPX gamma relabeled; it's the dealer book that actually hedges the futures contract.

Which futures can I trade with this, and how do I access them?
Full options analytics cover the liquid equity-index futures: ES (E-mini S&P 500, symbol ES=F) and NQ (E-mini Nasdaq-100, NQ=F). Use the /futures/es and /futures/nq pages, or call any endpoint with the symbol (encode = as %3D). CME index futures and flow analytics are Growth-tier.

How do I use the gamma flip and walls to trade ES intraday?
Read the gamma flip first: above it dealers dampen moves (favor fading extremes back toward the mean), below it they amplify them (favor trend continuation and wider stops). The call wall is resistance, the put wall is support. These are structural pressure levels, not guarantees, so combine them with your own execution and risk rules.

Why do ES gamma levels differ from SPX, and what is the basis?
ES levels are quoted on the futures price, which sits above cash SPX by the basis (F − S, the cost-of-carry "fair value," positive in normal contango and drifting to zero into the quarterly roll). So an ES wall is offset from the equivalent SPX strike by that basis. Trade the ES book for ES, and use SPX as context.

Can I automate an ES/NQ dealer-flow monitor with the API?
Yes. Poll /v1/exposure/gex/ES%3DF, /v1/exposure/levels/ES%3DF, /v1/flow/gex/ES%3DF and /v1/stock/ES%3DF/summary on your cadence; the schema matches the equity endpoints. Official SDKs cover Python, JS, .NET, Go and Java. See the API docs for fields and rate limits.

Live ES & NQ dealer positioning: flashalpha.com/futures. API docs: flashalpha.com/docs. Originally published on the FlashAlpha blog.

GEX on ES & NQ Futures: Live Gamma Exposure for E-mini S&P and Nasdaq

tomasz dobrowolski — Tue, 16 Jun 2026 19:02:23 +0000

Gamma exposure on index futures has been a blind spot for almost every analytics vendor. Most "futures GEX" you'll see is really SPY or SPX gamma with the label swapped: the same equity chain, plotted on a futures chart. That isn't what we compute.

We compute it directly on the options-on-futures chains for the E-mini S&P 500 (ES) and E-mini Nasdaq-100 (NQ), priced against the live futures forward, with the right contract economics applied at every step.

This is the futures-specific companion to the general explainer, so it won't re-derive what GEX is. If you need that, start with What Is Gamma Exposure (GEX) Explained. What this covers is everything that changes once the underlying is a cash-settled index future instead of an equity or ETF: the pricing model, the multiplier, the basis, the symbology, and why ES dealer-gamma has to be read differently from SPY.

New: GEX, DEX, VEX and CHEX are now live for ES=F and NQ=F. They run through the same exposure endpoints you already use for equities, plus dedicated ES and NQ futures pages.

What Is Different About Futures GEX?

The mechanics of dealer hedging are identical to equities: long gamma dampens moves, short gamma amplifies them, the gamma flip marks the regime boundary, and call/put walls act as resistance and support. What changes on futures is the plumbing underneath the gamma number. Three things differ, and each one matters if you want the dollar figures to come out right.

1. The underlying is a futures price, not a spot price. ES and NQ are cash-settled index futures. The options are written on the futures contract itself, a live exchange quote off CME Globex, and that contract trades at a basis to the underlying cash index (SPX for ES, NDX for NQ). It isn't SPY, it isn't QQQ, and it isn't the cash index.

2. The options are priced with Black-76, not Black-Scholes on spot. Options on futures are forward-settled, so the right model is Black-76. It prices off the forward F rather than a spot that drifts at the risk-free rate. Run spot Black-Scholes on them and you mis-price every Greek that feeds GEX.

3. The contract multiplier is not ×100. Equity options control 100 shares. Index futures options carry the futures multiplier: $50 per index point for ES, $20 per point for NQ. Dollar gamma has to scale by that multiplier, or your GEX comes out wrong by a constant factor.

Black-76: Pricing Options on the Forward

For a futures option, the underlying the option references is the futures price F, which already embeds carry to expiry. Black-76 is the standard model for this. The European call price is:

C = e^{- r T} [F N (d_{1}) - K N (d_{2})]

with

d_{1} = \frac{ln ( F / K ) + \frac{1}{2} σ ^{2} T}{σ T}, d_{2} = d_{1} - σ T

where F is the futures forward, K the strike, T the time to expiry, σ the implied volatility, r the risk-free rate, and N the standard normal CDF. The single discount factor e^(−rT) out front is what marks this as a forward model: the forward already carries the cost of carry, so there's no separate drift term inside.

The clean identity. Black-76 is just Black-Scholes with the substitution S = F and dividend yield q = r. Price, delta, gamma, vega, theta, vanna and charm all carry straight over; only rho differs. So the gamma feeding futures GEX runs on the same pricing core as our equity gamma. There's no separate, riskier re-derivation to get wrong.

Because a future's forward is just the future's own price, we pull the per-expiry forward from the chain by put-call parity, and where there's no pair to use, the fallback collapses to the futures price itself. Nothing applies an equity-style S·e^(rT) forward. What drops out is the real sensitivity of an options-on-futures position, not an approximation of one.

The Multiplier: Why ES Dollar-Gamma Scales by $50

Gamma per contract is a count of "deltas per point." To get dollar gamma exposure, the quantity GEX actually aggregates, you multiply that by open interest, by the underlying price (twice, for the dollar-per-1%-move convention), and by the contract multiplier. For equities the multiplier is 100. For index futures it's the contract's point value:

Contract	Point value
ES (E-mini S&P)	$50 / pt
NQ (E-mini NDX)	$20 / pt
Equity option	$100

The conceptual form of dollar gamma exposure at a strike is:

GEX = Γ \times O I \times Multiplier \times F^{2} \times 0.01 \times (dealer sign)

The multiplier isn't cosmetic. A $50 ES point value looks small next to the $100 of share exposure on an equity option, but the index sits at several thousand points and open interest piles into the front quarterly, so the dollar gamma on a single ES strike ends up large. Get the multiplier wrong and the whole dollar-GEX surface is mis-scaled by a constant. Flips and walls still land at the right strikes, but every notional and every dealer-hedging estimate is off. We thread the right multiplier through every aggregator (GEX, DEX, VEX, CHEX, max pain, dealer notional), so the dollar numbers are correct and not just the shape.

The same discipline applies to the micros, but the public futures pages cover the full-size ES=F and NQ=F contracts, which carry the deepest, most liquid options-on-futures chains.

Basis: Why ES Dealer-Gamma Reads Differently From SPY

SPY tracks the S&P 500 at roughly 1/10th the index, fully funded, with a continuous dividend yield. ES is a leveraged, financed exposure to the same index, and it trades at a basis to cash:

Basis = F - S, Basis % = \frac{F - S}{S}

where F is the ES future and S is the SPX cash index. A positive basis (contango) means the future trades above cash; a negative basis (backwardation) means below. The basis reflects financing minus dividends to the contract's expiry, and it drifts as the contract approaches its quarterly roll.

Which is why you can't just read ES gamma off a SPY chart:

The strikes live on the futures price. An ES call wall sits at an ES futures level, offset from the equivalent SPX level by the basis. Plot it against cash and you've put the wall in the wrong place.
The chains aren't the same product. ES options-on-futures, SPX index options, and SPY ETF options each have their own open interest, their own 0DTE behavior, and their own dealer positioning. They correlate, but the book that hedges ES is the ES options book.
The session is nearly 24 hours. ES trades CME Globex hours, so its gamma regime is live overnight and through the European session, when SPY is closed. The flip can get tested at 3 a.m. ET.

ES / NQ futures GEX vs SPY / QQQ ETF GEX

	ES / NQ futures	SPY / QQQ ETF
Chain	Options-on-futures	Equity options
Pricing	Black-76 on the futures forward	Black-Scholes on spot
Multiplier	$50 (ES) / $20 (NQ) per point	$100 per contract
Strikes	On the futures price	On the ETF price
Session	~23h Globex	RTH
Settlement	Cash index	Physically settled shares + dividend yield

Symbology: ES=F and NQ=F

We serve the equity-index futures under the =F suffix, the same convention you already know from Yahoo Finance and most data tools:

Contract	Symbol	Cash index	Multiplier	Page
E-mini S&P 500	`ES=F`	SPX	$50 / pt	/futures/es
E-mini Nasdaq-100	`NQ=F`	NDX	$20 / pt	/futures/nq

Both resolve to the continuous front-month contract, so you always get the active, most-liquid expiry without having to track the quarterly roll yourself. The chain, quotes, open interest and exposure all flow through the same endpoints you'd use for any ticker. The only thing that changes is the symbol.

How To Get It: Endpoints and Pages

The fastest way to see it is the dedicated futures pages, which render the live GEX, key levels, basis, expected move and contract specs server-side:

/futures/es: live ES gamma exposure, levels, basis to SPX, and contract specs.
/futures/nq: live NQ gamma exposure, levels, basis to NDX, and contract specs.
/futures: the futures hub, both contracts side by side.

For programmatic access, the exposure endpoints take the futures symbol directly. The one thing to remember is to URL-encode the = as %3D, since a raw = can break path-segment routing:

# Live GEX on ES futures (note %3D for the '=')
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/ES%3DF"

# And NQ
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/NQ%3DF"

The higher-order dealer-positioning surface is there for futures too. Delta, vanna and charm exposure use the same path pattern:

Endpoint	What it returns for ES/NQ
`/v1/exposure/gex/ES%3DF`	Per-strike gamma exposure, net GEX, gamma flip
`/v1/exposure/dex/ES%3DF`	Per-strike delta exposure (DEX)
`/v1/exposure/vex/ES%3DF`	Per-strike vanna exposure (VEX)
`/v1/exposure/chex/ES%3DF`	Per-strike charm exposure (CHEX)
`/v1/exposure/levels/ES%3DF`	Gamma flip, call wall, put wall, max-gamma strikes

The response schema is identical to the equity exposure endpoints, so any code or dashboard you already built against /v1/exposure/gex/SPY works against ES%3DF by swapping the symbol. See the API documentation for the full field reference.

If a request comes back with a 404 or an empty body, the usual culprit is an un-encoded =. Always send ES%3DF / NQ%3DF in the path. Most HTTP clients and SDKs handle this for you with standard URL-encoding.

How It's Computed

The pipeline that produces ES and NQ gamma exposure is the equity pipeline with futures-correct economics threaded through it, not a parallel approximation.

Ingest the options-on-futures chain. CME equity-index futures and their option chains land in the same option store under the futures root (ES, NQ), so the API serves them like any other ticker. Chain, quotes and open interest all resolve through the standard endpoints.
Resolve the live forward. The underlying is the futures price from the exchange feed. A per-expiry forward is derived from the chain by put-call parity; the no-pair fallback collapses to the futures price itself (a future's forward is its own price).
Price with Black-76. Every option's implied volatility and Greeks are computed on the forward using Black-76 (Black-Scholes with S = F, q = r). Gamma, delta, vanna and charm all come out of this single pricing core.
Stamp the contract multiplier. Each Greeks snapshot carries the contract's multiplier ($50 for ES, $20 for NQ) instead of the equity default of 100. The multiplier flows with the data into every aggregator.
Aggregate dollar exposure with the dealer convention. Per-strike gamma is signed for the standard dealer book (short the options customers bought), scaled by OI and the multiplier, then summed into net GEX, the gamma flip and the call/put walls. DEX, VEX and CHEX come out of the same machinery.

Because the futures path reuses the proven equity core under one clean substitution, the gamma is computed exactly the way it always has been. Only the forward, the model variant and the multiplier change. What you get is real options-on-futures dealer gamma scaled in actual dollars, not equity gamma wearing a futures label.

Reading ES and NQ Gamma in Practice

The interpretation rules carry over from the general GEX explainer, but a few futures-specific habits pay off:

Watch the flip overnight. ES gamma is live through the Globex session. A negative-gamma regime that gets tested at 4 a.m. ET on a macro headline behaves just like an intraday test, with the same amplified, trendy moves, hours before SPY opens.
Translate walls through the basis. If you trade ES off a SPX-quoted level, add the current basis to put the level on the futures price. The futures pages show the live basis so you don't have to do it by hand.
Compare ES and NQ regimes. The two contracts can sit in different gamma regimes (NQ short-gamma while ES is pinned, say). That divergence is itself a signal about where dealer hedging will add stress.
Use the cash cross-links. The futures pages cross-link to the SPX and NDX cash pages, so you can see the futures dealer book and the index dealer book together.

FAQ

Does FlashAlpha compute GEX on ES and NQ, or approximate it from SPY/QQQ?
It computes GEX directly on the ES and NQ options-on-futures chains. Options are priced with Black-76 on the live futures forward, and dollar gamma is scaled by the real contract multiplier ($50/pt ES, $20/pt NQ). It isn't SPY or QQQ equity gamma relabeled.

Why Black-76 instead of Black-Scholes?
Options on futures are written on the futures price, which already embeds carry to expiry, so the right model prices off the forward rather than a drifting spot. Black-76 is equivalent to Black-Scholes with S = F and q = r, so price, delta, gamma, vega, theta, vanna and charm all carry over; only rho differs.

How does the contract multiplier affect dollar GEX?
Dollar gamma exposure scales by the multiplier. Equity options use ×100; ES uses $50/pt and NQ $20/pt. Using ×100 on a futures chain overstates the dollar exposure by a constant factor.

What is the futures basis?
The basis is F − S, the difference between the futures price and the cash index (SPX for ES, NDX for NQ). It reflects financing minus dividends to expiry and drifts toward zero into the quarterly roll. Because ES strikes and walls live on the futures price, they're offset from the equivalent cash levels by the basis.

How do I get live GEX for ES and NQ?
Use the /futures/es and /futures/nq pages, or call GET https://lab.flashalpha.com/v1/exposure/gex/ES%3DF (URL-encode the = as %3D). DEX, VEX, CHEX and key levels use the same path pattern.

Live ES & NQ gamma exposure: flashalpha.com/futures. API docs: flashalpha.com/docs. Originally published on the FlashAlpha blog.

The 0DTE Gamma Heatmap API: Strike-by-Time GEX, a HIRO and Heatseeker Alternative

tomasz dobrowolski — Sun, 14 Jun 2026 19:15:39 +0000

A strike-by-time gamma heatmap is the chart SpotGamma TRACE and Skylit Heatseeker are known for. GET /v1/flow/zero-dte/heatmap/{symbol} returns that same strike × time matrix for today's 0DTE chain as plain JSON — so you render it in your own stack or feed it to a model instead of staring at someone else's dashboard. It's the per-strike layer of the broader live 0DTE flow family.

Read this first. The heatmap is built on FlashAlpha's flow model — effective open interest plus aggressor-classified trades — not a dealer's actual book. The values are estimates. Read the bands, shifts, and signs as a relative map of where positioning sits, not exact dealer inventory.

What a strike-by-time heatmap shows

A single GEX snapshot tells you where dealer gamma sits right now. A heatmap adds the dimension every 0DTE trader wants: how that profile moves through the session. Strikes down one axis, time across the other, color encodes the metric. Read across a row to see one strike build or bleed; read down a column for the whole profile at one instant; watch the bright bands migrate to see the magnet and walls shift.

That migration is the signal. A bright positive-gamma band that locks onto a strike and stays is pinning. A band bracketing price that thins out means the walls are weakening and a breakout gets easier. On a 0DTE chain this happens within hours — a static morning chart misses it, a live matrix doesn't.

The endpoint

GET /v1/flow/zero-dte/heatmap/{symbol}?bar=1m&metric=gex&mode=raw&minutes=60

Strikes are pulled out into a top-level strikes_grid, and each bar's values array is parallel by index — so you index it as values[bar][strike], exactly the shape a heatmap library wants. Roughly 30% smaller on the wire than per-cell objects.

{
  "symbol": "SPX",
  "underlying_price": 6012.4,
  "expiration": "2026-06-12",
  "metric": "gex",
  "mode": "raw",
  "bar_size": "1m",
  "as_of": "2026-06-12T18:45:12Z",
  "market_open": true,
  "strikes_grid": [5995, 6000, 6005, 6010, 6015, 6020],
  "bars": [
    { "t": "2026-06-12T18:43:00Z", "spot": 6011.8,
      "values": [-1.1e9, -3.8e8, 1.9e8, 9.0e8, 1.7e9, 2.8e8] },
    { "t": "2026-06-12T18:44:00Z", "spot": 6012.1,
      "values": [-1.2e9, -4.0e8, 2.1e8, 9.5e8, 1.8e9, 3.0e8] }
  ],
  "gap_intervals": []
}

Six metrics, one grid

The metric parameter swaps what the color channel represents:

gex — gamma exposure per strike (default). Bright positive = pin zones, deep negative = accelerant zones.
dex — delta exposure, directional dealer positioning.
vex — vega exposure, vol sensitivity by strike.
chex — charm exposure, where decay forces the fastest re-hedging into the close.
oi — effective open interest, the raw positioning mass.
signed_flow — net signed aggressor flow, where customers are buying (+) or selling (−) right now.

Raw vs delta mode

mode=raw shows the level at each cell — where the walls and magnet sit.
mode=delta shows the bar-over-bar change — where positioning is landing this minute. The closest analog to a HIRO-style "what just changed" read; a strike lighting up in delta often flags fresh flow before it shows in the raw level.

Common workflow: raw as the background field, delta as the overlay flagging active strikes.

Pull it and plot it

import numpy as np
import matplotlib.pyplot as plt
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
d = fa.flow_zero_dte_heatmap("SPX", metric="gex", mode="raw", bar="1m", minutes=120)

strikes = d["strikes_grid"]
times   = [b["t"][11:16] for b in d["bars"]]
spot    = [b["spot"] for b in d["bars"]]
grid    = np.array([b["values"] for b in d["bars"]]).T  # -> [strike][bar]

plt.imshow(grid, aspect="auto", origin="lower", cmap="RdBu_r",
           extent=[0, len(times), strikes[0], strikes[-1]])
plt.plot(np.arange(len(times)) + 0.5, spot, color="black", lw=1)  # spot overlay
plt.colorbar(label=f"{d['metric'].upper()} ({d['mode']})")
plt.title(f"{d['symbol']} 0DTE {d['metric'].upper()} heatmap")
plt.show()

JavaScript / Plotly:

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_KEY');
const d = await fa.flowZeroDteHeatmap('SPX', { metric: 'gex', mode: 'delta', bar: '1m', minutes: 120 });

const z = d.strikes_grid.map((_, j) => d.bars.map(b => b.values[j]));  // transpose
const trace = { type: "heatmap", colorscale: "RdBu", reversescale: true,
  x: d.bars.map(b => b.t), y: d.strikes_grid, z };
Plotly.newPlot("chart", [trace], { title: `${d.symbol} 0DTE ${d.metric}` });

vs SpotGamma TRACE and Skylit Heatseeker

Both popularized the intraday strike-by-time heatmap, and both are excellent dashboards. The gap they leave is programmatic access — you watch their chart, you don't pull their matrix. FlashAlpha returns the matrix as JSON: render it in your own stack, alert on a band crossing a strike, or feed it straight into a model. The point isn't that it looks better — it's that it's callable. It also pairs with FlashAlpha's numeric pin score and trade-setup classifier. The data is FlashAlpha's own, not resold from either product.

When you want the signed aggressor detail underneath — net delta-dollars, gamma-dollars, and contract counts per strike per bar — the companion GET /v1/flow/zero-dte/strike-flow/{symbol} returns three parallel arrays against the same grid.

Both the heatmap and strike-flow endpoints are on the Alpha plan (from $1,199/mo, unlimited requests) — the model-input granularity of the 0DTE flow family. Calling below Alpha returns 403 tier_restricted.

Full reference and an interactive playground: flashalpha.com

The Live 0DTE Flow API: Hedge-Flow, Heatmaps and Trade Setups

tomasz dobrowolski — Sun, 14 Jun 2026 19:15:11 +0000

If you're searching for a 0DTE options flow API, a same-day dealer-hedging feed, an intraday gamma heatmap you can pull from code, or a SpotGamma HIRO / Skylit Heatseeker alternative with a real REST surface, this is the reference. Everything lives under one base path — GET /v1/flow/zero-dte/ on https://lab.flashalpha.com — behind a single X-Api-Key header.

Read this first. The flow family is built on a model. Dealer hedge-flow, the live GEX shift, and the setup/probability layers are estimates derived from effective open interest and aggressor-classified trades — not a window into any dealer's actual book. The JSON below uses placeholder numbers. Read the signs, trends, and probabilities as a relative, decision-grade read, not exact order flow.

Why a live 0DTE flow family exists

Classic same-day analytics are computed from settled open interest — the prior session's end-of-day OPRA book. For a contract expiring in two weeks that's fine; one day of flow barely moves the aggregate. For a contract expiring today it's the wrong input. 0DTE traders open and close all day, and that flow concentrates OI and gamma at strikes that didn't look special at 9:30. A settled-OI snapshot is anchored to yesterday's book and tends to go stale by ~10:30 ET — right when the session gets interesting.

The fix is a simulation-aware effective open interest: settled OPRA OI plus an intraday simulator delta (model confidence 0.43). The /v1/flow/* family is computed independently of the settled /v1/exposure/* family, so it shows the regime, the pin, and the dealer hedge shift moving before the next settled print exists.

The family at a glance

Six endpoints, one base path. The first three are decision-ready signals on Growth; the last three are model-input granularity on Alpha.

Endpoint	What it answers	Plan
`snapshot/{symbol}`	Live 0DTE regime, favored setup, pin & range odds	Growth+
`series/{symbol}`	How that regime moved through the session	Growth+
`hedge-flow/{symbol}`	Are dealers buying or selling to stay hedged, bar by bar?	Growth+
`heatmap/{symbol}`	Where is gamma/delta/flow concentrating, strike by strike, over time?	Alpha+
`strike-flow/{symbol}`	Which strikes see signed aggressor delta-dollars right now?	Alpha+
`leaderboard`	Which symbols have the hottest 0DTE flow across the market?	Alpha+

Supported symbols: any name with a same-day expiry — the daily majors SPY, SPX, QQQ, IWM, plus weekly Mon/Wed/Fri OPEX names on their expiry days. Outside a 0DTE session every endpoint degrades gracefully, so your poller never special-cases the weekend.

1. Snapshot — the decision layer

GET /v1/flow/zero-dte/snapshot/{symbol} (Growth+) is the one most traders start and end with. It recomputes the full regime on effective OI and adds four decision-grade blocks on top of the raw body: flow_direction, headline, setup, probabilities. Pass ?expiry=YYYY-MM-DD to point at a 1DTE/2DTE expiry.

{
  "symbol": "SPY", "underlying_price": 600.42, "market_open": true,
  "flow_direction": {
    "label": "amplifying", "live_net_gex": 1.42e9, "flow_gex_pct_shift": 0.753,
    "description": "Today's flow reinforced dealers' long-gamma position — the pin toward 600 is strengthening."
  },
  "headline": {
    "narrative": "Pinning toward 600.00 (positive_gamma). Pin score 71/100. 64% pin prob.",
    "trade_angle": "pin_trade", "severity": "watch",
    "promoted": { "magnet": 600.00, "pin_score": 71, "pin_probability_pct": 0.64, "regime": "positive_gamma" }
  },
  "setup": {
    "primary": {
      "display_name": "Iron Fly", "confidence": "high",
      "conditions_met": ["spot within 0.3% of magnet", "regime = positive_gamma", "pin_score > 65"],
      "strikes_hint": { "short_call_strike": 601, "short_put_strike": 600, "long_call_strike": 603, "long_put_strike": 598 }
    },
    "anti_setups": [{ "display_name": "Long Premium / Lotto", "thesis": "Avoid — positive gamma + tight walls = unlikely >1σ move into close" }]
  },
  "probabilities": {
    "pin": { "value": 0.64, "calibration_method": "heuristic_v1" },
    "range_1sigma": { "value": 0.6827, "low": 598.38, "high": 602.46 }
  }
}

Read each block:

flow_direction — has today's flow reinforced or weakened the dealer regime vs settled? amplifying / dampening / neutral / no_flow / regime_flip (the one to watch — net GEX changed sign).
headline — the one-line dashboard pill. trade_angle is pin / range / breakout / low-signal; severity escalates info → watch → alert.
setup — a rules-engine read of the textbook 0DTE plays the state supports: primary + alternatives + explicit anti_setups. Every verdict ships its conditions_met / conditions_failed so you can audit it.
probabilities — calibrated odds, not raw scores. pin.value is the probability price closes near the magnet; range_1σ/2σ are the odds of closing in band. Each tags its calibration_method.

Outside a session the rich body is replaced by a small degraded envelope (body: null, session_closed: true), so always guard before reading body.

from flashalpha import FlashAlpha
fa = FlashAlpha("YOUR_KEY")
snap = fa.flow_zero_dte_snapshot("SPY")

if snap.get("body") is None:
    print(snap.get("message", "no 0DTE session"))
else:
    h, s = snap["headline"], snap["setup"]["primary"]
    print(h["narrative"])
    print(f"  setup={s['display_name']} ({s['confidence']})  angle={h['trade_angle']}")
    print(f"  pin prob={snap['probabilities']['pin']['value']:.0%}  flow={snap['flow_direction']['label']}")

2. Series — chart the session

GET .../series/{symbol}?bar=30s|1m|5m|15m&minutes=1-390 (Growth+) returns the same regime metrics as a time series, one row per bar: spot, net GEX/DEX, gamma flip, walls, magnet, pin score & probability, regime, ATM IV, charm-dollars-per-hour, and cumulative dealer hedge-flow split into calls/puts/combined. This is the endpoint behind an intraday "0DTE positioning" chart.

3. Hedge-flow — dealer pressure, bar by bar

GET .../hedge-flow/{symbol}?side=all|calls|puts (Growth+) is the signed delta-dollars dealers are inferred to be transacting each bar to stay hedged, plus a running cumulative. A run of same-signed, accelerating bars alongside a same-signed price move is the fingerprint of a gamma squeeze building. Split legs with side=calls vs side=puts to separate upside call-chasing from downside protection-driven hedging.

4–5. Heatmap & strike-flow — the per-strike picture

heatmap/{symbol} (Alpha+) is the strike-by-time value matrix — the grid SpotGamma TRACE and Skylit Heatseeker render — returned as JSON. strikes_grid is the y-axis; each bar's values is parallel by index, so you get values[bar][strike]. Pick the lens with metric (gex/dex/vex/chex/oi/signed_flow) and mode=raw (level) or mode=delta (where new positioning is landing).

strike-flow/{symbol} (Alpha+) gives the signed aggressor flow underneath: per bar, three parallel arrays — signed_delta_dollars, signed_gamma_dollars, contracts — against the same strikes_grid. This is the model input the hedge-flow and heatmap layers aggregate from.

6. Leaderboard — the hottest names

GET .../leaderboard?metric=heat|pin_risk|abs_flow|charm_intensity&n=1-100 (Alpha+) ranks the whole 0DTE landscape by one metric, so you scan the market for names worth a snapshot call. heat = hedge-flow normalized by net GEX (the "something's happening here" sort).

One session, end to end

Open (9:30–10:00 ET) — leaderboard with metric=heat to find where flow is concentrated, then snapshot the top names. headline.trade_angle says pin / range / breakout.
Setup (10:00–12:00) — when setup.primary hits high confidence with no conditions_failed, strikes_hint hands you the legs. If your idea is in anti_setups, the model is telling you conditions are against it.
Midday (12:00–14:30) — poll hedge-flow and flow_direction. amplifying + rising cumulative = dealers chasing, fade-the-range gets riskier. dampening supports the condor/fly thesis.
Power hour (14:30–16:00) — severity hits alert as a pin tightens or spot tests the flip. Tighten the poll interval; pin.value and charm_intensity are most informative in the final hour.

vs HIRO, Heatseeker, Unusual Whales

The space is dominated by dashboards. FlashAlpha ships the same class of signal as a developer-first API and adds a trader-product layer (headline / setup / probabilities) the raw feeds don't: signed dealer hedge-flow time series (HIRO's read), the strike-by-time heatmap as JSON (TRACE/Heatseeker's grid), a numeric pin score + calibrated odds, a rules-engine setup classifier, a cross-symbol leaderboard, and SDKs in Python/JS/C#/Go/Java. The data is FlashAlpha's own — not resold from any of those vendors.

Pricing

Plan	Price	Snapshot / Series / Hedge-Flow	Heatmap / Strike-Flow / Leaderboard	Rate limit
Free	$0	No	No	5/day
Basic	from $63/mo	No	No	100/day
Growth	from $239/mo	Yes	No	2,500/day
Alpha	from $1,199/mo	Yes	Yes	Unlimited

Below the required plan returns 403 tier_restricted with current and required plan names. Try any endpoint in the playground before writing code:
flashalpha.com

The Options Flow & Dealer Positioning API: A Complete Map of Every Endpoint

tomasz dobrowolski — Sat, 13 Jun 2026 18:17:31 +0000

If you are looking for an options flow API, a dealer positioning API, a GEX/DEX/VEX/CHEX exposure suite, an unusual options activity feed, a 0DTE analytics endpoint, or a plain-English read on the options market, they all live behind one key, one base URL (https://lab.flashalpha.com), and one auth header (X-Api-Key).

This post is the index. Each endpoint links to its own deep-dive guide.

pip install flashalpha

from flashalpha import FlashAlpha
fa = FlashAlpha("YOUR_KEY")
gex = fa.gex("SPY")
print(f"Gamma flip: {gex['gamma_flip']}")

First, the one distinction that matters: settled vs live

Everything in the dealer-positioning surface falls into one of two families, and picking the right one is the single most important decision you will make.

	Exposure (settled)	Flow Analytics (live)
Route prefix	`/v1/exposure/*`	`/v1/flow/*`
Based on	Settled open interest snapshots	Settled OI plus an intraday flow simulator
Use when	You want the official, stable picture	You want the flow-adjusted picture before OI re-settles
Goes stale	After the intraday OI re-snapshot (~10:30 ET)	Updates continuously with flow

The two are paired. Most exposure concepts (GEX, levels, pin risk, 0DTE) exist in both a settled and a live form. Pick settled for stability, flow for freshness. With that in hand, here is the full map.

1. Exposure & Greeks (settled positioning)

Per-strike Greeks, key levels, and term structure, computed from official open interest.

Question	Endpoint	Tier
Where is dealer gamma by strike?	`/v1/exposure/gex`	Basic+
What is dealer directional bias?	`/v1/exposure/dex`	Basic+
How does hedging react to vol & time?	`/v1/exposure/vex`, `/chex`	Basic+
Where are the call/put walls & flip?	`/v1/exposure/levels`	Growth+
Where is the pinning strike?	`/v1/maxpain`	Basic+
One unified per-strike Greek sheet?	`/v1/exposure/sheet`	Growth+
Which expiry drives the regime?	`/v1/exposure/term-structure`	Growth+
What positioning changed overnight?	`/v1/exposure/oi-diff`	Growth+
Is a sector or my book short gamma?	`/v1/exposure/basket`	Growth+
Give me the read in plain English	`/v1/exposure/narrative`	Growth+

2. Live Flow Analytics (flow-adjusted positioning)

The same concepts, recomputed intraday against the flow-driven OI simulator. Fresher than settled exposure during the session.

Question	Endpoint	Tier
What's the headline flow shift & direction?	`/v1/flow/summary`	Growth+
Where are the live walls & flip?	`/v1/flow/levels`	Growth+
What's the live pin risk?	`/v1/flow/pin-risk`	Growth+
How has dealer risk shifted on flow?	`/v1/flow/dealer-risk`	Alpha+
Full live GEX/DEX surface & OI state?	`/v1/flow/gex`, `/dex`, `/oi`, `/live`	Alpha+

3. The raw flow tape & cross-symbol scans

Trade-level flow and market-wide ranking. The "what is actually printing, and where" layer. Alpha plan.

Question	Endpoint	Tier
Recent prints, blocks, cumulative net flow?	`/v1/flow/options/{symbol}/...`	Alpha
Where's the unusual activity, ranked?	`/v1/flow/options/outliers`, `/leaderboard`	Alpha
Scored unusual options activity?	`/v1/flow/signals`	Alpha
Are dealers net long or short premium?	`/v1/flow/options/{symbol}/dealer-premium`	Alpha
Equity (stock) flow tape & bars?	`/v1/flow/stocks/{symbol}/...`	Alpha

4. 0DTE (same-day expiry)

Same-day options drive a disproportionate share of intraday price action. These endpoints are scoped to today's expiry.

Question	Endpoint	Tier
Live 0DTE regime snapshot?	`/v1/flow/zero-dte/snapshot`	Growth+
0DTE regime over time (chartable)?	`/v1/flow/zero-dte/series`	Growth+
Is a gamma squeeze building right now?	`/v1/flow/zero-dte/hedge-flow`	Growth+
0DTE analytics (settled)?	`/v1/exposure/zero-dte`	Growth+

Newest additions

Four endpoints that round out the surface:

Portfolio & Sector GEX Basket - aggregate GEX/DEX/VEX/CHEX across up to 50 symbols in one call. The question no single-ticker tool answers: is the whole basket short gamma?
Net Dealer Premium - one signed number for whether dealers are net long or short premium right now, off the full VWAP-weighted tape.
Real-Time Gamma Squeeze Detection - per-bar dealer hedge delta-dollars on today's 0DTE chain that turns "squeeze" from a vibe into a measurement.
Plain-English GEX Narrative - the exposure read as grounded sentences, built for LLM agents and automated alerts.

Tiers at a glance

Plan	Price	What unlocks
Free	$0	Sampling only (5 req/day)
Basic	from $63/mo	Per-strike Greeks (GEX/DEX/VEX/CHEX), max pain
Growth	from $239/mo	Levels, summary/sheet/basket/narrative, term structure, OI diff, Flow Analytics levels/pin/summary, 0DTE flow
Alpha	from $1,199/mo	Full flow analytics, the raw flow tape, flow signals, dealer premium, cross-symbol scans

Prices shown are annual billing. Month-to-month is 20% higher. Free key, no credit card: https://flashalpha.com/pricing

FAQ

What's the difference between exposure and flow endpoints? /v1/exposure/* computes positioning from settled open interest, the stable picture that goes stale after the intraday OI re-snapshot. /v1/flow/* recomputes the same concepts intraday against a flow-driven simulator, so they stay current through the session.

Which endpoints do I need for dealer positioning? Start with /v1/exposure/gex and /v1/exposure/levels for the gamma map and key strikes, add /v1/exposure/narrative for a plain-English read, and use /v1/exposure/basket to aggregate across a book. For intraday freshness, add the Flow Analytics equivalents.

Is the whole surface on one plan? No. Settled Greeks and max pain start on Basic. Levels, the summary/sheet/basket/narrative, term structure, OI diff, Growth-tier Flow Analytics and 0DTE flow are on Growth. The full live flow analytics, the raw tape, signals, dealer premium and cross-symbol scans are on Alpha.

Originally published at flashalpha.com. The historical host mirrors every live endpoint with a ?at=YYYY-MM-DDTHH:mm:ss parameter, identical response shapes, SPY from 2018 onward at minute resolution. Same SDK code, base-URL swap.