DEV Community: tomasz dobrowolski

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.

Quant Options Backtesting on Point-in-Time Data: The Complete Guide

tomasz dobrowolski — Mon, 08 Jun 2026 18:45:07 +0000

Originally published on the FlashAlpha Research blog.

Summary

Backtesting options strategies is structurally harder than backtesting equity momentum or fixed-income carry. The payoff is path-dependent. The instrument set re-generates every week. Fills are wide and asymmetric. And the data problem (point-in-time chains, computed dealer exposure, arbitrage-free surfaces) is usually bigger than the signal problem.

This guide is written for a quant or systematic developer who wants to:

Research a dealer-positioning, VRP, or dispersion signal on real historical data.
Build a candidate set across the options universe, not just one ticker.
Run a fill model that reflects what you would have actually paid.
Avoid the ten systematic mistakes that inflate backtested Sharpe before live trading erases the edge.
Connect the same code to a live production signal without rewriting the data layer.

The historical endpoint set covers: GEX/DEX/VEX/CHEX exposure replay (/v1/exposure/*?date=), VRP time-series and percentiles (/v1/vrp/{t}/history), full option chains with greeks and IV at minute resolution (/v1/options/{t}?date=), IV surfaces and SVI parameters (/v1/adv_volatility), and the universe screener (POST /v1/screener). Everything replays since 2018. The response shape is identical to the live endpoints: add or remove the date parameter to switch modes.

What systematic options research actually needs

Three requirements separate a backtest you can trust from a backtest that lies to you.

1. Point-in-time data

A request for /v1/exposure/gex/SPY?date=2020-03-16T14:30:00Z must return the state of the book exactly as it existed at that minute. Open interest, greeks, and computed gamma exposure as of 14:30:00, not end-of-day OI stamped back, not a forward fill from the prior session.

This matters for two concrete reasons. First, dealer-positioning signals use OI to compute GEX, and end-of-day OI is not known at 14:30. Second, option greeks depend on implied vol, which moves continuously, so a 15:30 vol observation is not the same as a 14:30 vol observation on a volatile day. Any historical dataset that stamps a single daily value and calls it "intraday" is baking lookahead bias into every signal that uses it.

Gamma exposure is:

GEX(t) = Σ_k OI_k(t) · Γ_k(S_t, σ_k(t), T_k − t)

Each term depends on spot S_t, the per-strike IV σ_k(t), and time to expiry at exactly time t. Substituting end-of-day values for any of these introduces forward-looking information.

2. No lookahead bias

Lookahead is not only about timestamps. It also lives in:

OI revision. Exchanges publish preliminary OI and revise it the next morning. A historical dataset assembled from the revised numbers makes yesterday's GEX look different from what any live system would have computed.
Methodology drift. If the analytics vendor updates the GEX formula, historical replays under the new formula produce different numbers than a live system running the old formula would have produced. Archive raw responses if you need bit-exact reproducibility.
Surface parameterization. SVI calibration parameters (a, b, ρ, m, σ) are an end-of-day fit in this dataset. An intraday request returns the most recent prior EOD SVI fit. If your signal uses the SVI latent at minute resolution, you have one observation per trading day, not per minute. Use the minute-level surface grid for intraday surface features, and SVI params for daily cross-sectional work.

3. Same schema, research to production

The single most underrated property of a historical API: research and production should call the same function. If your backtest calls hx.exposure_summary("SPY", at="2022-06-15T14:30:00") and your live signal calls fa.exposure_summary("SPY") and the response shapes differ, you will discover the discrepancy the first time the live system hits a field the backtest parser never saw. Every undocumented difference between historical and live response shapes is a production incident waiting to happen.

The FlashAlpha API uses the same JSON schema for both modes. The date parameter controls replay; omit it for live. One exception: the historical option-quote endpoint returns a flat array with renamed fields (implied_vol instead of iv, open_interest instead of oi) and historical-only fields (iv_bid, iv_ask, vanna, charm, rho). Write a thin adapter and test it against both modes before you backtest at scale.

The data: what the historical API covers

Dealer exposure replay (GEX/DEX/VEX/CHEX)

All four exposures replay at minute resolution from 2018, available via their own endpoints and via the unified exposure summary.

# Historical exposure summary, the one-call option
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/summary/SPY?date=2020-03-16T14:30:00Z"

# Or per-metric:
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/gex/SPY?date=2020-03-16T14:30:00Z"

from flashalpha_historical import FlashAlphaHistorical

hx = FlashAlphaHistorical(api_key="YOUR_KEY")

snap = hx.exposure_summary("SPY", at="2020-03-16T14:30:00")

print(f"Regime: {snap['regime']['label']}")
print(f"Net GEX: {snap['net_gex']:,.0f}")
print(f"Gamma flip: ${snap['regime']['gamma_flip']}")
print(f"Call wall: ${snap['levels']['call_wall']}")
print(f"Put wall:  ${snap['levels']['put_wall']}")

The response includes as_of, so you can confirm the timestamp is what you asked for. On March 16 2020 the net GEX was deeply negative; the COVID-crash dealer-positioning replay is the canonical stress-test for any strategy that conditions on GEX regime.

VRP time series and percentiles

The volatility risk premium (VRP) measures implied minus realized vol. The history endpoint returns a daily time series of VRP, z-score, and percentile rank against the trailing window, all point-in-time: the percentile for day T is computed using only data through day T.

curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/vrp/SPY/history?lookback=252"

curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/vrp/SPY?date=2022-10-14"

The vrp_percentile field is the fraction of days in the trailing window where VRP was below the current reading, computed with only prior observations. This is the operative number for a premium-selling trigger: if it is 85 or above, implied vol has been richer than this 85% of the time in the lookback window, conditioning only on past data.

Full option chains at minute resolution

The full chain endpoint returns every listed contract (bid, ask, IV, delta, gamma, theta, vega, vanna, charm, rho, OI) for a symbol at any minute since 2018.

curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/options/SPY?date=2020-03-16T14:30:00Z"

Honest resolution table for the chain endpoint:

Field	Resolution in history
Bid, ask, IV, delta, gamma, theta, vega	Minute-level (9:30 to 16:00 ET)
Vanna, charm, rho (historical-only)	Minute-level
Open interest	EOD-stamped (one value per trading day)
Volume	Always 0; use OI for liquidity proxy
SVI-smoothed vol (`svi_vol`)	Always null (`svi_vol_gated: "backtest_mode"`)

If your GEX calculation uses OI and you replay at minute resolution, you are using that day's opening OI for every minute of the session. That is what any live system would have done, since OI is published once per morning. So the EOD stamp is correct for intraday GEX replay, not a limitation.

IV surface and SVI parameters

The 50x50 implied vol surface grid (moneyness by maturity) evolves at minute resolution, driven by per-contract quotes. The SVI calibration parameters are EOD-stamped.

surface = hx.surface("SPY", at="2022-06-15T14:30:00")
adv     = hx.adv_volatility("SPY", at="2022-06-15T14:30:00")
# surface: minute-level 50x50 grid
# adv: EOD-stamped SVI params {a, b, rho, m, sigma} +
#      arbitrage-free flags + variance-swap strike

The universe screener: building a candidate set

Every cross-sectional strategy starts with a candidate set. The screener endpoint ranks and filters across the full symbol universe on GEX, VRP, IV rank, 0DTE contribution, and custom score formulas.

curl -X POST "https://lab.flashalpha.com/v1/screener" \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {"field": "vrp_percentile", "op": "gte", "value": 75},
      {"field": "iv_rank",        "op": "gte", "value": 50},
      {"field": "regime",         "op": "eq",  "value": "positive_gamma"}
    ],
    "sort": {"field": "vrp_zscore", "direction": "desc"},
    "limit": 30
  }'

In a backtest, run the screener at the decision timestamp on each rebalance date, then pull per-name history for those candidates only. This is both computationally efficient and methodologically correct: you only see names the screener would have surfaced on that date, not names that survived to the end of your sample.

Building a backtest: the full stack

The canonical loop:

Signal(t) → [screener] → Candidates(t) → [history] → Per-name data(t)
          → [fill model] → Fills(t) → [accum] → Metrics

Signal design

A signal is a function from the point-in-time state of one or more endpoints to a trade decision. Examples:

Dealer-positioning (GEX): Enter a momentum position when net GEX is negative and the 5-day average delta of net GEX is declining.
VRP premium-selling: Sell a put credit spread when VRP percentile is at least 80 and IV rank is at least 50, exit when VRP z-score reverts below its median.
Dispersion: Long single-name straddle, short index straddle, when the ratio of single-name IV to index IV is below its 6-month median.

Signals must be computable from endpoint fields available point-in-time. GEX is available at minute resolution. SVI parameters in a time series are EOD, so your signal updates once per day. OI trajectory is EOD, so the "trajectory" is one observation per day.

Candidate set via screener

import requests

API = "https://lab.flashalpha.com"
HEADERS = {"X-Api-Key": "YOUR_KEY", "Content-Type": "application/json"}

def screener_candidates(date_str: str, vrp_pctile: int = 75, limit: int = 30):
    """Run the screener point-in-time on a rebalance date."""
    body = {
        "date": date_str,
        "filters": {
            "op": "and",
            "conditions": [
                {"field": "vrp_percentile", "operator": "gte", "value": vrp_pctile},
                {"field": "iv_rank",        "operator": "gte", "value": 40},
                {"field": "regime",         "operator": "in",
                 "value": ["positive_gamma", "neutral"]}
            ]
        },
        "sort":  [{"field": "vrp_zscore", "direction": "desc"}],
        "limit": limit
    }
    r = requests.post(f"{API}/v1/screener", headers=HEADERS, json=body)
    r.raise_for_status()
    return [row["symbol"] for row in r.json()["data"]]

candidates = screener_candidates("2022-10-03")

Per-name history retrieval

from flashalpha_historical import FlashAlphaHistorical

hx = FlashAlphaHistorical(api_key="YOUR_KEY")

def fetch_signal_state(symbol: str, ts: str) -> dict:
    """Fetch point-in-time VRP + exposure for a candidate."""
    vrp  = hx.vrp(symbol, at=ts)
    summ = hx.exposure_summary(symbol, at=ts)
    vol  = hx.volatility(symbol, at=ts)
    return {
        "symbol":     symbol,
        "as_of":      ts,
        "vrp_pctile": vrp["vrp_percentile"],
        "vrp_zscore": vrp["vrp_zscore"],
        "vrp_regime": vrp["regime"],
        "gex_regime": summ["regime"]["label"],
        "gamma_flip": summ["regime"]["gamma_flip"],
        "net_gex":    summ["net_gex"],
        "iv_rank":    vol["iv_rank"],
        "iv_atm_30d": vol["atm_iv_30d"],
    }

The fill model is the edge

This is where most backtests lie. The naive fill model uses the midpoint price at decision time. That model is wrong in every direction that matters for premium sellers and spread traders:

You sell at the bid, not the mid. For a short put spread with a mid of $1.20 and a $0.10 wide bid-ask, your actual fill is closer to $1.10 than $1.20. At 250 trades per year, that $0.10 slip compounds.
The bid-ask widens before earnings and into events. Exactly when VRP looks richest, spreads are widest.
Volume is zero in historical chains. Use OI as a liquidity proxy and apply a conservative fill model for low-OI strikes.

A tractable fill model:

Fill_sell = Mid(t) − α · (Ask(t) − Bid(t)) / 2
Fill_buy  = Mid(t) + α · (Ask(t) − Bid(t)) / 2

Where α in [0.3, 0.7] is a market-impact parameter. Use α = 0.5 as a baseline; test sensitivity before claiming edge.

def fill_price(bid: float, ask: float, side: str, alpha: float = 0.5) -> float:
    mid = (bid + ask) / 2
    half_spread = (ask - bid) / 2
    if side == "sell":
        return mid - alpha * half_spread
    return mid + alpha * half_spread

def fill_spread(leg1, leg1_side, leg2, leg2_side, alpha=0.5) -> float:
    f1 = fill_price(leg1["bid"], leg1["ask"], leg1_side, alpha)
    f2 = fill_price(leg2["bid"], leg2["ask"], leg2_side, alpha)
    return f1 - f2

Metrics

Sharpe assumes normal returns; options premium-selling has negative skewness and excess kurtosis. Report Sharpe as a directional indicator, but lean on Sortino, Calmar, and maximum drawdown for sizing. A 70% win rate with a 3:1 loss-to-win payoff is a losing strategy.

Example strategies

Dealer-positioning momentum

When dealers are net short gamma, they buy into rallies and sell into drops to stay delta-neutral, amplifying directional moves. A momentum signal conditioned on negative-gamma regime should outperform an unconditional one.

At 9:45 ET, pull /v1/exposure/summary/{t} to determine the regime.
If net_gex < 0 and the 5-day EMA of net_gex is declining, the regime is "amplifying."
Compute the opening 15-minute return. If positive in an amplifying regime, go long a 1-week ATM call debit spread; if negative, a 1-week ATM put debit spread.
Exit at 14:30 or 2x the initial mid, whichever comes first.
Flat when regime is positive gamma or undefined.

VRP premium-selling

Implied vol systematically overstates realized vol on average. When VRP is in the upper tercile, selling premium has historically had positive expected value.

Daily, gate on vrp_percentile ≥ 75 and vrp_regime == "rich".
Sell a 30-delta put credit spread 21 DTE, short put at the put wall, long put $5 further OTM.
Exit at 50% of initial credit or 7 DTE.
Apply the fill model with α = 0.5, cap at 2% notional per trade.

Realized-vol dispersion

The implied vol of an index exceeds the weighted implied vol of its constituents; the excess is the correlation risk premium. Long single-name straddles, short index straddle, vega-neutral. Pull /v1/adv_volatility/{name} per constituent and for the index on the same timestamp.

Validation and pitfalls

Walk-forward, not in-sample optimization. Fit on a training window, evaluate on the next held-out window, roll forward.
Out-of-sample periods must include stress events. A backtest that excludes March 2020, August 2024, and Q4 2018 is an in-sample fit on calm markets.
Costs must be large enough to matter. If removing slippage changes Sharpe by more than 0.3, the edge is in the cost model.
Regime sensitivity test. Split by VIX tercile. If it only works in one regime, say so.

The kinks and common mistakes

Kink 1: Survivorship bias. A fixed ticker list (today's S&P 500) excludes names delisted or merged before today but present at the time. Construct the universe from point-in-time index membership.

Kink 2: Lookahead in computed analytics. VRP percentile computed over the full sample ranks a 2019 reading against observations that had not happened yet. Verify the window is trailing.

Kink 3: Restatement and non-determinism. Recomputed analytics change if methodology updates. Archive raw responses for bit-exact reproducibility.

Kink 4: Ignoring fills and slippage. A 1-DTE short straddle mid-priced at $3.20 with a $0.25 spread costs $0.50 round-trip, 15.6% of premium. Apply the fill model and vary α from 0.3 to 0.7.

Kink 5: Overfitting strike, expiry, and threshold. Many free parameters. Treat threshold as a hyper-parameter, fit on training only, test out-of-sample with it locked.

Kink 6: Regime dependence without disclosure. VRP selling wins slowly in calm markets, loses quickly in spikes. Report Calmar, worst drawdown, and drawdown duration. Backtest any drawdown breaker as a system parameter.

Kink 7: Point-in-time OI vs revised OI. Using finalized OI for a 14:30 signal is lookahead. Verify you use the preliminary morning publication.

Kink 8: Train/test leakage via shared normalization. Fit all preprocessors on training data only, then transform both train and test with frozen parameters.

Kink 9: Research vs production data mismatch. The historical option-quote shape differs from live (flat array, renamed fields). Write one parser that handles both, test against both before deploying.

Kink 10: Assignment and pin risk near expiry. A short put ITM within 2 to 3 DTE carries early-assignment risk. For credit spreads, pin risk leaves a naked overnight position with gap risk. Flag any position at 1 DTE with the short strike within 1% of spot, and apply a conservative exit fill.

Worked example: a VRP backtest sketch

A condensed but complete sketch of a 30-delta put credit spread backtest on SPY using the VRP signal.

from datetime import date
import pandas as pd
import requests
from flashalpha_historical import FlashAlphaHistorical

API_BASE = "https://lab.flashalpha.com"
API_KEY  = "YOUR_KEY"
hx = FlashAlphaHistorical(api_key=API_KEY)

SIGNAL_OPEN_HOUR  = "15:30:00"
VRP_PCTILE_THRESH = 75
IV_RANK_THRESH    = 40
ALPHA_FILL        = 0.5
DTE_OPEN          = 21

start, end = date(2019, 1, 2), date(2024, 12, 31)
cal_days = pd.bdate_range(start, end, freq="B")
rebalance_dates = cal_days[::5]  # weekly

trades = []
for rd in rebalance_dates:
    ts = f"{rd.isoformat()}T{SIGNAL_OPEN_HOUR}"
    try:
        vrp_data = hx.vrp("SPY", at=ts)
        vol_data = hx.volatility("SPY", at=ts)
        exp_data = hx.exposure_summary("SPY", at=ts)
    except Exception:
        continue

    if (vrp_data["vrp_percentile"] < VRP_PCTILE_THRESH or
            vol_data["iv_rank"] < IV_RANK_THRESH or
            exp_data["regime"]["label"] not in ("positive_gamma", "neutral")):
        continue

    put_wall = exp_data["levels"]["put_wall"]
    chain = requests.get(
        f"{API_BASE}/v1/options/SPY",
        headers={"X-Api-Key": API_KEY},
        params={"date": ts}
    ).json()

    short_put = next(
        (c for c in chain
         if c["option_type"] == "P"
         and abs(c["strike"] - put_wall) <= 2.5
         and DTE_OPEN - 3 <= c["days_to_expiry"] <= DTE_OPEN + 3), None)
    if short_put is None:
        continue
    long_put = next(
        (c for c in chain
         if c["option_type"] == "P"
         and c["strike"] == short_put["strike"] - 5
         and c["days_to_expiry"] == short_put["days_to_expiry"]), None)
    if long_put is None:
        continue

    short_fill = fill_price(short_put["bid"], short_put["ask"], "sell", ALPHA_FILL)
    long_fill  = fill_price(long_put["bid"],  long_put["ask"],  "buy",  ALPHA_FILL)
    net_credit = short_fill - long_fill
    if net_credit <= 0:
        continue

    trades.append({
        "open_date":    rd,
        "short_strike": short_put["strike"],
        "long_strike":  short_put["strike"] - 5,
        "net_credit":   round(net_credit, 4),
        "vrp_pctile":   vrp_data["vrp_percentile"],
    })

df = pd.DataFrame(trades)
print(f"Trades: {len(df)}")

What this sketch leaves out, deliberately, as kink-avoidance exercises: the exit loop, the assignment model, the drawdown breaker, and walk-forward parameter selection.

Tooling: endpoints and the MCP connector

Endpoint	Use	Tier
`GET /v1/exposure/gex/{t}?date=`	Net GEX by strike, gamma flip, walls	Alpha
`GET /v1/exposure/summary/{t}?date=`	Full dealer-positioning state	Alpha
`GET /v1/options/{t}?date=`	Full option chain: IV, greeks, OI, bid/ask	Alpha
`GET /v1/vrp/{t}/history`	VRP series, z-score, percentile	Alpha
`GET /v1/volatility/{t}?date=`	IV, realized vol, skew, term structure	Alpha
`GET /v1/surface/{t}?date=`	50x50 IV surface grid (minute-level)	Alpha
`GET /v1/adv_volatility/{t}?date=`	SVI params (EOD), variance surface, arb flags	Alpha
`POST /v1/screener`	Universe filter on GEX, VRP, IV rank, regime	Growth

# Historical replay
from flashalpha_historical import FlashAlphaHistorical
hx = FlashAlphaHistorical(api_key="YOUR_KEY")
snap = hx.exposure_summary("SPY", at="2022-06-15T14:30:00")

# Live production, same method names, no at=
from flashalpha import FlashAlpha
fa = FlashAlpha(api_key="YOUR_KEY")
snap = fa.exposure_summary("SPY")

For LLM-augmented research, the quant MCP connector exposes the full Historical API as callable tools:

{
  "mcpServers": {
    "flashalpha-quant": {
      "url": "https://lab.flashalpha.com/mcp-oauth/quant"
    }
  }
}

Conclusion

The systematic options research pipeline has three honest bottlenecks: point-in-time data, a realistic fill model, and discipline against the ten kinks that inflate backtested Sharpe before live trading reveals the truth.

Once the backtest is validated, the production migration is a one-parameter change: remove at= from each call and the same code runs live. That is the architectural reason to use a pre-computed analytics layer rather than building a raw-chain pipeline from scratch.

This post was originally published on FlashAlpha. FlashAlpha provides pre-computed options analytics (GEX, DEX, VEX, CHEX, SVI surfaces, VRP) for 6,000+ US equities and ETFs via API. Free API key, no credit card.

Volatility Relative-Value Trading: The Complete Guide

tomasz dobrowolski — Mon, 08 Jun 2026 07:40:35 +0000

Originally published on the FlashAlpha Research blog.

What relative-value volatility trading is

A directional equity trader has a view on where the stock goes. A volatility relative-value trader has a view on how much it should cost to insure it, and on whether that cost is mispriced relative to history, relative to a model, or relative to another asset. The underlying price is not the primary variable: implied volatility is.

Relative-value vol trading exploits dislocations in the implied volatility surface: one tenor trading too rich versus another (calendar trades), the put wing too expensive versus fair value (skew trades), index implied correlation diverging from single-name vols (dispersion), or the market pricing future variance above what realised variance will deliver (variance or volatility risk premium). The common thread is that every trade is structural and model-referenced, not a directional bet on the S&P going up or down.

This matters because the risk profile is different. A well-constructed vol-arb trade is delta-hedged and, when also vega-hedged across legs, is primarily exposed to the shape of the surface rather than its level. That shape exposure (the relative cheapness or richness of one part of the surface versus another) is more persistent and mean-reverting than the level of implied vol itself. That is the edge.

The toolkit

SVI surfaces and arbitrage-free constraints

The Stochastic Volatility Inspired (SVI) parameterisation, due to Gatheral (2004), maps log-moneyness k to total implied variance w for a single expiry slice:

w(k) = a + b·[ ρ(k − m) + sqrt((k − m)² + σ²) ]

where k = ln(K/F) is log-moneyness relative to the forward F, and the five parameters carry clear economic content:

a is the overall level of variance (vertical shift)
b is the angle of the smile wings (controls vol-of-vol)
ρ is put/call asymmetry (negative in equity markets due to the leverage effect)
m is the moneyness at which the smile is most symmetric
σ is the curvature of the ATM region

Five parameters describe a liquid equity smile. The real difficulty is not the fitting; it is ensuring the fitted surface is arbitrage-free. Two static arbitrage conditions must hold. No butterfly arbitrage means the risk-neutral density must be non-negative at every strike, which translates to a non-negative second derivative of total variance in log-moneyness. No calendar arbitrage means total variance must be non-decreasing across expiries at every moneyness. If either fails, you have a surface that implies free money, and any trade priced off it is wrong in an unbounded way. Arbitrage detection is the first deliverable to check, not an afterthought.

Variance swap replication and the var-swap strike

A variance swap pays the difference between realised variance and a fixed strike agreed at inception. The fair strike is the replication-theoretic value (Demeterfi et al. 1999):

K_var = (2/T) · [ ∫₀ᶠ P(K)/K² dK + ∫ᶠ^∞ C(K)/K² dK ]

Because the integrand spans all strikes, you need a complete smile, which is exactly what the SVI fit provides. The numerical integral over the smile gives a clean, arb-consistent fair value for realised variance that goes beyond ATM implied vol. The convexity adjustment (fair vol minus ATM IV) measures how much the wings contribute; when the put wing is rich, the fair var-swap vol sits above ATM IV, and selling vol via variance swaps captures that richness.

Variance risk premium versus volatility risk premium

This is one of the most conflated concepts in practice. The variance risk premium (VaRP) is the expected profit from selling a variance swap and delta-hedging: it operates on squared vol. The volatility risk premium (VolRP) is the P&L from selling a vega-neutral straddle and continuously delta-hedging: it operates on vol itself.

VaRP = K_var − E[σ_R²]      VolRP = σ_IV,ATM − E[σ_R]

These diverge because of the nonlinear relationship between variance and vol. In the tails, variance grows quadratically while vol grows linearly, so fat-tail regimes inflate VaRP far more than VolRP. A strategy that looks like it is selling VaRP may actually be mostly selling VolRP with a highly convex residual tail exposure, and vice versa. Knowing which you are trading, and sizing accordingly, is critical.

Skew and term structure

The surface has two primary shape dimensions beyond the ATM level. Skew is the slope of implied vol across strikes at a fixed expiry; in equity markets the put wing is systematically richer than the call wing. Term structure is the slope of ATM implied vol across expiries: contango (front below back) is normal, backwardation occurs around events that concentrate near-term uncertainty. Calendar trades buy cheap tenors and sell rich ones.

Spot-vol correlation is a further shape measure. When spot falls, vol typically rises (negative spot-vol correlation in equities). A surface with very steep downside skew reflects a high-magnitude negative spot-vol correlation priced into the smile.

Dispersion and implied correlation

Implied correlation is extracted by comparing index implied vol to single-name implied vols:

ρ_implied = (σ_index² − Σ wᵢ²σᵢ²) / (2 Σ_{i<j} wᵢ wⱼ σᵢ σⱼ)

Implied correlation is typically higher than realised because the index put skew is structurally bid: investors pay up to hedge the index as a unit rather than buying individual-name puts. A dispersion trade sells index vol and buys single-name vols (or vice versa), monetising the spread. When implied correlation exceeds realised, the index is rich relative to constituents: sell the index, buy the names.

Reading the data

SVI parameters: what the numbers tell you

import requests

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

for s in d["svi_parameters"]:
    print(
        f"{s['expiry']} ({s['days_to_expiry']}d): "
        f"a={s['a']:.5f}  b={s['b']:.5f}  "
        f"rho={s['rho']:.4f}  m={s['m']:.4f}  sigma={s['sigma']:.4f}  "
        f"ATM IV={s['atm_iv']:.2f}%  arb_free={s.get('arb_free', True)}"
    )

Interpretation per parameter:

rho more negative than −0.7: extremely steep put skew. Often indicates event risk or structural demand for downside protection. Check whether it is a single-name earnings effect or a broad index regime.
b above 0.15: wide wings, large moves priced at both extremes. High b with a normal rho means symmetric wing richness, which is unusual and may indicate a vol-of-vol dislocation.
sigma near zero: a nearly V-shaped smile with minimal ATM curvature. Numerically fragile; arb violations are more likely.
cross-slice rho flattening: near-term slices are usually steeper than long-dated ones. If the long end suddenly steepens to match, the long end is pricing a structural change.

Arbitrage flags: non-negotiable checks

flags = d.get("arbitrage_flags", [])
if flags:
    for f in flags:
        print(f"[{f['type'].upper()}] {f['expiry']} moneyness={f.get('moneyness','n/a')}: {f['description']}")
else:
    print("Surface is arbitrage-free")

A butterfly violation means the risk-neutral density goes negative at that moneyness, so any price referencing that region is undefined. A calendar violation means a calendar spread there is a free lunch. Do not trade off a surface with active flags.

Variance surface and var-swap strikes

for vs in d["variance_swap_fair_values"]:
    K_var     = vs["K_var"]            # fair variance strike (annualised)
    fair_vol  = vs["fair_vol"]         # sqrt(K_var), vol units
    convexity = fair_vol - vs["atm_iv"]
    print(
        f"{vs['expiry']}: fair_vol={fair_vol:.2f}%  "
        f"ATM={vs['atm_iv']:.2f}%  convexity_adj={convexity:+.2f}pp"
    )

The convexity adjustment directly measures how much the wings cost relative to ATM. Above +1.5pp for SPX is historically elevated, indicating the market is paying a premium for tail coverage beyond what ATM vol implies. Track the time series and you have a clean signal for when variance swaps are cheap or rich relative to straddles.

Dispersion and spot-vol correlation

disp = requests.get(
    "https://lab.flashalpha.com/v1/dispersion",
    params={
        "index": "SPX",
        "symbols": "AAPL,MSFT,NVDA,AMZN,GOOGL",
        "weights": "0.07,0.07,0.06,0.05,0.05",
        "horizon_days": 20,
    },
    headers={"X-Api-Key": "YOUR_API_KEY"}
).json()

print(f"Implied correlation:  {disp['implied_correlation']:.4f}")
print(f"Realised correlation: {disp['realized_correlation']:.4f}")
print(f"Corr premium:         {disp['correlation_premium']:+.4f}")

The trades

Calendar / term-structure trades

A calendar spread buys total variance at one expiry and sells it at another. Compute the ATM IV ratio between front and back via /v1/volatility/skew-term. If the ratio is in the top decile of its history, the front is rich: sell front variance, buy back variance. Size to vega-neutrality across the two legs, not notional-neutrality.

ts = requests.get(
    "https://lab.flashalpha.com/v1/volatility/skew-term/SPX",
    headers={"X-Api-Key": "YOUR_API_KEY"}
).json()

front = ts["term_structure"][0]
back  = ts["term_structure"][-1]
print(f"Front/back ratio: {front['atm_iv'] / back['atm_iv']:.4f}")
print(f"Regime: {ts['term_structure_regime']}")

Event distortions. The front ratio inflates mechanically before FOMC, CPI, and earnings because the near-term expiry prices the event premium. A top-decile ratio during a FOMC week is not a calendar opportunity; it is the options market correctly pricing the event. Check the term-structure endpoint's event flags first.

Skew / risk-reversal trades

A risk reversal sells an OTM put and buys an OTM call at the same delta, delta-hedged: a pure bet on the skew level.

RR25 = σ_IV(Δput = −0.25) − σ_IV(Δcall = +0.25)

A 25-delta RR in the bottom decile (puts cheap relative to calls, rare in equities) is a long-skew opportunity. A top-decile RR (puts extremely rich) is a short-skew opportunity, but timing matters enormously because equity skew is structurally bid and can stay rich for months.

Dispersion

The canonical dispersion trade sells index variance and buys single-name variance in proportion to index weights. The P&L is driven by the off-diagonal cross-terms: each constituent pair contributes its weighted vol product weighted by the correlation gap. When implied correlation exceeds realised, selling the index and buying the names earns positive carry.

Regime risk. Correlation is regime-switching. In a broad risk-off event (March 2020, the 2022 rate shock), realised correlation spikes above 0.9 and the dispersion trade loses catastrophically because single-name vol cannot offset the index move. Sizing requires explicit correlation-scenario stress testing, not just historical mean-reversion assumptions.

Variance vs vol RP trades

vrp = requests.get(
    "https://lab.flashalpha.com/v1/vrp/SPX",
    headers={"X-Api-Key": "YOUR_API_KEY"}
).json()

print(f"VRP (variance basis): {vrp['variance_risk_premium']:.2f}pp")
print(f"VolRP (vol basis):    {vrp['volatility_risk_premium']:.2f}pp")
# VRP z >> VolRP z: wings rich, convexity elevated
# VolRP z >> VRP z: wings cheap, ATM richness dominates

When the convexity adjustment widens, the wings are expensive relative to ATM; a ratio spread long ATM and short the wings monetises it. When it compresses, butterfly buyers and long vol-of-vol positions benefit.

Risk and sizing

Every vol-RV trade should be vega-hedged at the trade level: the book earns from surface-shape dislocations, not from the level of vol. Net vega across all legs should sit close to zero, rebalanced at least daily. Gamma neutrality is harder to hold simultaneously, since in a calendar the short front leg has far higher gamma than the long back leg, so you will carry net gamma. For a multi-name dispersion book, report risk in vega-weighted terms per name, normalising by vol-of-vol (proxy via b from the SVI fit), because 10,000 vega in NVDA carries more vol-of-vol risk than 10,000 vega in MSFT.

The residual risk in a delta- and vega-neutral book is correlation risk, which is fat-tailed and regime-switching. Size as a fraction of the risk budget assuming realised correlation can spike 0.3 to 0.5 above its long-run mean in a single macro shock, and confirm the resulting P&L stays inside your drawdown limit.

The kinks and common mistakes

1. Trading off a non-arbitrage-free surface. A butterfly failure implies negative probability density. The symptom is subtle: a calendar that should pay positive carry bleeds theta because the fit is locally inconsistent. Check arb_free per slice before placing any trade.

2. Conflating VaRP with VolRP. A high VolRP z-score says ATM straddles are rich. A high VaRP z-score says the wings are rich too. Selling a straddle when VaRP is rich but VolRP is flat earns no premium; the wing richness lives in the variance-swap convexity adjustment. The correct trade there is a ratio spread, not an outright straddle sale.

3. Liquidity filtering of SVI fits. Stale, zero-OI, or wide-market strikes distort the fit. Rich/cheap signals in the far wings are often artefacts of liquidity gaps, not real dislocations. Cross-check wing signals against raw chain liquidity.

4. Dispersion correlation regime shifts. The implied-exceeds-realised argument is valid in low-correlation regimes. During a macro sell-off, realised correlation jumps toward 1.0 and the trade loses on both legs at once. Require hard stop-losses on realised correlation.

5. Term-structure event distortions. A calendar that looks rich on the ATM ratio alone may be fully justified by an event in the front expiry. Check event flags on both legs before interpreting front-month richness as a calendar opportunity.

6. Realised vol estimator choice. Close-to-close is biased by overnight gaps and noisy for short windows. Yang-Zhang uses overnight, open-to-close, and close-to-close returns simultaneously for lower variance. The choice can shift apparent richness by 0.5 to 2pp, enough to flip a weak z-score signal.

Worked example: an SPX surface snapshot

Representative figures, illustrative rather than live:

Metric	Front (21d)	Back (49d)	Read
ATM IV	17.4%	15.8%	Ratio 1.10, mild backwardation, front modestly rich
25Δ RR	−4.2pp	−3.1pp	Front put wing steeper, within normal range (~60th pctile)
Var-swap fair vol	19.1%	17.2%	Convexity +1.7pp and +1.4pp above ATM, wings elevated
Butterfly (25Δ)	1.8pp	1.5pp	Wing curvature above ATM, consistent with convexity
Arb flags	None	None	Trade-ready on both slices

The front convexity adjustment of +1.7pp is elevated versus the historical mean near 1.0pp for SPX, so variance swaps are expensive relative to straddles. A ratio spread (long ATM, short wings) or an outright var-swap sell is more attractive than a simple straddle sale. The skew signal is neutral at the 60th percentile, so no standalone RR trade is justified.

import requests, numpy as np

adv = requests.get("https://lab.flashalpha.com/v1/adv_volatility/SPX",
                   headers={"X-Api-Key": "YOUR_API_KEY"}).json()
hist = requests.get("https://lab.flashalpha.com/v1/surface/history/SPX?lookback_days=90",
                    headers={"X-Api-Key": "YOUR_API_KEY"}).json()
skew = requests.get("https://lab.flashalpha.com/v1/volatility/skew-term/SPX",
                    headers={"X-Api-Key": "YOUR_API_KEY"}).json()

rr_today = skew["term_structure"][0]["risk_reversal_25d"]
rr_hist  = [s["risk_reversal_25d"] for s in hist["skew_history"]]
rr_pctile = np.mean(np.array(rr_hist) <= rr_today) * 100
front_arb_free = adv["svi_parameters"][0].get("arb_free", True)

if rr_pctile > 85 and front_arb_free:
    print("PUT WING RICH: short skew / short RR candidate")
elif rr_pctile < 15 and front_arb_free:
    print("PUT WING CHEAP: long skew / long RR candidate")
else:
    print(f"No skew signal: RR at {rr_pctile:.0f}th percentile")

Endpoints for vol-arb

Endpoint	Delivers	Tier
`/v1/adv_volatility/{t}`	SVI params, variance surface, arb flags, var-swap fair values	Alpha
`/v1/surface/{t}`	Full IV surface grid (historical replay available)	Alpha
`/v1/surface/svi/{t}`	Per-bucket IV with rolling mean and z-score	Alpha
`/v1/vrp/{t}`	Variance RP, vol RP, z-scores	Alpha
`/v1/dispersion?index=...&symbols=...&weights=...`	Implied/realised correlation, premium	Alpha
`/v1/volatility/skew-term/{t}`	ATM IV, 25Δ RR, butterfly, regime, event flags	Growth
`/v1/volatility/spot-vol-correlation/{t}`	30d, 90d, 6m spot-vol correlation	Growth
`/v1/volatility/{t}`	ATM IV, Yang-Zhang and close-to-close realised vol, IV rank	Growth

For a Claude-based research or signal-generation agent, the vol-arb MCP connector is at https://lab.flashalpha.com/mcp-oauth/volarb, exposing the advanced volatility, VRP, surface, dispersion, and term-structure tools as Claude-callable functions.

Conclusion

The edge in relative-value volatility is exposure to the shape of the surface, not its level, and shape is more persistent and mean-reverting than level. Capturing it cleanly depends on an arbitrage-free fit, a clear separation between variance and volatility risk premium, and explicit correlation-scenario sizing for anything dispersion-shaped. Get the surface right first; the trades follow from it.

Originally published on FlashAlpha. FlashAlpha provides SVI surfaces, var-swap strikes, VRP decomposition, dispersion, and term structure as structured JSON for 6,000+ US equities and ETFs. Free API key, no credit card.

Best Options Data APIs 2026: 7 Compared (Pricing & Free Tiers)

tomasz dobrowolski — Sun, 07 Jun 2026 07:00:40 +0000

Full disclosure: I built FlashAlpha. I am going to be honest about where every other provider beats us, because lying in a comparison guide gets you exactly one click and zero customers.

The seven that actually matter

The "options data API" search returns dozens of providers. Most are repackaged Polygon, dead startups, or enterprise tools nobody under $1M revenue can afford. These seven are the ones real quants and developers actually choose between:

Provider	Best for	Starting price	Free tier
Polygon.io	Raw market data infrastructure, tick-level history	$29/mo (stocks) + $79/mo (options)	5 calls/min, no options
ORATS	Historical data, backtesting, 25 years of history	$99/mo	14-day trial
Tradier	Brokerage-attached API, retail traders, sandbox	$10/mo (data) or free with brokerage account	Sandbox account
Intrinio	Institutional fundamental + options data combo	~$1,000/mo+	Limited demo
ThetaData	Cheap historical options tick data for quants	$80/mo	None (paid only)
Unusual Whales	Flow alerts, dark pool prints, congressional trades	$48/mo retail / API on request	None
FlashAlpha	Pre-computed exposure analytics (GEX/DEX/VEX/CHEX), max pain, vol surfaces	Free / $79 / $299 / $1,499/mo	5 req/day, no time limit, no card

That is the table you came for. Now let me explain why the choice matters and which one fits which job.

What are you actually building?

Most developers waste their first month picking an API on price or feature lists without asking what data they actually need to fetch. Five common project types and the right starting point for each:

1. A backtesting engine. Start with ORATS or ThetaData. Both have deep historical options data with greeks attached. ORATS gives you a hosted backtesting engine (300M+ pre-computed backtests) and 98 proprietary indicators if you do not want to build the strategy logic yourself. ThetaData is cheaper per gigabyte if you are comfortable writing your own framework and pulling raw end-of-day data.

2. A real-time GEX dashboard. Start with FlashAlpha. Real-time per-strike gamma exposure, gamma flip levels, call/put walls, and dealer regime classification, pre-computed in a single API call. Polygon and Tradier give you the raw chain, but you will need to compute the greeks yourself, then aggregate by strike, then label the regime. That is 2,000+ lines of code before your first chart.

3. API access for a brokerage workflow. Start with Tradier. If you already trade with Tradier, the data is bundled with the account, the API is free for active traders, and the sandbox lets you build before funding. No pre-computed analytics, though. Good for execution-adjacent automation, bad for analytical research.

4. A SaaS product needing every contract on every US underlying. Start with Polygon.io. They are the infrastructure layer: tick-level history, full chains, websocket streaming, real-time consolidated quotes. Expensive at scale but the most complete raw feed in the retail-accessible range. Use Polygon for the data, build (or rent) analytics on top.

5. Following flow, dark pool prints, unusual activity, congressional trades. Start with Unusual Whales. They built a product around the "follow the smart money" thesis. The data is opinion-laden in a way the others are not. You are getting their interpretation of "unusual" baked in, which is fine if you trust the definition and a problem if you want to define your own.

The three categories nobody names

Once you have narrowed by use case, the seven fall into three categories none of their marketing pages name out loud. Knowing the category is more useful than any feature list.

Category A: Raw data infrastructure (Polygon, Tradier, ThetaData). They give you the chain - bid, ask, IV, OI, volume, sometimes greeks - and you bring the analytics layer. Best for teams that want full control of the pipeline. Trade-off: 4-8 weeks building the analytics layer before your first useful screen. Cheapest long-term if you have engineers and time; fastest path to a delayed launch if you have a deadline.

Category B: Pre-computed analytics (ORATS, FlashAlpha). These ship analytics with the data - regime labels, GEX, vol surfaces, strategy scores, VRP. You pay for the math to be done for you. Best for teams whose value-add is the strategy, not the data engineering. Trade-off: you are locked into someone else's definitions. The category splits on the time axis - ORATS optimises for EOD depth (25 years back to 2007), FlashAlpha for minute-level dealer-positioning analytics (live, plus a historical API replaying every analytics endpoint at any minute since April 2018 in the same response shape). ORATS goes wider, FlashAlpha goes deeper.

Category C: Flow and sentiment products (Unusual Whales, SpotGamma, Intrinio). These wrap data in a UX or a thesis. You pay for opinion as much as data. Best for traders who want a commentary or alert stream rather than building from raw inputs. Trade-off: less programmatic flexibility - the best content often lives behind a web dashboard, not an API.

What each one does best, in one sentence

Polygon.io - Best raw options data infrastructure in the retail-accessible price range. Buy if your team will build the analytics layer.
ORATS - Best for historical backtesting and 25 years of consistently-computed indicators. Buy if your strategy needs to backtest across multiple regimes.
Tradier - Best brokerage-attached API. Buy if you are already a Tradier customer or want bundled execution and data.
Intrinio - Best for combining fundamentals with options in one bill. Buy if you have $1K+/mo budget and need both.
ThetaData - Best cheap historical options tick data. Buy if you are a price-sensitive quant comfortable with raw data engineering.
Unusual Whales - Best flow alerts and "follow the smart money" product. Buy if you want opinion-laden alerts rather than building from raw data.
FlashAlpha - Best pre-computed dealer-positioning analytics (GEX, DEX, VEX, CHEX, max pain, regime, VRP) with a matched live + historical API. Buy if you want to ship a GEX dashboard or premium-selling scanner this week instead of next quarter.

The stacks that actually work

Most serious teams combine two providers. The three I see most often:

Backtest + live execution. If you need pre-2018 EOD depth or ORATS's proprietary indicators, use ORATS for deep-history validation and FlashAlpha for live signals plus intraday research since 2018. If your strategy is dealer-positioning-driven, FlashAlpha alone works - the historical API replays every live endpoint at any minute since April 2018 in the same shape, so backtest and production run the same code path.

Raw data + custom analytics. Polygon for the raw chain, in-house Python for everything else. Full methodology control, slowest to first value, cheapest at scale.

Flow alerts + positioning context. Unusual Whales for the alerts, FlashAlpha for the positioning. When the alert fires "TSLA unusual call activity," check whether TSLA is in positive or negative gamma, where the call wall is, and what the VRP looks like. The alert tells you something is happening; the positioning tells you whether to fade or follow it.

Decide in under five minutes

Work down this list and stop at the first match:

EOD backtesting engine needing pre-2018 data → ORATS
Backtesting a dealer-positioning or intraday strategy since 2018 → FlashAlpha (Alpha tier, historical API)
Every options contract on every US underlying with full tick history → Polygon.io
Retail trader already on Tradier → Tradier API (free for you)
Ship a GEX dashboard or VRP scanner this week → FlashAlpha (free tier, no card)
Flow alerts and "what are the smart traders doing today" → Unusual Whales
Fundamentals + options in one bill, $1K+/mo budget → Intrinio
Cheap quant who will write your own pipeline against raw tick data → ThetaData

If two or more match, read the dedicated pairwise comparison - the headline difference is rarely the actual decision driver.

What changed in 2026

Free tiers are table stakes. The "no credit card" free tier used to be a differentiator. Now Polygon, Tradier sandbox, and newer entrants all offer one. The bar for "show me before you charge me" is permanently higher.
Pre-computed analytics is a category. Until 2024, most providers shipped raw data and expected you to build analytics (ORATS aside). Buyers now ask "what do you compute for me?" not just "what data do you ship?"
Point-in-time analytics replay is new. A historical API mirroring every live analytics endpoint at minute resolution since April 2018, in the same response shape, is a shape that did not exist before. Raw historical data is still a commodity; the minute-level computed-analytics replay is the new part.
MCP servers are an unlock. Model Context Protocol lets LLM assistants (Claude, Cursor, Windsurf) query providers directly. If your dev workflow involves an LLM - and most do in 2026 - MCP support is a real differentiator.
0DTE is its own product. Same-day expiry now drives enough volume that providers ship dedicated 0DTE endpoints returning pin risk, expected move, and gamma acceleration in real time.

The TL;DR

For the most common case - a developer who wants to build something useful with options data this week without getting locked into a $299/mo bill before validating the idea - start with a free tier (5 calls/day, no card, no time limit) covering GEX, IV, BSM greeks, key levels, and stock quotes for 6,000+ symbols. Prototype a whole premium-selling screener before deciding whether to scale up.

Then pair it with the right second provider. ORATS for backtesting depth. Polygon for raw data scale. Unusual Whales for flow context. The single-vendor stack rarely wins; the two-vendor stack does.

Originally published at flashalpha.com. FlashAlpha provides pre-computed options analytics - GEX, DEX, VEX, CHEX, SVI surfaces, max pain, VRP, and dealer positioning - as a live and historical API for 6,000+ US equities and ETFs.

Alpha Decay in Options Analytics: Which Endpoints Erode With Crowding, and Why the Edge Has a Price

tomasz dobrowolski — Sat, 06 Jun 2026 20:31:07 +0000

If you sell options analytics to prop desks and funds, the first honest question a quant buyer asks is: "If you sell this to everyone, doesn't the edge disappear?" It is the right question, and the lazy answer ("our moat is data depth") does not survive contact with someone who has read the crowding literature. The accurate answer requires separating what actually decays from what does not, because the two are mixed together in any analytics product.

Full disclosure: I build this stack. I am going to be specific about which of our own endpoints carry no edge at all, because the credibility of the parts that do matter depends on not overselling the parts that do not.

What alpha decay actually is

Alpha decay is the erosion of a strategy's excess return over time. It has three distinct drivers, and conflating them is the most common mistake:

Data-mining decay. A backtested edge was partly noise; it shrinks out-of-sample even if nobody else ever sees it. McLean and Pontiff bound this at roughly the 26% out-of-sample decline.
Crowding / publication decay. Once others learn the signal and commit capital, they arbitrage it toward fair value. This is the additional drop from 26% to 58% - the part caused by awareness, not noise.
Capacity decay. A specific case of crowding: the strategy has finite room before the participants' own trades move the price against them. Capacity is a function of liquidity and holding period, not of how clever the signal is.

That last point is the one most relevant to a data vendor, and the one most often abused in marketing. The crowding literature is consistent that decay magnitude scales with capacity constraints: slower, less liquid strategies decay more because they attract more arbitrage capital relative to the liquidity available to absorb it (Why and how systematic strategies decay, 2021). The classic worked example is pairs trading, whose returns compressed materially as hedge funds crowded it after the 1990s.

The corollary matters for honesty. A signal on the most liquid instruments on earth - SPX, SPY, 0DTE index options - has very high capacity, so the marginal participant erodes it slowly. A niche, low-capacity signal erodes fast. Any vendor claiming "we limit subscribers so the edge survives" is only telling the truth for the low-capacity case.

Not every endpoint is an edge

Here is the part that gets skipped. An analytics API is a mix of measurements, risk premia, mechanical effects, and genuine timing signals. Only one of those four classes decays the way the popular usage of "alpha decay" implies.

Class	Endpoints	Decay behaviour	Mechanism / evidence
1. Measurement (was never alpha)	`option_chain`, `option_quote`, `stock_quote`, `greeks`, `solve_iv`, `volatility`, `surface`, `dex`, `vex`, `chex`, `kelly`, `tickers`	None. You cannot decay what was never an edge.	Reports consensus market state or is pure math. Any edge lives in your model of them, not in the number.
2. Risk premia (persistent, time-varying)	`vrp` (the premium itself)	Compresses under crowding but is not eliminated; can invert in stress.	Compensation for bearing variance risk (Carr and Wu, 2009). Paid because short-vol periodically blows up.
3. Mechanical flow (structural)	`max_pain` / pinning, the dealer-hedging component of `gex` and `levels`	Resists crowding decay; erodes instead via front-running and manipulation.	Driven by dealer delta-hedging, not by how many people believe it (Ni, Pearson and Poteshman, 2005).
4. Crowdable timing signals (genuine decay)	`narrative`, the directional read of `exposure_summary`, `zero_dte` timing, front-running a gamma-flip level, VRP strategy scoring, the live `screener`	Real decay with awareness and capital, scaled by capacity.	Publication / crowding effect (McLean and Pontiff, 2016).

Class 1 - measurement endpoints carry no alpha to lose

A real-time options chain, a Black-Scholes greek, a solved implied vol, an SVI-fitted surface, a DEX/VEX/CHEX exposure - these are descriptions of the market's current state. The vol surface is the market's consensus; it cannot be arbitraged away by being widely distributed because it is not a prediction. If you have an edge here, it is in your model spotting that the surface is mispriced relative to your own forecast, and that edge is yours, not the endpoint's. Distributing this data to a thousand desks does not degrade it. This is the bulk of what most buyers actually need, and it is honest to say it does not decay.

Class 2 - the variance risk premium is a premium, not an anomaly

VRP is frequently mis-sold as a decaying "edge." It is not an anomaly; it is compensation for selling volatility insurance, and it is pervasive across assets and regions precisely because someone has to be paid to be short volatility into the next crash. Crowding compresses it - more sellers, thinner premium - but it does not vanish, because the risk it pays for is real and occasionally catastrophic (February 2018's short-vol unwind is the standing reminder). VRP is persistent in expectation, time-varying, and capable of going deeply negative in stress. What decays is the timing overlay on top of it - knowing when to lean in - not the premium itself.

Class 3 - pinning is mechanical, so it resists belief-crowding

Max pain and strike pinning are the most misunderstood case. Ni, Pearson and Poteshman (2005) showed that on expiration dates, optionable stock closes cluster at strike prices, shifting returns by an average of at least 16.5 basis points, with no equivalent effect in non-optionable stocks. The driver is dealer delta-hedging: hedgers of net-long option positions sell above the strike and buy below it, pushing price toward the strike. Because the effect is a mechanical consequence of hedging flow rather than a belief traders can pile into, it does not decay the way a sentiment signal does.

Two honest caveats keep this factual. First, the original evidence covers 1996-2002; market structure has changed materially since, and the rise of 0DTE has compressed the relevant hedging horizon, so the modern magnitude is not guaranteed to match the original study. Second, the same paper found proprietary-trader manipulation contributing to clustering, which means the erosion channel here is front-running and gaming, not crowding-toward-fair-value. The signal is structural, but it is not immortal.

Class 4 - the signals that genuinely decay

This is where "alpha decay" actually applies. A packaged directional narrative, a gamma-flip level traded as a setup, a 0DTE expected-move timing call, a ranked screener of "best" setups - these are predictions that work better when fewer people act on them, and McLean-Pontiff is the empirical anchor: awareness erodes returns.

The crucial distinction is the two-layer nature of a dealer-positioning level. The gamma-flip level as a number is mechanical (Class 3) and persistent. The trade of front-running that level is a Class 4 timing signal and does decay with crowding. Same endpoint, two layers, opposite decay behaviour.

Why the edge has a price

For Class 4 signals - and only those - distribution is the decay variable. The mechanism is a congestion externality: each additional participant acting on a capacity-constrained signal imposes a small cost on everyone already holding it, by moving the price before they can. This is standard limits-to-arbitrage reasoning.

The factual scoping matters: this externality is large for low-capacity signals and small for high-capacity ones. So the correct version of the rationing argument is not "we cap subscribers or the edge dies on everything." It is narrower and defensible:

For genuinely capacity-constrained signals, the value to each holder is a decreasing function of how many other holders there are. The economically efficient price for such a feed is therefore high by construction - the price is the rationing mechanism that keeps per-holder capacity intact.
Mass retail distribution of a niche, low-capacity signal is the fastest way to destroy it.
This is observable in the tiering itself. Measurement endpoints (Class 1, no decay) are cheap or free. The crowdable signals (Class 4) sit in the higher tiers. The price gradient tracks the decay gradient, which is what you would expect if the pricing is doing real work rather than segmenting on willingness-to-pay alone.

The signals worth protecting are protected by the fact that a crowd cannot afford them, and the things a crowd can afford are the ones that do not decay anyway.

Offshoring the quant stack

Strip away the Class 4 signals and look at what is left: Class 1 measurement infrastructure. That is the durable, non-decaying core, and it is also the most expensive thing to build in-house. Replicating it means standing up three functions:

A quant function to build and validate the calculators - greeks hydration, SVI surface fitting with arbitrage constraints, exposure math, VRP estimation. Months of work before the first correct number.
A data function to ingest, store, and serve options data at scale - the minute-level history behind a single liquid name runs into billions of rows - with gap detection and daily reconciliation.
A devops / on-call function to keep the pipeline running every trading day.

For a desk whose actual edge is its trading, not its data infrastructure, the build-versus-buy maths is one-sided. What you are really paying for is the non-decaying measurement layer - the part that stays valuable no matter how many people have it. The Class 4 signals on top stay useful precisely because the price keeps their distribution narrow.

References

McLean, R.D. and Pontiff, J. (2016). "Does Academic Research Destroy Stock Return Predictability?" Journal of Finance 71(1): 5-32.
Ni, S.X., Pearson, N.D. and Poteshman, A.M. (2005). "Stock Price Clustering on Option Expiration Dates." Journal of Financial Economics 78(1): 49-87.
Carr, P. and Wu, L. (2009). "Variance Risk Premiums." Review of Financial Studies 22(3): 1311-1341.
"Why and how systematic strategies decay" (2021). arXiv:2105.01380.

Originally published at flashalpha.com. FlashAlpha provides pre-computed options analytics - GEX, DEX, VEX, CHEX, SVI surfaces, VRP, and dealer positioning - as a live and historical API for 6,000+ US equities and ETFs.

Machine Learning on Options Data: An Honest Quant ML Guide

tomasz dobrowolski — Sat, 30 May 2026 07:53:06 +0000

Options data is one of the densest public-markets modalities and one of the worst-served by ML toolchains. This is a direct tour of eight ML methodologies that have published research or plausible workflows on options, grouped by maturity, with the data shape each one needs, where historical replay actually delivers minute-level signal versus end-of-day, and the honest list of what none of this solves.

I maintain the calculator stack this is written against, so I'll be upfront about the bias: I sell pre-computed analytics on top of historical options data. For a trader the pitch has always been "you don't have to build the calculator yourself." For an ML engineer the pitch is sharper: you don't have to build the training corpus yourself. Most of the exposure summaries, volatility analytics, and quote streams that power the live API are also available point-in-time across the history window. Some pieces (SVI parameters, open interest, macro overlays) are EOD-stamped rather than minute-level, and I'll flag exactly where that matters per methodology.

If you want the case against before the survey, skip to the failures section at the end.

The pipeline problem (why this field is small)

Before any model trains, the data has to be shaped, and options data is uniquely punishing here.

Raw chains aren't features. A quote feed gives you bids and asks per strike. You still need spot, the forward curve, dividends, and a consistent Greeks pass before any of those numbers are usable as model inputs.
Surface fits are not optional. Without an arbitrage-free fit, your "implied volatility" feature is whatever Newton-Raphson converged to per strike, which means your skew, term, and butterfly features are noise plus signal. Models trained on that overfit to fit instability.
Multi-year minute-level coverage is large and hard to join. Spot bars, option quotes per strike per expiration, open interest, macro overlays (VIX, VVIX, SKEW, MOVE), event calendars. Assembling all of this from raw tick providers is measured in months, and then you own the maintenance.
Leakage hides in EOD. Most academic options datasets are end-of-day. Intraday strategies trained on EOD labels are quietly using settlement information that wouldn't have been known mid-session. Backtest looks great, live looks terrible.
Greeks consistency. If your training data has Greeks from one IV-surface assumption and your inference path uses another, you have silent training-serving skew. The feature drifts and you blame the model.

This is why most published ML-on-options papers use a tiny strike subset and a short window. Every methodology below assumes the data is shaped right. If it isn't, your research timeline is consumed before you ever read a paper.

Two SDKs, one wire format

There are two FlashAlpha Python packages, and conflating them is a common mistake.

flashalpha wraps the live service. High-level methods do not accept an at= kwarg.
flashalpha-historical wraps the historical service. Every high-level method requires at= for point-in-time replay.

# Recommended: dedicated historical SDK
# pip install flashalpha-historical
from flashalpha_historical import FlashAlphaHistorical

hx = FlashAlphaHistorical(api_key="YOUR_KEY")
snap = hx.exposure_summary("SPY", at="2020-03-16T15:30:00")
vol  = hx.volatility("SPY", at="2024-06-03T14:30:00")

# Fallback: hit historical REST directly with the same X-Api-Key
import requests
BASE = "https://historical.flashalpha.com"
HEADERS = {"X-Api-Key": "YOUR_KEY"}

def get(path, at, **params):
    params["at"] = at
    r = requests.get(f"{BASE}{path}", headers=HEADERS, params=params, timeout=60)
    r.raise_for_status()
    return r.json()

vol = get("/v1/volatility/SPY", at="2024-06-03T14:30:00")

What historical actually ships: minute-level vs EOD

"Same response shape as live" is true for the analytics surface. It is materially misleading for a handful of endpoints, and the resolution truth matters more than the schema.

Field	Resolution
Per-contract bid, ask, IV, Greeks, spot	Minute, 9:30 to 16:00 ET
50x50 surface grid values	Minute (driven by quotes)
SVI calibration parameters {a, b, ρ, m, σ}	EOD-stamped (one fit per trading day)
Open interest	EOD-stamped
Macro (VIX, VVIX, SKEW, MOVE)	EOD-stamped
Forward prices	EOD-stamped
Per-contract `svi_vol`	Always null in historical (`backtest_mode`)
Per-contract `volume`	Always 0 in historical (use `open_interest`)

That table dictates which methodology survives at minute resolution and which is bounded to EOD.

The maturity map

The eight are not equally mature.

Production-proven: realised-vol regression (1), deep hedging (4) for market makers and option desks.
Research-backed: sequence models on surfaces (3), vol-surface anomaly detection (5), causal inference and event studies (8).
Plausible but not production: regime classification on pre-computed dealer labels (2), generative path augmentation (6), GNNs on chains (7).

I include all eight because the data shape supports all eight. I am not selling all eight as alpha.

If you read nothing else, read this table. It pulls the rest of the article into one place: what each method is mature enough to ship, the resolution constraint that actually bites it, and the tier that unblocks it.

#	Methodology	Maturity	Resolution constraint	Tier to run it
1	Realised-vol regression	Production	Macro overlay is EOD; features otherwise minute	Growth live / Alpha replay
2	Regime classification	Plausible	Labels minute-level; classifier methodology drifts	Growth live / Alpha replay
3	Sequence models on surfaces	Research	Grid minute, SVI latent EOD	Alpha
4	Deep hedging / RL	Production (desks)	Greeks minute, OI EOD, full chain per step	Alpha
5	Surface anomaly detection	Research	Grid minute, SVI reference EOD	Alpha
6	Generative path augmentation	Plausible	Grid minute; can't synthesise unseen tails	Alpha
7	GNNs on chains	Speculative	Chain minute; no known PnL profile	Alpha
8	Causal inference / event studies	Research	Surface minute; statistical power is the limit	Alpha

The pattern is blunt: live feature engineering starts at Growth, and every method that needs point-in-time history is Alpha. The free tier inspects response shapes on a single non-index equity and nothing more.

1. Realised-volatility forecasting (regression)

The simplest, most-published, most reliably useful-at-the-margin target: predict realised vol at a forward horizon (1d, 5d, 21d) given the current implied surface and recent realised history.

Realised vol over horizon h is RV(t, h) = sqrt((252/h) · Σ r²). The vol risk premium is VRP = σ_IV − σ_RV. The forecasting target is the realised side; the implied side is a feature, because traders pricing protection are betting on the future return distribution and that signal leaks into level, skew, and term structure.

Tree ensembles (XGBoost, LightGBM) and small recurrent models exploit this with a feature set that is easy to assemble: realised vol at multiple lookbacks, ATM 30-day IV, 25-delta risk reversal (skew), 30d-vs-90d term slope, 25-delta strangle vs ATM (butterfly), and the macro overlay (EOD-stamped in history).

vol = hx.volatility("SPY", at="2024-06-14T15:30:00")
# realised-vol ladders, ATM IV, skew, term structure
# field names follow the live /v1/volatility response

What it doesn't solve: regime change (the model always lags) and event-driven shocks (FOMC and earnings follow a different conditional distribution; treat them as a separate feature regime). This is the Kaggle-shaped end of options ML. Useful as a building block, not institutional alpha standalone.

2. Regime classification (dealer gamma, VRP)

Conditional strategies are where most options alpha actually lives: sell premium when VRP is rich, buy gamma when dealers are short, fade rallies in positive-gamma regimes, ride them in negative-gamma. Every one needs a label, and labels are where most ML projects on options quietly fail, either look-ahead-biased or arbitrary.

The exposure summary endpoint returns a categorical regime label per minute alongside net GEX, gamma flip, 0DTE contribution, and dealer-positioning interpretations, with the same classifier running across the replay window.

summary = hx.exposure_summary("SPY", at="2024-06-14T15:30:00")
# net GEX/DEX/VEX/CHEX, gamma flip, 0DTE contribution,
# dealer-hedging narrative, regime label

Honest caveat: the classifier evolves as bugs are fixed, so replay reflects current methodology, not a frozen-at-the-time snapshot. If you need bit-exact reproducibility against an older pull, archive your responses. The labels are descriptive, not causal: knowing the market is in a negative-gamma regime doesn't tell you when it ends. Pair with a separate transition-timing model. That's why this sits in "plausible but not production."

3. Sequence models on IV surfaces (LSTM, transformer)

The surface at time t is an (n_strikes by n_expirations) tensor; the sequence over a day is a tensor time series. This is squarely in the modality patch-based transformers, TCNs, and dilated convolutions handle well. The canonical reference is Horvath, Muguruza, and Tomas, "Deep Learning Volatility" (2019), which uses neural nets to price options under rough vol; the inverse problem of predicting surface dynamics uses the same input shape.

SVI fits each expiration slice's total variance w(k) = a + b{ρ(k − m) + sqrt((k − m)² + σ²)}: five parameters per slice, arbitrage-free under explicit constraints.

Feature engineering, in increasing dimensional efficiency: raw IV grid (most expressive, hardest to train), SVI parameters per slice, or whole-surface SVI parameters as global state (lowest-dimensional latent).

Resolution caveat that bites here. The 50x50 grid evolves at minute resolution because it's driven by quotes. The SVI calibration parameters are EOD-stamped. An intraday at= returns the most recent EOD SVI parameters, not a fresh intraday calibration. If your model forecasts the SVI latent, you have one observation per trading day, not per minute. If you use the raw grid, the intraday tensor is real.

surface = hx.surface("SPY", at="2024-06-14T15:30:00")   # minute-level grid
adv     = hx.adv_volatility("SPY", at="2024-06-14T15:30:00")  # SVI (EOD) + arb checks

What it doesn't solve: sub-second mid-quote prediction. Market makers see flow you don't. Stay at multi-second horizons or longer.

4. Deep hedging and RL hedging

This is where the academic literature is strongest and industrial deployment most mature, inside market-maker and exotic-desk shops. You hold a path-dependent position and want a hedging policy that minimises transaction-cost-aware variance, CVaR, or another risk measure. Analytical delta hedging is provably suboptimal under transaction costs and jumps; neural-network policies trained on simulated and real paths beat it.

The objective: min over policy π of ρ(V_T − C_T), where V_T = V_0 + Σ π_t ΔS_t − Σ TC(π_t) and ρ is a convex risk measure. References: Buehler, Gonon, Teichmann, Wood, "Deep Hedging" (2018); Kolm and Ritter (2019); Cao, Chen, Hull, Poulos (2021).

The data requirement is the hardest in this article: the full option chain at every step of every rollout, with full Greeks, so the policy can choose its hedge.

chain = hx.option_quote("SPY", at="2024-06-14T15:30:00")
# flat array, renamed fields: implied_vol (not iv), open_interest (not oi),
# lastUpdate (camelCase). Historical-only: iv_bid, iv_ask, vanna, charm, rho.
# volume always 0 (use open_interest); svi_vol always null (backtest_mode);
# open_interest EOD-stamped.

The minute-level Greeks, bid/ask, and spot anchor are real and usable; EOD OI and the null intraday smoother are the honest limits. Deep hedging is a hedging technology, not an alpha. PnL comes from being a market maker; deep hedging shrinks the residual variance. If you're a directional trader, this isn't your methodology.

5. Vol-surface anomaly detection (unsupervised)

Mispriced surfaces produce structural arbitrage (butterfly, calendar, sticky-strike vs sticky-delta) and unusual structural shifts that precede directional moves. Both are unsupervised: you learn what normal looks like and flag deviations.

Autoencoder on the surface grid. Reconstruction error is the anomaly score. The 50x50 grid is minute-level historically, so this works at minute resolution.
Quote-vs-fit residual analysis. The deviation between minute-level quotes and the EOD SVI fit is itself a signal; a persistent large deviation often precedes a quote correction or flags a stale fit.

Reference: Ackerer, Tagasovska, Vatter, "Deep Smoothing of the Implied Volatility Surface" (2020). The residuals of any smoother are usable as anomaly signals.

adv = hx.adv_volatility("SPY", at="2024-06-14T15:30:00")
# SVI (EOD), variance grid, butterfly/calendar arb flags,
# variance-swap fair values, higher-order Greeks surfaces

What it doesn't solve: anomalies on illiquid strikes are mostly fit noise. Use the liquidity-weighted version.

6. Generative models for vol path augmentation

The 8-year intraday history sounds long until you condition on a joint state: negative dealer gamma, VRP above its 90th percentile, earnings week, VIX between 18 and 22. The sample count drops to single digits. Generative models synthesise realistic-but-novel paths to augment training in those undersampled regions.

Reference: Wiese, Knobloch, Korn, Kretschmer, "Quant GANs" (2020); the architecture has since extended to TimeGAN, conditional GANs on surface tensors, and diffusion models on financial series.

for ts in iter_market_minutes(start="2018-04-16", end="2026-01-01"):
    grid = hx.surface("SPY", at=ts.isoformat())
    yield surface_grid_to_tensor(grid)

What it doesn't solve: synthetic paths can't introduce tail behaviour that wasn't in the training set. A model trained on calm regimes will not invent a COVID-style crash. Generative augmentation expands the interior of your distribution, not its tails. Plan stress tests separately.

7. Graph neural nets on option chains

The most speculative section. I include it because the data shape is right, not because industry adoption is strong. Contracts on the same underlying form a natural graph: strikes connect via butterflies, expirations via calendars, related underlyings (SPX/SPY, sector ETFs and constituents) via vol-of-vol relationships. A GNN with these structural priors can handle the whole surface jointly rather than slice by slice.

chain = hx.option_quote("SPY", at="2024-06-14T15:30:00")
# nodes = per-strike contracts; edges via moneyness/expiry proximity;
# messages carry IV and Greek information

Worth reaching for cross-chain mispricing detection (SPX vs SPY drift, sector ETFs vs constituents) or research where the joint surface structure matters. It's a research direction, not a deployed methodology with a known PnL profile. Calibrate expectations accordingly.

8. Causal inference and event studies

The most under-rated angle. Classical finance has decades of event-study methodology; modern ML adds heterogeneous treatment effect estimation (causal forests, X-learners, doubly-robust estimators give per-firm CATE rather than a single average), counterfactual surface construction (synthetic control on the surface tensor), and IV-crush prediction.

A concrete flow: pull the surface around every earnings announcement in the window. Use trading-day offsets, not calendar-day, and align to the actual announcement timestamp (most issuers report before-open or after-close).

from datetime import timedelta
import pandas_market_calendars as mcal
nyse = mcal.get_calendar("XNYS")

def trading_days_before(dt, n):
    sched = nyse.schedule(start_date=dt - timedelta(days=n*2), end_date=dt)
    return sched.index[-n].to_pydatetime()

def pull_pre_post(symbol, announce_ts, when_announced):
    pre_day  = trading_days_before(announce_ts, 5)
    last_day = trading_days_before(announce_ts, 1)
    if when_announced == "before_open":
        post_day = announce_ts
    else:
        post_day = nyse.valid_days(announce_ts, announce_ts + timedelta(days=5))[1]
    pre  = hx.volatility(symbol, at=f"{pre_day.date()}T15:30:00")
    last = hx.volatility(symbol, at=f"{last_day.date()}T15:30:00")
    post = hx.volatility(symbol, at=f"{post_day.date()}T15:30:00")
    return pre, last, post

Earnings and FOMC dates are well known; the matched surface state isn't, and that's the bottleneck. What it doesn't solve: rare-event causal estimates have wide error bars regardless of ML sophistication. The framework cleans up the analysis; it doesn't manufacture statistical power.

Leakage and point-in-time correctness

The single most common reason ML-on-options papers don't replicate live: training labels built from end-of-day or settlement data that wouldn't have been known at the decision time. The model looks fine in cross-validation and loses money in paper trading. The cause is upstream of the model.

The primitive against this is point-in-time replay. Every historical endpoint accepts at=YYYY-MM-DDTHH:mm:ss and returns the response as it would have been computed at that minute. Feature construction is leak-free by default if you ask for features at t and labels at t+h using at for both.

Checklist:

Are your features as-of t or as-of t-1? Decide explicitly and verify.
Are your labels computed using only data timestamped ≤ t + horizon, not back-revised?
Are your regime labels from the same classifier across history, or did methodology drift?
Does your hold-out split respect time (chronological), not random?
Are event dates aligned to the announcement timestamp (before-open vs after-close)?
Are you treating EOD-stamped fields (SVI, OI, macro) as as-of-most-recent-close, not as-of-minute t?

What ML on options won't solve

The credibility section. Every quant ML engineer has met a vendor who claimed everything.

Sub-second mid-quote prediction. Market makers see the flow; you don't. The information asymmetry is structural.
Regime change prediction. Detection works. Change prediction does not, robustly. Detection plus position sizing is the honest play.
Cross-asset macro. Options data tells you about this underlying. Rates, credit, FX, commodities come from elsewhere.
Survivorship bias. Cross-sectional ML on single-name options is biased toward winners that didn't get delisted. Index ETFs largely sidestep it; single-name work needs explicit handling.
Intraday SVI / OI / macro evolution. EOD-stamped here. If your architecture requires minute-level SVI dynamics, this dataset is not it.
"Same response shape" for everything. True for most analytics endpoints; not for optionquote, maxpain, or stock-summary macro objects. Write your client with awareness.

If your project requires any of the above, this stack is part of the answer, not the whole answer.

The substrate, not the strategy

Eight methodologies, grouped by maturity, mapped to verified endpoints. The honest pitch: this is the data substrate that compresses ML wall-clock from quarters to weeks. It does not manufacture alpha; it removes the pipeline tax. Pick the methodology that fits your research question, recognise that almost all require historical replay, and budget accordingly. For a single non-index equity sniff test, the free tier inspects response shapes. For real work you need the historical replay tier.

Originally published on FlashAlpha Research. Free API key, no credit card: flashalpha.com/pricing.

Connect Claude to a live options-analytics API over MCP (the 2-endpoint gotcha)

tomasz dobrowolski — Fri, 29 May 2026 13:10:21 +0000

FlashAlpha ships two MCP endpoints with the same tool catalogue but different auth, and picking the wrong one is the single most common setup failure. This walks both paths and the errors you will actually hit.

FlashAlpha exposes 40 tools over the Model Context Protocol (23 live, 17 historical-replay), so you can ask Claude about gamma exposure, dealer positioning, volatility surfaces and Greeks in plain English instead of hand-rolling REST calls.

Which endpoint?

Same tools on both. Different authentication. Match the row to the client you are configuring.

Client	URL	Auth
claude.ai (web)	`https://lab.flashalpha.com/mcp-oauth`	OAuth (one-time sign-in)
Claude Desktop	`https://lab.flashalpha.com/mcp-oauth` (current builds) or `https://lab.flashalpha.com/mcp`	OAuth, or API key on older builds
Claude Code (CLI)	`https://lab.flashalpha.com/mcp`	API key per tool call
Cursor / Windsurf / VS Code	`https://lab.flashalpha.com/mcp`	API key per tool call

The one rule: claude.ai web and current Claude Desktop builds use the -oauth endpoint and OAuth sign-in. The CLI and editor clients (Claude Code, Cursor, Windsurf, VS Code) use the plain /mcp endpoint and you hand Claude the key in your first message. If your Desktop build is old enough that OAuth fails, fall back to /mcp and the apiKey path below.

Option 1: OAuth (claude.ai web or Claude Desktop)

Cleanest setup. Sign in once, click Allow, and Claude calls tools on your behalf with no key handling. Works on Free, Pro, Max, Team and Enterprise.

Open claude.ai and sign in.
Your name (bottom-left) then Settings.
Customize then Connectors. On Team/Enterprise the workspace owner adds connectors under Organization settings then Connectors.
Click + then Add custom connector.
Fill in the dialog:
- Name: FlashAlpha
- Remote MCP server URL: https://lab.flashalpha.com/mcp-oauth. The -oauth suffix is required.
- Advanced settings: leave empty. FlashAlpha uses Dynamic Client Registration, so Claude registers itself. No client ID or secret to paste.
Click Add, then Connect.
Sign in on the FlashAlpha page and click Allow. If you are already signed in to flashalpha.com in the same browser, you skip straight to consent.
You land back in Claude and the connector flips to Connected.

On Desktop the only difference is the callback: you get an "Open Claude?" browser dialog that deep-links back into the app. Click Open Claude. That is expected, not an error.

Verify with a new chat: "What is my FlashAlpha account?" Claude calls get_account and returns your email, tier and remaining quota.

Your API key never appears in Claude on this path. The OAuth resource server resolves your account from the bearer token and forwards your stored key on the internal upstream call only.

Option 2: apiKey (Desktop, Cursor, Windsurf, VS Code, Claude Code CLI)

Here each tool takes an apiKey argument. Two steps: register the URL, then tell Claude the key once per chat.

Claude Desktop config:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "flashalpha": {
      "url": "https://lab.flashalpha.com/mcp"
    }
  }
}

Save, then fully quit and reopen Claude Desktop. A reload is not enough; the config is read once at startup.

First message in a fresh chat:

My FlashAlpha API key is fa_xxxxxxxxxxxxxxxxxxxxxxxx.
Use it on every FlashAlpha tool call.

Claude holds the key for the session and passes it as apiKey on every call.

Other clients, same /mcp URL and same chat-paste pattern:

# Claude Code CLI
claude mcp add flashalpha --transport http https://lab.flashalpha.com/mcp

Cursor: Settings then MCP Servers then Add Server. Name flashalpha, URL https://lab.flashalpha.com/mcp.
Windsurf: Cascade then MCP then Add Server, paste the same URL.
VS Code (Copilot / Continue): add { "url": "https://lab.flashalpha.com/mcp" } to your MCP settings.

Why is the key not in the config? Claude Desktop's HTTP-transport MCP config only supports a URL. There is no env or headers pass-through that maps to a tool argument, and the key is a per-tool argument. So it comes from the conversation, or you skip it entirely with the OAuth endpoint.

Troubleshooting

"MCP Server not responding" on claude.ai. You pasted /mcp into a custom-connector dialog that needs OAuth. The /mcp endpoint expects an apiKey argument the browser flow never sends, so the first call hangs. Edit the connector URL to exactly https://lab.flashalpha.com/mcp-oauth and reconnect. This is the one nearly everyone hits.

"A server with this URL already exists" but nothing shows in your Connectors list. Claude.ai recorded the URL during an earlier handshake that failed mid-flow. Try, in order: hard-refresh (Ctrl/Cmd+Shift+R) and retry Add; open claude.ai in an incognito window and Add from there; sign out and back in. If all three still error, send Anthropic support the ofid_... reference from the original failure and ask them to clear the orphaned record.

"A server with this URL already exists" and FlashAlpha is visible. Close the dialog, click the existing entry, use Connect / Reconnect. If stuck, delete from the ... menu and re-add.

"apiKey is required" on Desktop. Config is fine, Claude just has not been told the key in this chat. Paste it as your first message.

"Unauthorized" after hours of working. Token expired before refresh. Settings then Connectors then FlashAlpha then Reconnect.

HTTP 429. Daily quota hit (Free 5/day, Basic 100, Growth 2,500, Alpha unlimited). Reset is midnight UTC, or upgrade.

"no_data" on get_gex, get_levels, get_volatility. Markets are closed. Not a connector bug. Retry during US market hours.

Desktop ignores the new config. You reloaded instead of quitting. Cmd-Q on macOS, tray then Quit on Windows, then relaunch.

What you get once it is green

All 23 live tools work immediately. Highlights:

Exposure: get_gex, get_dex, get_vex, get_levels, get_exposure_summary, get_narrative
Volatility and pricing: get_volatility, get_stock_summary, calculate_greeks, solve_iv
Market data: get_stock_quote, get_tickers, get_option_chain, get_account
Historical replay (Alpha tier): 17 tools that mirror the live ones with an at=<timestamp> argument back to April 2018

Four one-click workflow prompts also surface in the client UI: analyze_exposure(symbol), vrp_regime_check(symbol), historical_comparison(symbol, reference_date) and zero_dte_brief(symbol).

A good first prompt: "Show me the gamma exposure for SPY and tell me where the gamma flip is."

Free tier needs only an email and password, no card: flashalpha.com/pricing. The same key works on both endpoints.

FlashAlpha vs Quant Data: What an AI Agent Can Actually Reason Over

tomasz dobrowolski — Wed, 27 May 2026 13:39:00 +0000

Disclosure up front: I work on FlashAlpha. The factual claims are checkable against quantdata.us/api/docs and lab.flashalpha.com/swagger as of 2026-05-27. The framing is opinion.

Quant Data and FlashAlpha both publish themselves as real-time options analytics platforms with REST APIs and native MCP servers. From a feature-list distance they look like they compete head-to-head. They do not. They were architected for different classes of user and they expose fundamentally different data layers.

This is the comparison the way a senior engineer would explain it to a colleague evaluating both.

The one-sentence framing

Quant Data is a trader workstation with an API attached. FlashAlpha is an API-first quant analytics engine with a UI attached.

That sentence does most of the work. Both platforms read the same underlying market data and both expose a REST surface plus an MCP server, so a checklist will produce overlap. The interesting comparison is not which checkbox each one ticks. It is which class of problem each platform was built to solve, and what that decision implies for everything downstream.

TL;DR

	Quant Data	FlashAlpha
Primary product	Hosted dashboard (web, iOS, Android) with 30+ tools; REST API on top	REST API + MCP server; companion per-ticker pages
Design philosophy	Trader workflow platform	Quantitative analytics infrastructure
Greeks coverage	First-order Greek-weighted exposures (delta, gamma, vega)	First-order plus second-order (VEX, CHEX) with published 8-year backtest
Volatility surfaces	Vol skew, term structure, IV rank	Full SVI calibration, arbitrage-free constraints, sampleable smiles
Flow scoring	Flow analytics endpoints (Net Drift, Net Flow)	Six-component composite with `score_breakdown` in every response
Open/close inference	OI snapshots and changes	Per-contract OI simulator, 0.43 confidence weight, daily calibration
Dealer positioning	Greek-weighted exposure series	Positive vs negative gamma regime, flip-level computation, regime-conditioned VRP
Pricing entry	$124.99/mo annual, non-pro, personal use only	Free 5 req/day; Basic $63/mo annual; commercial use allowed
Best fit	Discretionary traders who want a polished UI + mobile	Quants, devs, fintech apps, AI agents consuming derived state

What each platform actually is

Quant Data

A real-time options market intelligence platform built around a hosted dashboard. Web app plus native iOS and Android with drag-and-drop layouts and 30+ trading tools. A REST API exposes the same feeds programmatically, and an MCP server lets ChatGPT, Claude, Cursor, Gemini, and custom agents call it as a typed tool. The standard plan is gated to non-professionals with "personal use only" and no external redistribution.

What you get: a polished dashboard product, 23 options endpoints, 6 equity endpoints, real-time alerts, and an MCP server. The data is the polished, finished feed; the API mirrors what the dashboard shows.

FlashAlpha

An options quantitative analytics engine that ships as a REST API and an MCP server, with a companion site that surfaces the same analytics visually. The endpoints cover the same raw-flow territory Quant Data does, but the centre of gravity is one layer up: derived market state. Dealer-positioning regimes, second-order exposures, full SVI-calibrated arbitrage-free volatility surfaces, VRP series, an OI simulator that emits effective open interest in near real time, 0DTE analytics keyed on intraday gamma regime, and a six-component scored flow signal with the formula breakdown returned in every response.

What you get: a documented REST API, SDKs in Python, JavaScript/TypeScript, C#, Go, and Java, an MCP server at lab.flashalpha.com/mcp with typed tools for every endpoint, an OpenAPI playground at lab.flashalpha.com/swagger, and methodology articles covering every derived value. No native mobile app, no flagship dashboard. The API is the product.

What Quant Data does genuinely well

This is the section that earns the article credibility. If a vendor-vs-vendor piece only critiques the competitor, the reader correctly discounts it.

Polished trader workflow. Drag-and-drop layouts, iOS and Android apps, real-time alerts, exchange notifications, a clean UI for flow monitoring. Serious product surface.
Dark pool visibility. Dark Flow, Dark Pool Levels, Equity Prints, and exchange notifications are first-class endpoints.
API ergonomics. The "many shapes, one operation" filter design (case-insensitive field names, shorthand and full-name operators, scalar or array values interchangeably) is a developer-experience win.
Solid infrastructure positioning. Published 240 req/min rate limit, 99.99% uptime SLA, 365+ day historical lookback.
Native MCP support. They shipped MCP-as-typed-tools early and deserve credit.
Discretionary-trader fit. The product is honestly built for a human in the loop.

None of this is a hedge. Quant Data is a well-built trader platform. The question is whether it is the right product for a different class of problem, the one FlashAlpha was built to solve.

Flow data vs derived intelligence: the centerpiece distinction

Most options APIs expose what an options market did: trades, chains, sweeps, exposure snapshots, raw activity. This is necessary and useful. It is also one layer below where systematic strategies actually need to operate.

FlashAlpha exposes that same raw flow, but also surfaces a layer above it: what the options market is, in structural terms.

Typical options API surface (activity):

Order flow prints, options chains with first-order Greeks
Sweep and block tags
Exposure by strike and expiration
Max pain, IV rank, vol skew snapshots
Dark pool prints

FlashAlpha's additional layer (structure):

Dealer-positioning regime classification (positive vs negative gamma)
VEX (vanna exposure) and CHEX (charm exposure) series
SVI-calibrated arbitrage-free volatility surfaces
VRP, regime-conditioned and directional
Effective open interest from an intraday OI simulator
Six-component scored flow signals with score_breakdown
Gamma flip levels and exposure concentration zones

Activity tells you what just happened. Structural data tells you what regime the market is in. Both matter; they are not substitutes.

Quantitative differentiators

Second-order exposures: VEX and CHEX

Quant Data's exposure endpoints are Greek-weighted by first-order Greeks (delta, gamma, sometimes vega). Standard treatment, correct for most flow-monitoring use cases.

FlashAlpha additionally surfaces:

VEX (vanna exposure): sensitivity of dealer delta to implied volatility changes. Useful for vol-crush behaviour around earnings, dealer hedging shifts when vol moves, and regime transitions where the second-order term dominates.
CHEX (charm exposure): time-decay impact on dealer delta positioning. Useful for intraday drift, expiry effects (OPEX, quarterly), 0DTE dynamics, overnight roll-over.

FlashAlpha published an 8-year backtest of GEX/DEX/VEX/CHEX as predictors of SPY returns and VIX changes. Most retail-focused platforms do not surface these in a usable form.

Arbitrage-free volatility surfaces (SVI)

Quant Data exposes vol skew, term structure, IV rank, IV percentile. Standard.

FlashAlpha exposes the full underlying surface infrastructure. SVI (Stochastic Volatility Inspired) calibrations per expiration with arbitrage-free constraints (no calendar arbitrage, no butterfly arbitrage), smile parameterisation that can be sampled at any strike or moneyness, term-structure interpolation, and the underlying liquidity-filtered fit data.

This matters for any workflow that consumes IV as a primary input: backtesting, signal generation off skew dynamics, options pricing models, variance trading, ML features built from surface shape rather than snapshot points.

Volatility risk premium (VRP)

VRP is the gap between implied volatility and realised volatility. It is the central premium that systematic options strategies harvest. Quant Data does not surface a published VRP endpoint in their API documentation as of writing.

FlashAlpha publishes VRP as a first-class derived value in several conditioned forms: base VRP across the universe, GEX-conditioned (segmented by dealer-positioning regime), directional (put vs call decomposition), and a VRP-driven strategy scoring endpoint.

OI simulator and effective open interest

The OPRA tape carries the side of every trade but not whether it opens or closes a position. That information lives at the clearing firm and reaches the tape the next morning as a settled OI broadcast.

Quant Data exposes the standard daily OI snapshots and changes. Same data the rest of the industry consumes.

FlashAlpha runs a per-contract OI simulator that maintains a running signed intraday delta against the OPRA broadcast. The simulator's per-trade confidence weight is 0.43, calibrated daily against next-morning settled OI residuals. The output is an effective open interest field that updates intraday, which is what lets FlashAlpha compute live GEX from flow rather than only end-of-day settled GEX.

For systematic strategies that care about intraday regime shifts, this is the difference between operating on yesterday's positioning and today's.

Scoring transparency

FlashAlpha's Flow Signals endpoint returns a six-component composite score with the full score_breakdown in every response. Components: premium (log-normalised), size-vs-OI (ratio), aggressor strength (NBBO-position + side), sweep structure (sweep/block/single), opening bias (OI simulator output, 0.43 weight), tenor (linear decay to 45 DTE). Default weights and formulas are documented. The breakdown reconstructs the composite within rounding.

Quant Data's order flow endpoints surface Net Drift, Net Flow, and Contract Statistics without a documented composite formula. Fine for a finished-signal product; a different choice from audit-trail-by-default.

The MCP / agent angle

Both platforms ship native MCP servers. The interesting question is not whether a platform has an MCP surface but what shape the data is in when an agent consumes it.

LLMs reason well over compact, structured, derived values and poorly over voluminous raw data. Handing an agent a 3,000-row chain JSON and asking it to compute exposures, fit a surface, or derive a regime is a misuse of the tool. There is no clean closed-form path from "here is the chain" to "this market is in a negative-gamma regime with VRP three standard deviations above the GEX-conditioned mean."

An agent can reason cleanly over precomputed derived state:

"What is the current gamma regime for SPX?" → one field, one value, one decision branch.
"Is VRP elevated relative to its GEX-conditioned distribution?" → one signal, segmented by regime.
"List the top-5 scored unusual flow signals on NVDA today, with score_breakdown." → structured, bounded, auditable.

FlashAlpha was designed assuming a non-trivial fraction of consumers would be machines rather than humans. The derived analytics layer is the surface area an AI agent actually wants. The raw chain is available, but it is not the primary product.

Quant Data's MCP server exposes the same data layer as the dashboard: flow feeds, exposure snapshots, dark pool prints. For a workflow that wants an agent to surface what a trader would see, this is well-suited. For a workflow that wants an agent to reason over structural market state, the derived layer matters.

Ideal use cases

Use case	Better fit
Discretionary options flow trading from a dashboard	Quant Data
Mobile options flow monitoring (iOS, Android)	Quant Data
Dark pool prints and exchange notification feeds	Quant Data
Quantitative research on dealer positioning	FlashAlpha
Systematic volatility strategies (VRP harvest, variance, dispersion)	FlashAlpha
Backtesting on second-order exposures (VEX, CHEX)	FlashAlpha
Building ML features from surface shape	FlashAlpha
Live GEX/DEX from flow (intraday regime detection)	FlashAlpha
0DTE intraday gamma regime modelling	FlashAlpha
AI / LLM agents reasoning over derived market state	FlashAlpha
API-first integration into a fintech app	FlashAlpha
Audit-trail scored unusual flow signals	FlashAlpha
Free tier with no credit card for evaluation	FlashAlpha (5 req/day)

If your workflow centres on visual flow monitoring in a polished dashboard, Quant Data is the better fit and there is no shame in it. If it centres on systematic strategies, derived market state, or agent-driven automation, FlashAlpha is the better fit.

Pricing (2026-05-27)

Quant Data's standard plan is explicitly marked "Non-professionals only" and "Personal use only. Not for external redistribution." If you are building a commercial product, a fintech app, or anything that redistributes data downstream, you need their enterprise tier (contact sales).

FlashAlpha's paid tiers allow commercial use directly. Free (5 req/day, no card), Basic $63/mo annual (100 req/day), Growth $239/mo annual (2,500 req/day), Alpha $1,199/mo annual (unlimited, full derived analytics + historical replay).

The right comparison is per-workflow, not per-dollar.

Where the two genuinely overlap

Raw flow ingest, sweep/block tagging
First-order Greek-weighted exposure series
IV rank, percentile, vol skew
Max pain
Native MCP for agents
Well-documented REST surfaces

If your workflow only uses the overlap surface, the two are closer to substitutes than this article suggests, and the choice should come down to pricing, ergonomics, and UI. The thesis here is that workflows that only use the overlap surface are leaving the more interesting half of options analytics on the table.

The one sentence

FlashAlpha is designed to expose quantitative market structure, not just market activity.

If that sentence describes the layer your strategy or product needs, FlashAlpha is the right fit. If it doesn't, Quant Data may genuinely be the better-fit product for what you are doing, and that is a legitimate outcome.

Full article with FAQ, deeper methodology, and links to the published backtests on the canonical version. Free API key (5 req/day, no card) at flashalpha.com/pricing. OpenAPI playground at lab.flashalpha.com/swagger.