DEV Community: tomasz dobrowolski

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.

How to Trade a Long 0DTE Straddle, Read From a Single API Endpoint

tomasz dobrowolski — Sun, 24 May 2026 08:13:35 +0000

A long 0DTE straddle is a bet that today's remaining move will exceed what the market is currently pricing in.

It's a small-edge trade. The default outcome on an unfiltered session is a loss. The structural forces working against the buyer (theta acceleration, pin risk, vol crush, slippage) are large, well-documented, and almost always at least one is dominating any given afternoon.

The article that follows is the structural read I do before considering one. The data comes from a single API endpoint, /v1/exposure/zero-dte/{symbol}, which returns regime, pin score, expected move, IV ratio and execution score in one call. The decision logic stays on your side. The endpoint does not give you a signal; it gives you the data to form one.

What you're paying for

A long straddle is two long options at the same strike and same expiry: one call and one put, both at the at-the-money strike. The naïve breakevens sit symmetrically around the strike:

BE_upper = K + (C + P)
BE_lower = K - (C + P)

Where K is the ATM strike and C + P is the combined call + put mid. FlashAlpha exposes that combined mid directly at expected_move.straddle_price.

Two important framings before the structural read:

The straddle mid is not the strict 1-sigma. Under the lognormal Black-Scholes convention the ATM straddle prices to roughly 0.8 × σ × S × √t, so it sits modestly below the true 1-sigma. The endpoint reports the strict statistical 1-sigma separately at expected_move.implied_1sd_dollars (full session) and expected_move.remaining_1sd_dollars (rest of session). Use the straddle mid for breakeven math and the 1-sigma fields for probability comparisons.

Terminal payoff depends on the close, not the range. A move that touches the upper breakeven at noon and reverts to the strike by 4 PM pays nothing if you hold to expiration. Realised range matters only if you exit at the moment of the move. Both views matter; they are not the same trade.

The real breakeven includes round-trip slippage

The naïve breakeven assumes you fill at mid on both entry and exit. You will not. On 0DTE you pay roughly half the bid-ask spread on each leg on entry, and again on exit, on both the call and the put. That is one full spread round-trip per leg, summed across two legs:

BE_upper_real ≈ K + (C + P) + (S_C + S_P)

The FlashAlpha liquidity.atm_spread_pct field is defined as the average of the call and put spread percentages at the ATM strike. With that definition, round-trip slippage as a percentage of combined premium works out to roughly atm_spread_pct itself:

(S_C + S_P) / (C + P) ≈ atm_spread_pct

A SPY session with a 1% ATM spread costs roughly 1% of premium in round-trip slippage. A less-liquid name with a 3% spread costs roughly 3%. Linear in the spread, not the multiplicative blow-up retail traders sometimes assume. On a small-edge trade, even 1-3% slippage eats a meaningful share of the move you need to recoup.

Four forces against the buyer

On a typical session, the buyer is fighting at least one of:

Theta acceleration. 0DTE gamma is several times larger than equivalent 7DTE gamma at the same strike (the endpoint reports the ratio at decay.gamma_acceleration), and theta scales with gamma. The hourly bleed is captured at decay.theta_per_hour_remaining.
Pin risk. When dealers are net long 0DTE gamma, hedging flow biases price toward the highest-OI strike into close. If the ATM strike is also the magnet, the position decays to near-zero on a session that closes near the strike. Captured at pin_risk.pin_score (the endpoint labels 82 as a "strong pin").
Vol crush. A long straddle is long vega. If implied volatility declines through the session, the position loses on vega even when the underlying moves. The endpoint's vol_context.iv_ratio_0dte_7dte compares 0DTE ATM IV against the next weekly. Ratios above 1.0 carry an event premium that will compress regardless of direction.
Slippage. Covered above. The most underweighted force.

The buyer needs at least one of these to invert, or needs realised vol to outpace all of them combined. The default expectation for an unfiltered 0DTE straddle is a loss.

The negative-gamma timing trap

"Negative gamma" sounds bullish for a long straddle because dealer hedging amplifies moves. The trap is that the regime label is a present-tense observation, not a forward-looking signal. Dealers typically become short gamma after a sharp move has already pushed spot through the flip level. By the time regime.label == "negative_gamma", much of the move you needed may have already happened.

Three sub-cases worth distinguishing:

Already-realised vol. Spot has gapped through the flip overnight or moved sharply pre-noon. The negative-gamma label is now true but the implied move is already partly spent.
Stable negative-gamma session. Spot opened below the flip and is consolidating. The amplification force is present but not yet engaged. The cleanest backdrop.
About-to-cross. regime.label == "positive_gamma" but regime.distance_to_flip_sigmas is well below 1.0. The straddle benefits from the cross during the session.

The endpoint cannot distinguish "already moved" from "about to move" on its own. Compare expected_move.implied_1sd_dollars to the realised move so far. If the day's high-low range already exceeds the implied 1-sigma at the time of read, the easy part of the move is over.

The five structural fields

Five fields capture most of the structural picture and come back in a single response.

Regime and distance to flip:

regime.label                          # "negative_gamma" or "positive_gamma"
regime.distance_to_flip_sigmas        # <1.0 = flip within a normal move
exposures.pct_of_total_gex            # >50% = 0DTE dominates intraday flow

Pin risk and level clustering:

pin_risk.pin_score                    # 0-100; 82 = "strong pin" per API
pin_risk.oi_concentration_top3_pct    # higher = stronger magnet
levels.level_cluster_score            # 0-100; high = levels stacked at one strike

IV ratio (cost, not edge):

vol_context.iv_ratio_0dte_7dte        # <1.0 = cheap vs term; >1.0 = event premium
vol_context.zero_dte_atm_iv
vol_context.skew_25d                  # 25-delta risk reversal in IV points

A common mistake: treating "cheap IV" as a payoff-probability signal. It is not. The IV ratio tells you about the cost of the position, not the likelihood of payoff. A 0.85 ratio means you're paying a relatively low premium; it does not mean the move is more likely to happen. Cheap IV reduces gravity pulling the position toward zero; it does not push it toward profit.

An IV ratio above 1.0 is an event premium. If you cannot name the event, assume the market knows something you don't and skip.

Liquidity and execution:

liquidity.atm_spread_pct
liquidity.weighted_spread_pct         # OI-weighted across the window
liquidity.execution_score             # 0-100 composite; directional read
metadata.snapshot_age_seconds         # <30s for trade decisions

execution_score is reliably high on SPY and SPXW during regular hours. On smaller-cap names with 0DTE listings, a low score combined with a wide ATM spread is a hard veto.

Catalyst alignment

Structural read tells you what dealer positioning looks like. It does not tell you whether the day has a reason to move. The most powerful predictor of realised 0DTE vol is whether the session contains a scheduled catalyst: CPI, PCE, NFP, retail sales, ISM, FOMC, central bank meetings outside the Fed, treasury auctions (especially 30Y).

For single-name 0DTE straddles, post-close vs pre-open earnings matters because the 0DTE expiry usually does not capture the move if the report is after-hours.

A catalyst-empty day with hostile structure is the average session that drains straddle premium.

Sizing

The maximum loss is the combined premium paid. Every US equity, ETF and index option contract carries a 100x multiplier. A SPY straddle quoted at $1.62 is $162 of risk per contract, not $1.62. Sized at 5 contracts: $810 of risk before fees.

Size as if the position goes to zero, because that is the modal outcome on sessions that don't deliver realised vol.

Settlement and exercise risk

The most common way a 0DTE straddle trader ends up surprised on Monday morning.

Cash-settled index options (SPXW, XSP, NDX, RUT): the ITM amount settles to cash. No stock position is created, no overnight risk.

Physically-settled equity and ETF options (SPY, QQQ, IWM, NVDA, TSLA, single names): any leg ITM at expiration is auto-exercised by the OCC under the standard $0.01 threshold. For a long straddle, the call leg buys 100 shares per contract at the strike, or the put leg shorts 100 shares per contract. If the account cannot finance the long-stock buy or borrow for the short, the broker liquidates at Monday's opening print, which is often gapped against the trader.

The rule: close both legs before 4:00 PM ET on physically-settled expiries, even the worthless one. Letting a near-zero leg expire OTM is fine; letting a profitable leg expire ITM creates a stock position you did not size for.

Exit rules tied to live fields

Time-based exits ("exit at noon") work only because the average straddle decays predictably. A more robust ruleset references the same live fields used on entry:

Implied-move compression stop. Compare entry expected_move.remaining_1sd_dollars to current. If remaining implied move has compressed to a fraction of entry, the trade has been outwaited by the clock. Exit.
Regime-flip stop. If regime.label transitions to the opposite regime and spot moves back toward the straddle strike, the structural reason has reversed. Exit.
Pin-score escalation stop. If pin_risk.pin_score climbs into the "strong pin" range while the underlying is near the strike, exit before the magnet finishes its work.
Profit lock. When one leg has gained substantially and the other is approaching worthless, close the winning leg. Letting it ride is a directional bet you did not size for.

Three recurring traps

Morning IV crush. Buying at 9:31 AM, when overnight IV is still elevated and the day's range is unknown. The 0DTE IV typically declines through the first 30-60 minutes. Wait for the ratio to stabilise.

Mid-day pin trap. Buying at 1:30 PM with the pin score already elevated, hoping for an afternoon breakout the gamma profile is actively resisting. The breakout occasionally happens; the more common outcome is a slow drift to the magnet and a near-total premium loss into close.

The "move already happened" entry. Buying after the underlying has already realised a meaningful fraction of the morning's implied 1-sigma. Front-of-day IV has typically crushed (the vol uncertainty that priced the morning straddle is partly resolved), and the session has less time remaining. You're buying the residual of a move someone else captured.

Extract and label

The script below pulls the relevant fields and labels each as buyer-friendly or buyer-hostile based on the API's documented anchors. It does not emit a buy/sell signal, because the right entry depends on calibration, catalysts and your own risk tolerance.

import requests

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

regime        = d["regime"]["label"]
flip_sigmas   = d["regime"]["distance_to_flip_sigmas"]
zdte_share    = d["exposures"]["pct_of_total_gex"]
pin           = d["pin_risk"]["pin_score"]
cluster       = d["levels"]["level_cluster_score"]
iv_ratio      = d["vol_context"]["iv_ratio_0dte_7dte"]
skew          = d["vol_context"]["skew_25d"]
exec_score    = d["liquidity"]["execution_score"]
atm_spread    = d["liquidity"]["atm_spread_pct"]
straddle_mid  = d["expected_move"]["straddle_price"]
implied_1sd   = d["expected_move"]["implied_1sd_dollars"]
remaining_1sd = d["expected_move"]["remaining_1sd_dollars"]

# atm_spread_pct is the avg of call+put spread %.
# Round-trip slippage as % of premium ≈ atm_spread_pct.
est_slippage_pct = atm_spread

# remaining_1sd / implied_1sd ≈ sqrt(t_remain / t_full).
# This is the time-decay scaling of the implied move,
# NOT realised price movement.
implied_time_decay_pct = (1 - remaining_1sd / implied_1sd) * 100

def tag(label, friendly):
    return f"{label}: {'OK' if friendly else 'WARN'}"

print(tag("Regime",
    regime == "negative_gamma"
    or (flip_sigmas is not None and flip_sigmas < 1.0)))
print(tag("0DTE dominates flow", zdte_share > 50))
print(tag("IV not event-priced",
    iv_ratio is not None and iv_ratio < 1.0))
print(tag("Pin not forming",
    pin is not None and pin < 70))
print(tag("Levels scattered",
    cluster is not None and cluster < 70))
print()
print(f"Straddle mid:           ${straddle_mid:.2f}")
print(f"Implied 1sd (full):     ${implied_1sd:.2f}")
print(f"Remaining 1sd:          ${remaining_1sd:.2f}")
print(f"Implied-move time decay:{implied_time_decay_pct:5.0f}%  (time only)")
print(f"ATM spread:             {atm_spread:.2f}%")
print(f"Approx round-trip slip: {est_slippage_pct:.2f}% of premium")
print(f"Execution score:        {exec_score}")
print(f"25d skew:               {skew}")
print()
print("Note: realised range must be checked separately.")
print("Fetch today's OHLC and compare day's high-low to implied_1sd.")

The output is a structured read, not a verdict.

The short answer

A long 0DTE straddle is a small-edge trade fighting four structural forces. The setups where the buyer wins are sessions where the structural read is friendly (negative gamma not yet realised, low pin, IV not event-priced, levels scattered, execution clean) and a catalyst gives the day a reason to move. The endpoint returns the structural picture in one call. It does not give you a signal; it gives you the data to form one. The discipline is in the filter, the catalyst check, and the willingness to skip the trade on the majority of sessions where the structure doesn't align.

Full guide with formulas typeset, the strangle alternative as a cheaper expression, and the curl version on the canonical: Long 0DTE Straddle on FlashAlpha. Free API key, no card, on the pricing page.

Inside an Unusual Options Activity Score: Six Components, One Audit Trail

tomasz dobrowolski — Sat, 23 May 2026 19:24:33 +0000

The unusual-options-flow market is full of black boxes. Vendors publish "scored" feeds without specifying what the score means: which trades qualify, how the score is computed, what threshold separates a meaningful signal from background noise.

For a developer building a screener, this is unworkable. You cannot calibrate against a number whose derivation is hidden, and you cannot ignore false positives whose drivers you cannot see.

This article is the methodology paper for the FlashAlpha Flow Signals API. The score is the deterministic, weighted average of six normalised components. Every component is returned in the response under score_breakdown. The classification of every trade as a sweep or block, an opening or closing flow, a bullish or bearish bet, follows rules documented in code and reproduced here.

What the feed actually is

GET /v1/flow/signals/{symbol} takes the raw block-sized prints from the OPRA tape, groups same-side prints that arrived within 500ms of each other on the same contract into single execution intents, and produces one scored, classified FlowSignal per group.

The output is the input layer for any system that needs to react to unusual activity: a trading dashboard, an alert ruleset, a backtest universe selector, or an LLM that needs structured options-flow context.

The pipeline is split across pure-static components so every step is independently testable on synthetic tapes. No clock, no HTTP, no global state outside the inputs.

1. FlowDataClient.NotableTradesAsync  - windowed pull from notable-trade ring
2. FlowAnalyticsService.LoadAsync     - greek snapshots + OI simulator state
3. UnusualFlowScorer.Score            - pure classification and scoring
4. UnusualFlowEnricher.Enrich         - chain overlay (greeks, IV vs ATM, etc)
5. Controller                         - tier gate, filters, JSON shaping

Sweep coalescing: 500ms, same side, same contract

The single most important pre-processing step is sweep coalescing. A real institutional execution often crosses multiple venues in rapid succession: one bid lifted on PHLX, another at the same instant on CBOE, a third on AMEX, because that is how exchanges route a multi-leg sweep. On the tape, that single intent looks like three prints.

Without coalescing, the score-it-once-per-print approach would either double-count the intent or under-rate it.

group(t_i, t_{i+1}) iff
    side(t_i) == side(t_{i+1})
    AND (t_{i+1} - t_i) <= 500ms

Any group with two or more prints is classified as a sweep; a singleton block-sized print is a block. The size used for scoring is the sum across the group; the price is the size-weighted average; the timestamp is the last print in the group.

The 500ms window is deliberately conservative. Genuine cross-venue sweeps usually finish in under 100ms; the extra headroom catches venues that route via slower paths without false-coalescing prints that are merely temporally adjacent.

The six scoring components

Every coalesced group is scored along six axes. Each component is normalised to [0,1] before weighting, the components are combined as a weighted average, and the result is scaled to a 0-100 integer.

1. Premium (weight 1.0)

The notional dollar value of the trade (price × size × 100), log-normalised against a $10M cap.

n_premium = clamp( log10(1 + P) / log10(1 + P_cap), 0, 1 )

A $1M trade scores about 0.86, a $100K trade about 0.71, a $10M trade saturates at 1.00. The log normalisation is deliberate: linear scaling would push every $100K-$1M print to noise and only spotlight the largest tape.

2. Size vs Open Interest (weight 1.0)

The ratio of trade size to the contract's settled OI, capped at 1.0.

n_size_vs_oi = clamp( size / max(1, settled_oi), 0, 1 )

This is the unusual-activity classic. A 50,000-lot SPY 0DTE print on a strike with 800,000 OI scores 0.0625; the same 50,000-lot on a single-name back-month strike with 30,000 OI saturates at 1.0. That is intended behaviour: relative significance, not absolute size. For absolute-size ranking, sort by premium instead.

3. Aggressor Strength (weight 0.8)

Where the print landed inside the NBBO, side-aware.

n_aggressor =
    0.4                        if side == mid
    0.5                        if spread <= 0 (crossed/locked)
    (price - bid) / spread     if side == buy
    (ask - price) / spread     if side == sell

A buyer who lifts the offer scores near 1.0; a buyer paying the midpoint scores around 0.5. Mid prints get a flat 0.4 because they cannot be classified as aggressive in either direction with confidence.

4. Sweep Structure (weight 1.0)

n_sweep =
    1.00   coalesced group, >= 2 prints (sweep)
    0.55   singleton block-sized print (block)
    0.20   single print below block size (rare)

Sweeps signal urgency. A standalone block is meaningful but compatible with patient, single-venue execution.

5. Opening Bias (weight 1.2, but capped at 0.43)

Whether the trade opens new positions or closes existing ones, from the OI simulator's signed intraday delta.

n_opening = bias_score * oi_confidence

bias_score =
    1.0   net OI delta > 0  (OpeningBias)
    0.3   net OI delta < 0  (ClosingBias)
    0.5   net OI delta == 0 (Unknown)

oi_confidence = 0.43   # calibrated against next-morning settled OI

This is the most important design choice in the entire scorer.

Even a "perfect" opening signal contributes at most 0.43 to the normalised component, not 1.0. With the default weight of 1.2 out of total 5.6, the opening-bias bucket can contribute at most 100 * 1.2 * 0.43 / 5.6 ≈ 9.2 points to the composite score.

That ceiling is intentional: the simulator's calibrated confidence is 0.43, and a scoring model that gave full credit to opening signals would be overstating what the underlying inference can actually prove. Honest in, honest out.

6. Tenor (weight 0.6)

Days to expiration, normalised so short-dated trades score higher.

n_tenor = clamp( 1 - dte/T_cap, 0, 1 )   # T_cap = 45 default

A 0DTE print scores 1.0, a 22-DTE print scores 0.51, a 45+-DTE print scores 0. LEAPS get zero credit for tenor. Shorter-dated flow has more time-discounted information value.

The composite

contribution_i = round( 100 * w_i * n_i / sum(w_j) )
score = clamp( sum(contributions), 0, 100 )

Default weights (sum 5.6): premium=1.0, size_vs_oi=1.0, aggressor=0.8, sweep=1.0, opening_bias=1.2, tenor=0.6.

The breakdown lives in the response:

{
  "score": 78,
  "score_breakdown": {
    "premium":      22,
    "size_vs_oi":   10,
    "aggressor":    13,
    "sweep":        18,
    "opening_bias":  6,
    "tenor":         9
  }
}

Add the buckets and you get the score, within rounding. Any score in the feed can be reconstructed from the trade + OI context using the formulas above. There are no hidden adjustments.

Intent classification

Once scored, the scorer assigns a directional intent.

intent =
    Neutral   if bias == ClosingBias        # unwind, direction unknown
    Neutral   if side == Mid
    Bullish   if BuyCall  or SellPut
    Bearish   if SellCall or BuyPut

The closing-bias-collapses-to-Neutral rule is load-bearing. A closing trade tells you what is being unwound, but the direction the unwinder originally bet is generally unknown to the tape. Calling a closing trade "Bullish" or "Bearish" would over-claim.

The consumer can still read open_close_bias directly if they want to count closing flow separately.

Conviction labels and the "golden" tag

Score	Conviction
80-100	high
60-79	medium
40-59	low
0-39	minimal

A signal is tagged golden if its score is in the top decile of the current result set and meets the absolute floor of 70. The dual gate stops a quiet session from promoting a mediocre signal.

Greeks enrichment overlay

After scoring, the enricher joins the signal with the settled greek snapshot:

iv, delta, gamma from the snapshot (null if just-listed)
iv_vs_atm: the contract's IV minus the ATM IV on its expiry
moneyness: ITM if |δ| >= 0.65, OTM if <= 0.35, else ATM
estimated_delta_notional = size * 100 * δ * S
hypothetical_gex_impact_if_opening = size * 100 * Γ * S² * 0.01

The hypothetical GEX field is named for a reason. The live chain on the flow surface already folds intraday OI deltas in, so adding the per-signal impact on top would double-count. Use it to size individual trades, not to recompute chain GEX.

Quick example: top bullish sweeps on SPY

import requests

resp = requests.get(
    "https://lab.flashalpha.com/v1/flow/signals/SPY",
    headers={"X-Api-Key": "YOUR_KEY"},
    params={
        "windowMinutes": 240,
        "intent": "bullish",
        "structure": "sweep",
        "minScore": 70,
        "limit": 10,
    },
)
data = resp.json()

for s in data["signals"]:
    print(
        f"{s['ts']}  {s['expiry']} {s['strike']}{s['right']}"
        f"  size={s['size']:>5}  ${s['premium']:>10,.0f}"
        f"  score={s['score']}  ({s['conviction']})"
        f"  {','.join(s['tags'])}"
    )

What it isn't

Three honest scope limits:

Not a full tape replay. The notable ring is capped at 512 prints; this is a windowed scan, not exhaustive history.

Not single-print precision intent. Multi-leg structures (verticals, butterflies, calendars) aren't detected at this layer. A bear-call-spread leg that buys the lower call still reads as a bullish single leg here.

Not a replacement for per-strike GEX. The chain-level live GEX number lives at /v1/flow/gex, computed against effective OI. Use both: signals for intent and significance, the GEX endpoint for chain-level dealer exposure.

Why the score breakdown matters

Every unusual-activity vendor publishes a score. Almost none of them tell you what is inside it. The buyer is forced to trust the number, the implicit weighting, and the (undisclosed) calibration choices the vendor made years ago and may or may not have revisited.

The default weights (1.0 / 1.0 / 0.8 / 1.0 / 1.2 / 0.6) were set by eye after looking at a representative range of SPY, NVDA, and TSLA sessions. There is no claim that these weights are statistically optimal. They are documented defaults you can override per-request. The audit trail in score_breakdown exists partly so customers can build their own re-weighting on top of the normalised components.

The score is the product. The methodology is the warranty.

Full methodology paper with all formulas typeset, FAQ, and worked examples: Flow Signals API on FlashAlpha. Free API key, no card required, on the pricing page.

Build a Working Unusual Options Activity Scanner in Python (Under 150 Lines)

tomasz dobrowolski — Sat, 23 May 2026 19:24:09 +0000

If you want to build an unusual options activity scanner, you have two choices.

You can buy a packaged alert product from a vendor that picks the strategy for you and charges per ticker. Or you can call a transparent flow API yourself and write the scanner you actually want.

This article walks through the second route end to end: every line of Python, every parameter, every alert format. By the end you'll have a single-file scanner you can run locally, schedule with cron, or wire into Slack.

The underlying feed used here is the FlashAlpha Flow Signals API, which scores every block-sized print on a 0-100 scale with six documented components (premium, size-vs-OI, aggressor, sweep, opening bias, tenor). The full methodology is a separate article; the short version is that every score in the response carries a score_breakdown object you can audit. We'll filter, rank, render, and alert on top of that.

Prerequisites

pip install requests
export FLASHALPHA_API_KEY=your_key_here

You need Python 3.9+ and an Alpha-tier API key. The signals endpoints are gated to Alpha. requests is the only dependency for the scanner itself; if you want fancier terminal output, rich is a drop-in addition but the article doesn't use it.

Step 1: The signals call

One function, one HTTP call, one parsed JSON response.

import os
import requests

API_BASE = "https://lab.flashalpha.com"
API_KEY = os.environ["FLASHALPHA_API_KEY"]

def fetch_signals(
    symbol: str,
    window_minutes: int = 240,
    min_score: int = 0,
    intent: str | None = None,
    structure: str | None = None,
    limit: int = 50,
    expiry: str | None = None,
):
    """One call to /v1/flow/signals/{symbol}."""
    params = {
        "windowMinutes": window_minutes,
        "minScore": min_score,
        "limit": limit,
    }
    if intent: params["intent"] = intent
    if structure: params["structure"] = structure
    if expiry: params["expiry"] = expiry

    resp = requests.get(
        f"{API_BASE}/v1/flow/signals/{symbol}",
        headers={"X-Api-Key": API_KEY},
        params=params,
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

The response is a top-level metadata wrapper plus a signals array. Each signal carries the trade fields, classification, score, breakdown, and the chain context.

Step 2: A pretty terminal renderer

The point of a transparent feed is that you can read the per-component score, not just the composite. Render the breakdown alongside the signal.

from datetime import datetime

def render_signal(s: dict) -> str:
    ts = datetime.fromisoformat(s["ts"].replace("Z", "+00:00"))
    bd = s["score_breakdown"]
    bd_str = " ".join(f"{k[:3]}={v:>2}" for k, v in bd.items())
    tags = ",".join(s["tags"]) if s["tags"] else "-"
    return (
        f"{ts:%H:%M:%S}  "
        f"{s['expiry']} {s['strike']:>6}{s['right']}  "
        f"{s['side']:>4}  "
        f"size={s['size']:>5}  "
        f"${s['premium']:>10,.0f}  "
        f"score={s['score']:>3} ({s['conviction']:>7})  "
        f"{s['intent']:>7}/{s['open_close_bias']:>13}  "
        f"[{bd_str}]  "
        f"tags={tags}"
    )

def scan_and_print(symbol: str, **kwargs):
    data = fetch_signals(symbol, **kwargs)
    print(f"\n=== {symbol} - {data['count']} signals ===")
    print(
        f"chain: call_wall={data['chain']['call_wall']} "
        f"put_wall={data['chain']['put_wall']} "
        f"flip={data['chain']['gamma_flip']}"
    )
    for s in data["signals"]:
        print(render_signal(s))

if __name__ == "__main__":
    scan_and_print("SPY", min_score=70, structure="sweep", window_minutes=60)

One line per qualifying signal with every score component, the intent, the open/close bias, the chain context, and the tags. No interpretation layer, no opaque rank.

Step 3: A watchlist scanner

The summary endpoint returns a directional roll-up in one call per ticker. Concurrent fetches let you sweep a watchlist in under a second.

from concurrent.futures import ThreadPoolExecutor

WATCHLIST = ["SPY", "QQQ", "IWM", "NVDA", "TSLA", "AAPL", "META", "AMZN"]

def fetch_summary(symbol: str, window_minutes: int = 60):
    resp = requests.get(
        f"{API_BASE}/v1/flow/signals/{symbol}/summary",
        headers={"X-Api-Key": API_KEY},
        params={"windowMinutes": window_minutes},
        timeout=10,
    )
    resp.raise_for_status()
    return symbol, resp.json()

def watchlist_card(watchlist=WATCHLIST, window_minutes: int = 60):
    print(f"\n=== Watchlist Direction Card (window={window_minutes}m) ===")
    print(f"{'SYM':6} {'DIR':8} {'NET PREMIUM':>16} "
          f"{'OPEN':>14} {'CLOSE':>14} {'SIGNALS':>8}")

    with ThreadPoolExecutor(max_workers=8) as pool:
        for sym, d in pool.map(
            lambda s: fetch_summary(s, window_minutes), watchlist
        ):
            net = d["net_directional_premium"]
            direction = "BULLISH" if net > 0 else "BEARISH" if net < 0 else "NEUTRAL"
            print(
                f"{sym:6} {direction:8} "
                f"${net:>14,.0f}  "
                f"${d['opening_premium']:>12,.0f}  "
                f"${d['closing_premium']:>12,.0f}  "
                f"{d['signal_count']:>8}"
            )

Sample output on a busy session:

=== Watchlist Direction Card (window=60m) ===
SYM    DIR           NET PREMIUM           OPEN          CLOSE  SIGNALS
SPY    BULLISH    $   4,820,000   $  6,420,000   $  1,600,000        42
QQQ    BULLISH    $   1,140,000   $  2,810,000   $  1,670,000        28
NVDA   BEARISH    $  -2,250,000   $    410,000   $  2,660,000        17
TSLA   BULLISH    $   3,100,000   $  3,420,000   $    320,000        12
AAPL   NEUTRAL    $     -45,000   $     80,000   $    125,000         3
AMZN   NEUTRAL    $          0    $          0   $          0         0

SPY is bullish with mostly fresh positioning (open > close). NVDA looks bearish at the net but closing premium dominates opening, so it's mostly position unwinding, not fresh bearish conviction. The opening/closing split is doing real work here. Most UOA feeds publish only the net.

Step 4: Custom filters - whale sweeps only

Compose the filter parameters for the specific pattern you care about. Whale (premium ≥ $1M) sweeps with high conviction:

def whale_sweeps(symbol: str, window_minutes: int = 60):
    data = fetch_signals(
        symbol,
        window_minutes=window_minutes,
        structure="sweep",
        min_score=70,
        limit=50,
    )
    return [s for s in data["signals"] if "whale" in s["tags"]]

for sym in WATCHLIST:
    for s in whale_sweeps(sym):
        print(f"{sym}  {render_signal(s)}")

The whale tag fires automatically at $1,000,000+ premium.

Step 5: Golden signals only

The golden tag is a dual gate: top decile of the current result set and at or above 70 score. A quiet session doesn't promote weak signals.

def golden_signals(symbol: str, window_minutes: int = 240):
    data = fetch_signals(symbol, window_minutes=window_minutes)
    return [s for s in data["signals"] if "golden" in s["tags"]]

Step 6: Opening-only bullish scan

Most directional bets worth surfacing are opening flows, not closing flows.

def opening_bullish(symbol: str, window_minutes: int = 240, min_score: int = 60):
    data = fetch_signals(
        symbol,
        window_minutes=window_minutes,
        intent="bullish",
        min_score=min_score,
    )
    return [
        s for s in data["signals"]
        if s["open_close_bias"] == "opening_bias"
    ]

intent=bullish already drops every closing trade (closing flows collapse to Neutral). The client-side check is the explicit double-gate.

Step 7: Slack alerts

Wire any filter into a Slack incoming webhook. Send the score breakdown in the alert body so the human reading it can see why it fired without leaving Slack.

SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL")

def slack_block(symbol: str, s: dict) -> dict:
    bd = s["score_breakdown"]
    color = (
        "#22c55e" if s["intent"] == "bullish"
        else "#ef4444" if s["intent"] == "bearish"
        else "#a1a1aa"
    )
    return {
        "attachments": [{
            "color": color,
            "title": (
                f"{symbol}  {s['expiry']} {s['strike']}{s['right']}  "
                f"{s['side'].upper()}  score={s['score']} ({s['conviction']})"
            ),
            "text": (
                f"size: {s['size']:,}  "
                f"premium: ${s['premium']:,.0f}  "
                f"intent: {s['intent']}\n"
                f"bias: {s['open_close_bias']}  "
                f"structure: {s['structure']}  "
                f"tags: {', '.join(s['tags']) or '-'}\n"
                f"breakdown: prem={bd['premium']} sz={bd['size_vs_oi']} "
                f"aggr={bd['aggressor']} swp={bd['sweep']} "
                f"open={bd['opening_bias']} ten={bd['tenor']}"
            ),
        }]
    }

def slack_post(symbol: str, s: dict):
    if not SLACK_WEBHOOK_URL: return
    requests.post(SLACK_WEBHOOK_URL, json=slack_block(symbol, s), timeout=5)

Step 8: De-duplication on a schedule

Polling every minute, the same signal appears in consecutive responses until it ages out of the window. Hash the natural key and remember.

import hashlib

_alerted: set[str] = set()

def signal_key(symbol: str, s: dict) -> str:
    raw = f"{symbol}|{s['ts']}|{s['expiry']}|{s['strike']}|{s['right']}|{s['size']}"
    return hashlib.sha1(raw.encode()).hexdigest()[:16]

def alert_once(symbol: str, s: dict):
    k = signal_key(symbol, s)
    if k in _alerted: return
    _alerted.add(k)
    slack_post(symbol, s)

Coalesced sweeps come through with their group's last-print timestamp and combined size, so the key is stable for the duration of the window. For long-running daemons, periodically prune entries older than the window.

Step 9: The single-file daemon

import time
from datetime import datetime, timezone

def loop_forever(
    watchlist=WATCHLIST,
    poll_seconds: int = 60,
    window_minutes: int = 30,
    min_score: int = 70,
):
    print(f"UOA daemon starting on {watchlist}, polling every {poll_seconds}s")
    while True:
        try:
            for sym in watchlist:
                for s in opening_bullish(sym, window_minutes, min_score):
                    if "golden" in s["tags"]:
                        alert_once(sym, s)
        except requests.HTTPError as e:
            now = datetime.now(timezone.utc).isoformat(timespec="seconds")
            print(f"{now}  HTTP {e.response.status_code} - retrying next tick")
        except Exception as e:
            now = datetime.now(timezone.utc).isoformat(timespec="seconds")
            print(f"{now}  {type(e).__name__}: {e} - retrying next tick")
        time.sleep(poll_seconds)

if __name__ == "__main__":
    loop_forever()

That's it. Under 150 lines, one dependency, alerts to Slack with full breakdown, deterministic de-dup, swappable filters.

What you avoid by building it yourself

Packaged UOA product:

Black-box score with no per-component breakdown
Alert thresholds the vendor picks, not you
Per-ticker pricing that gets expensive fast
Cannot inspect why an alert fired (or did not)
Wire format is whatever the vendor provides

API + 150 lines of Python:

Every component of every score in the response
You pick filters, thresholds, watchlist
One key, unlimited symbols, no per-ticker fees
Every alert carries its audit trail
Slack, Discord, Telegram, terminal, whatever you want

Five natural extensions

0DTE-only filter. Pass expiry=<today's ET date>. Combine with structure=sweep for intraday momentum.
Cross-reference with chain context. Compare each signal's strike against chain.call_wall, chain.put_wall, chain.gamma_flip. A sweep through a wall is structurally different from one in no-man's-land.
Score-weighted leaderboard. Aggregate by ticker, sum premium weighted by score. Daily top-5 at 4:05 PM ET.
Cross with live GEX direction. Alert only when intent agrees with the live GEX regime shift.
Persist to a database. Drop alerts into Postgres or DuckDB keyed by signal_key. Build your own residual analysis: how often did "golden bullish opening sweep" precede a meaningful move? The breakdown makes per-component backtests trivial.

Full tutorial with worked examples and FAQ on the canonical: Build an Unusual Options Activity Scanner with Python. The methodology pillar that explains every field in the response: Flow Signals API methodology.

VRP Short Put Spreads: An Honest 7-Year Backtest Across 5 Symbols

tomasz dobrowolski — Thu, 21 May 2026 10:19:18 +0000

Framing correction (read first). The thesis of this article ("the edge does not survive honest execution") is overstated. A controlled follow-up, VRP Backtest: The Fill Model Is the Edge, shows the result is bounded by the fill-model assumption: honest fills give breakeven to negative (these numbers); idealized mid-fills (the universal public-backtest default) give strongly positive. The correct conclusion is execution-fragility and a result-range straddling zero, not "VRP is dead." Read this piece as the pessimistic bound of that range.

Search "volatility risk premium strategy" and you will find a hundred posts with an equity curve going up and to the right and a win rate north of 80%. They are almost all built on three quiet lies: mid-price fills, clean profit-target exits, and parameters chosen on the same symbol they are advertised on. This study removes all three.

We took a single short-put-spread VRP harvest, tuned it once on SPY in prior work, froze every parameter, and ran it unchanged across QQQ, IWM, AMZN, and NVDA from 2019 to 2026. SPXW was added as a flagship out-of-sample check via a completely separate daily-resolution data path. Execution was modeled the way a real account experiences it: post-and-wait limit orders, exits that have to cross the spread, a stale-quote guard, and a signal that can only see the past.

TL;DR

Symbol	Trades	Win rate	Profit factor	Sharpe	CAGR %	MaxDD %	Fill rate
SPY (tuned)	335	71.6%	1.10	0.23	1.05	6.48	13.7%
NVDA	201	72.1%	1.12	0.22	0.84	6.87	6.5%
AMZN	139	71.2%	1.08	0.13	0.42	7.38	3.4%
QQQ	162	69.8%	0.96	−0.08	−0.23	7.76	7.9%
IWM	58	63.8%	0.72	−0.35	−0.11	1.24	3.1%
SPXW †	112	61.6%	0.37	−0.39	−0.66	5.81	100% †

Period: 2019-02-01 to 2026-04-02 (7.16 years). $100k notional, unlevered Half-Kelly.
† SPXW is sourced at daily-close resolution from the Historical API; fill rate is 100% by construction. Direction check only.

Win rate clusters at 64-72% across every symbol. The VRP probability edge is real and travels. Sharpe ranges from +0.23 to −0.39. Two of four out-of-sample symbols lost money. SPXW lost money. The premium is real; the tradeable edge is not.

The strategy (frozen specification)

A short put credit spread on the underlying, gated by a market-regime VRP signal. Every number below was fixed before the cross-sectional run and never changed per symbol.

Structure: short put vertical spread (defined risk)
Short leg target: 0.10 delta (far-wing premium)
DTE target: 14 days (±2)
PT / SL: 50% / 100% of credit
Spread widths: 5 / 10 / 15 / 20 / 25 / 30 points (EV-ranked at entry from observable greeks only)
Sizing: Half-Kelly, default 0.05, cap 0.25 (unlevered)
Entry time: 10:05 ET
Regime gate: one SPY/VIX market-regime signal applied to all five symbols (this is what makes the four extra symbols a genuine OOS test rather than four fitted strategies)
Circuit breaker: 30% peak-to-trough

The regime signal is built from VIX, VIX9D, VVIX, the VIX term structure, a realized-vs-implied VRP proxy and its 252-day percentile, HY spreads, and stress z-scores. It outputs risk_on / neutral / reduce / risk_off with a continuous Kelly multiplier. risk_off means no trade. Construction is leak-free; methodology in Historical VRP Percentiles Without Lookahead Bias.

The honesty controls

Each control below removes a specific way backtests lie. This is the entire point.

1. Leak-free signal. The signal CSV is shifted forward one calendar day with a 7-day walk-back lookup. Any trading day's decision uses only data fully observable before that day's open.

2. Honest fills (post-and-wait limits). We do not fill at mid. We post a limit at ask_edge and wait for someone else to cross our price. If nobody does, the order is cancelled. That is why fill rates are 3-14% and not 100%.

3. Stale-quote guard. When a cross is detected, we re-check that the mid has not moved through our limit by more than a floor. A one-tick bid blip during a vol spike does not get to manufacture a phantom fill.

4. Patient-then-cross exits. Profit-target and stop-loss exits are not free. We post a buy-to-close limit at the trigger and wait. If it does not fill, we cross the spread and pay the offer. Those exits are tagged pt_x / sl_x so the execution tax is auditable.

5. EV-blind tiebreak. When multiple candidate spreads cross on the same bar, the winner is chosen by a timestamp-seeded random shuffle, never by best EV. Any EV-aware tiebreak is a look-ahead oracle.

6. Frozen, never re-fit. Tuned once on SPY in prior work. Then frozen. QQQ, IWM, AMZN, NVDA, SPXW received zero per-symbol optimization.

Why a 70% win rate nets to nothing

Symbol	Avg win	Avg loss	Win:loss
SPY	$369	−$850	1 : 2.3
QQQ	$311	−$751	1 : 2.4
AMZN	$407	−$933	1 : 2.3
NVDA	$385	−$888	1 : 2.3
IWM	$53	−$130	1 : 2.4

A 70% win rate at a 1:2.3 payoff has expected value 0.70 × 1 − 0.30 × 2.3 ≈ 0. By arithmetic, it is a coin flip. This is the defining feature of short-vol: you win small, often, and lose big, occasionally. The win rate is the wrong number to anchor on.

Only 3-14% of orders filled, and the fills were adversely selected

Symbol	Proposed	Filled	Fill rate	Avg edge captured
SPY	2,438	335	13.7%	−$0.037
QQQ	2,055	162	7.9%	−$0.042
NVDA	3,072	201	6.5%	−$0.044
AMZN	4,114	139	3.4%	−$0.040
IWM	1,896	58	3.1%	−$0.039

A mid-fill backtest books all of the proposed trades at a better price. Reality books a single-digit-to-low-teens percentage of them and the ones that do fill cross at ~$0.04 worse than mid. The orders that fill are disproportionately the ones the market is running through (adverse selection). On 100-multiplier contracts that is a structural ~$4 headwind per fill before the trade begins.

The "profit target" is mostly a forced spread cross

pt = clean limit fill at target. pt_x = target hit but had to cross the spread.

Symbol	pt (clean)	pt_x (crossed)	sl	sl_x	expiry
SPY	103	133	63	32	4
QQQ	29	76	37	12	8
AMZN	44	47	25	14	9
NVDA	68	71	43	13	6
IWM	12	21	7	13	5

On every symbol, more profit-target exits required crossing the spread than filled cleanly at the limit. The idealized "close at 50% target" that naive backtests book is, in practice, the minority outcome. This single effect is a primary driver of the gap between the win rate and the Sharpe.

The high-conviction regime did not earn its name

The signal's risk_on ("deploy full size") regime underperformed neutral on four of five 1-minute symbols:

Symbol	`neutral` P&L (win%)	`risk_on` P&L (win%)
SPY	+$5,604 (73%)	+$2,174 (70%)
QQQ	−$3,000 (69%)	+$1,364 (71%)
NVDA	+$5,918 (75%)	+$266 (69%)
AMZN	+$4,669 (70%)	−$1,644 (73%)
IWM	+$145 (72%)	−$910 (60%)

A signal that sizes up into its highest-conviction state and earns less there is a signal whose conviction is, at best, uncorrelated with forward edge. The same pattern reappears on SPXW from a completely separate data feed (95 risk_on trades, −$5,266; 17 neutral trades, +$625). This is the precise mechanism by which leveraged-VRP posts blow up.

SPXW: the flagship out-of-sample check

SPXW is the canonical home of the VRP trade. The strategy was never tuned on it, and it had to be sourced from a different data path entirely (Historical API, daily-close resolution).

Metric	SPXW (daily, OOS)
Trades	112 over 7.16 yr
Win rate	61.6%
Profit factor	0.37
Sharpe	−0.39
Avg win / avg loss	$39 / −$170 (1 : 4.4)
`risk_on` regime	95 trades, −$5,266, 60% win
`neutral` regime	17 trades, +$625, 71% win

It lost money too. The win/loss asymmetry is even worse (1:4.4) because narrow 5-point SPX spreads collect tiny credits against a wide max loss.

Caveat: SPXW transacts at daily-close mid minus the −$0.04 haircut empirically measured on the five 1-minute symbols. Fill rate is 100% by construction and exits are all forced crosses, so its fill rate and Sharpe magnitude are not apples-to-apples with the 1-minute rows. It is cited as a directional confirmation, not a sixth execution-comparable Sharpe.

What this means

VRP is real; the free lunch is not. The premium shows up reliably as a high win rate. It does not reliably show up as money once you (a) pay realistic execution and (b) refuse to re-fit per symbol.
The win rate is the most misleading number in options content. A 70% win rate with a 1:2.3 payoff is structurally breakeven. Any post leading with win rate and not showing the loss distribution is selling you the setup, not the result.
Execution is the strategy. The single biggest gap between the hyped version and this one is fills, not signal. Mid-fill assumptions, clean-target exits, and 100% fill rates are where the fictional returns live.
Out-of-sample is brutal and necessary. SPY (tuned) was the best result. Every symbol the strategy had never seen did worse. Honest deployment is the non-tuned result.
Do not lever the confidence. The risk_on regime, the one a leveraged variant would size into hardest, was the weaker regime.

Reproduction

bash run_cross_symbol.sh                              # 5 symbols, 1-min local chains
python spxw_api_backtest.py --start 2019-02-01 \
       --end 2026-04-02 --label vrpfrozen             # SPXW, daily-close via API
python aggregate_cross_symbol.py                      # cross_symbol_summary.{csv,json}

Per-symbol engine invocation (identical except --symbol):

python intraday_bt_ev_rank.py --symbol <SYM> \
  --start 2019-02-01 --end 2026-04-02 \
  --delta 0.10 --dte 14 --pt 0.50 --sl 1.0 \
  --vrp-signal vrp_signal_v2.csv \
  --kelly-default 0.05 --kelly-mult 0.5 --vrp-on-mult 1.0 \
  --kelly-max 0.25 --max-drawdown 0.30

The SPXW row consumed the same Historical API surface a paying user would call. Full study, full appendix table, year-by-year breakdowns, and the limitations section live in the original article. The companion fill-model sensitivity study is VRP Backtest: The Fill Model Is the Edge.

Effective Open Interest: How to Estimate Live OI From OPRA Flow

tomasz dobrowolski — Thu, 21 May 2026 09:39:32 +0000

If you have ever wondered why one vendor's "live GEX" differs from another's even though both read the same OPRA feed, the answer is almost always how they handle open interest.

OPRA broadcasts settled OI once per session, usually before the open. Everything past 09:30 ET is built on top of an OI estimate derived from trade flow. The estimate is rarely disclosed. Most vendors mix settled OI with their own intraday adjustments and call the result "live data" without describing how the adjustment is made.

The choice of estimator changes the GEX number. It changes the call wall. It sometimes changes the gamma flip. For anyone wiring this into a model, the methodology is the product.

This post walks through how we do it at FlashAlpha: the six OI values we expose, the flow simulator, the 0.43 confidence weight and how it was calibrated, and how the whole thing feeds live exposure.

The problem with official OI

Open interest is the count of outstanding contracts at a strike and expiration. It moves when positions are opened or closed. Aggregate exposure (GEX, DEX, VEX, charm) is linear in OI: wrong OI, wrong exposure.

Official OI comes from the OCC's nightly clearing run and is broadcast by OPRA once per ET trading day, typically before the open. It is the only OI that has cleared. It is also stale through every minute of the trading day after the morning broadcast.

For a sleepy index in a quiet week, that approximation is fine. For SPY on a Fed afternoon, QQQ on an NVDA-news day, or any single name on earnings, official OI is hours behind the actual book.

0DTE is the extreme case: the entire OI lifecycle from creation to expiration happens inside one trading day. By the time tomorrow's settled OI arrives, those contracts have already cleared. If you want any GEX signal from 0DTE flow, you have to estimate OI from the tape in real time.

The six OI values we expose

Every Exposure API response includes six named OI fields per chain. Mixing them up produces silently wrong analytics, so each one has a precise meaning.

Field	What it is
`official_oi`	Last settled OI from OPRA (StatType=9). Conservative, accurate, stale.
`intraday_oi_delta`	Signed running estimate of position changes since the morning broadcast. Resets on a new ET trading day.
`intraday_oi_delta_x10`	Same delta in fixed-point form (one decimal preserved) for integer-only pipelines.
`simulated_oi`	`official_oi + intraday_oi_delta`, unclamped. May go negative on contracts where sell flow exceeds the morning baseline. Diagnostic only.
`effective_oi`	`max(0, simulated_oi)` per contract. The non-negative, intraday-updated OI surface that feeds live GEX/DEX/VEX/CHEX.
`oi_day`	The ET trading day this state belongs to. Critical for reconnect-replays and weekend boundaries.

If you want the textbook official number, read official_oi. If you want to see how aggressive intraday flow has been, watch intraday_oi_delta. If you want the number that actually drives live GEX, read effective_oi.

The side-classified flow simulator

The intraday delta comes from a per-trade accumulator running continuously against OPRA. Each trade is side-classified (buy / sell / midpoint), weighted, and added to the running delta:

ΔOI_t = size_t × Confidence × sign(side_t)

Where sign(buy) = +1, sign(sell) = -1, sign(mid) = 0. Midpoint trades contribute zero because they cannot be reliably classified as opening or closing flow. That removes some signal but eliminates a large bias source in tight-spread names where midpoint prints are common.

The aggregator runs at OPRA-trade resolution: a single contract's OI estimate updates the instant a print hits. Chain-level effective_oi is the per-strike sum.

Side classification is the upstream weakness. Tick-rule and quote-rule heuristics get most trades right, but rapid quote updates around news events can flip classification on individual prints. We monitor the aggregate impact in the residual reconcile rather than trying to make every classification perfect.

The 0.43 confidence weight

The confidence weight is the one knob that has to come from data, not theory. There is no first-principles derivation of "43% of volume opens new positions": the right value depends on participant mix, side-classification accuracy, time of day, and ticker. The only honest calibration is empirical.

The reconcile loop runs daily.

16:30 ET snapshot. After the MOC auction settles, the calibration service walks every contract with non-zero intraday delta and writes a prediction row: today's morning settled OI, the accumulated intraday delta, the predicted end-of-day OI, and the confidence weight in use.

09:35 ET reconcile. The next morning, after the new day's settled-OI broadcast, the service looks up the actual settled value for each contract and writes a residual row: actual - predicted. Predictions are matched to the previous trading day: Monday's reconcile compares against Friday's predictions, not Sunday's.

Aggregating residuals over a week or two tells you three things no single trade can: whether the weight is right on average, whether the bias is symmetric or tilted, and whether the error varies by ticker, side, or trade size.

The current 0.43 came out of a calibration run in May 2026. The original setting was 0.40, calibrated when the pipeline first shipped. Residual analysis showed that 0.40 systematically under-predicted EOD OI by 4 to 10 percent on liquid names, with the bias largest on names with heavy retail flow. Raising the weight to 0.43 brought the median residual close to zero across the liquidity distribution.

The tuning itself is not automated. The service writes residuals; humans look at the data and decide whether the heuristic needs adjusting. Automating the loop would risk over-fitting to a particular liquidity regime. Treating it as a quarterly engineering review preserves the option to ignore the data when something else is going on in the market.

Feeding live GEX

The aggregate GEX calculation does not care about the OI source. It multiplies gamma by OI by 100 by spot squared, summed across the chain:

GEX_live = Σ Γ_i × effective_oi_i × 100 × S²

Swap the OI input and the GEX number changes mechanically. Using official_oi gives a morning-stale GEX. Using simulated_oi would feed a negative-OI artifact into the sum on contracts where the heuristic overshot. The per-contract max(0, simulated) clamp is the small, important step that makes chain-level GEX sensible even when individual contract estimates are noisy.

Same effective OI feeds DEX, VEX, charm exposure, and every per-strike profile. They are all linear in OI, so they all inherit the calibration of the underlying flow simulator.

A useful diagnostic

Aggregate intraday_oi_delta is the simulator's direct signed sum, never reconstructed from (effective - official). Reconstructing from clamped values loses magnitude on contracts where the clamp fired. The accumulator is the source of truth for net intraday flow.

A large gap between unclamped simulated_oi and clamped effective_oi on a chain means per-contract clamps fired somewhere and the heuristic is straining. That is your "trust the live GEX less right now" signal.

When the heuristic breaks

The simulator is a heuristic, not a position-tracking ledger. Three patterns produce predictable bias.

Dealer-internalised crosses. Large institutional trades that print through dealer-internal crossing networks show up on the tape but do not create new OI. The 0.43 weight accounts for some fraction of this through calibration, but bursts of internalised flow can locally inflate the estimate.

Roll activity. Around OPEX, large multi-leg rolls produce flurries of trades that side-classifiers read as one-directional. The simulator counts them as new positions when they are, in aggregate, position-neutral.

Midpoint density. In tight-spread names, a large fraction of prints clear at the midpoint and contribute zero. Genuine positioning that prints at the midpoint is missed. Bias is toward under-estimating OI changes in liquid, tight-spread names.

None of these break the methodology on aggregate. They show up as residual variance in the daily reconcile and inform the next calibration pass.

Using it

import requests

resp = requests.get(
    "https://lab.flashalpha.com/v1/exposure/gex/SPY",
    headers={"X-Api-Key": "YOUR_KEY"}
)
data = resp.json()
print(f"Official OI:    {data['oi']['official_oi']:,}")
print(f"Simulated OI:   {data['oi']['simulated_oi']:,}")
print(f"Effective OI:   {data['oi']['effective_oi']:,}")
print(f"Intraday Delta: {data['oi']['intraday_oi_delta']:+,}")
print(f"Confidence:     {data['oi']['oi_delta_confidence']}")
print(f"Live GEX:       {data['live_gex']:,.0f}")

Free tier and docs at flashalpha.com. Full methodology details, calibration history, and the four-question vendor checklist are in the original article.