Forem: tomasz dobrowolski

Screener Cookbook — GEX, VRP, and 0DTE Filters for the Live Options Screener

tomasz dobrowolski — Sun, 05 Apr 2026 17:26:06 +0000

The Live Screener is a grammar. Most of its value shows up the moment you stop asking "what fields exist" and start asking "what question am I trying to answer."

This cookbook is a dozen of the questions I ask most often, with the JSON that answers each one and a note about what the thresholds mean. For the full technical walkthrough of the data model, filter grammar, and cascading semantics, see the pillar article.

1. Negative-gamma alert board

Question: which symbols have dealers short gamma and already carrying a lot of exposure?

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime",           "operator": "eq",  "value": "negative_gamma" },
    { "field": "dealer_flow_risk", "operator": "gte", "value": 50 }
  ]},
  "sort":   [{ "field": "dealer_flow_risk", "direction": "desc" }],
  "select": ["symbol","regime","dealer_flow_risk","gamma_flip","net_gex"]
}

Use this at the open to flag names that will amplify intraday moves. Raise the threshold to 70 for a more exclusive list; drop to 30 for a wider net.

2. Harvestable VRP short list

Question: where is it actually safe to sell premium today?

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime",            "operator": "eq",  "value": "positive_gamma" },
    { "field": "vrp_regime",        "operator": "eq",  "value": "harvestable" },
    { "field": "dealer_flow_risk",  "operator": "lte", "value": 40 },
    { "field": "harvest_score",     "operator": "gte", "value": 65 }
  ]},
  "sort":   [{ "field": "harvest_score", "direction": "desc" }],
  "select": ["symbol","price","harvest_score","dealer_flow_risk","vrp_regime"]
}

All four filters are doing work: positive gamma means the vol backdrop is stable, harvestable means VRP is rich and realized vol is behaving, low dealer risk means hedging flow won't run against you, and the harvest score gives a hard floor on the composite signal.

3. 0DTE call-seller setup (cascading)

Question: for every symbol, pull just the 0DTE calls worth selling.

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

The cascading AND trims every symbol to just its 0DTE expiry, just the calls, just the 30-delta-and-higher contracts, just the ones with meaningful OI. select: ["*"] gives you the full flat object so you can inspect bid/ask and walk strikes in one pass.

4. Skew-rich put wings

Question: where is downside protection genuinely expensive vs the rest of the chain?

{
  "filters": { "op": "and", "conditions": [
    { "field": "skew_25d", "operator": "gte", "value": 4 },
    { "field": "regime",   "operator": "eq",  "value": "positive_gamma" }
  ]},
  "sort":   [{ "field": "skew_25d", "direction": "desc" }],
  "select": ["symbol","skew_25d","skew_25d_put","skew_25d_call","atm_iv"]
}

Rich put skew in a positive-gamma regime is a clean short-put setup — the skew tells you the premium is there, the regime tells you dealers are on your side.

5. Liquid ATM short-dated calls

Question: tradable short-dated, delta-50 calls across symbols.

{
  "filters": { "op": "and", "conditions": [
    { "field": "atm_spread_pct",          "operator": "lte", "value": 0.05 },
    { "field": "expiries.days_to_expiry", "operator": "between", "value": [1, 14] },
    { "field": "contracts.type",          "operator": "eq",  "value": "C" },
    { "field": "contracts.delta",         "operator": "between", "value": [0.45, 0.55] }
  ]},
  "select": ["*"], "limit": 20
}

Stock-level atm_spread_pct prunes names with bad microstructure, then the cascading contract filter pulls just the liquid ATM expressions.

6. Risk-adjusted ranking (formula)

Question: rank symbols by edge per unit of dealer risk.

{
  "formulas": [
    { "alias": "risk_adj", "expression": "harvest_score / (dealer_flow_risk + 1)" }
  ],
  "filters": { "field": "harvest_score", "operator": "gte", "value": 50 },
  "sort":    [{ "formula": "risk_adj", "direction": "desc" }],
  "select":  ["symbol","price","harvest_score","dealer_flow_risk","risk_adj"],
  "limit":   20
}

The +1 prevents div-by-zero. Sort by the ratio to put the highest "bang per risk" setups at the top.

7. Macro-conditioned regime scan

Question: negative-gamma names only when VIX is elevated.

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime", "operator": "eq",  "value": "negative_gamma" },
    { "field": "vix",    "operator": "gte", "value": 20 }
  ]},
  "select": ["symbol","regime","atm_iv","vix"]
}

The VIX condition is the entry gate — on a calm day this returns nothing. That's the point.

8. IV band targeting

Question: names sitting in the premium sweet spot.

{
  "filters": { "field": "atm_iv", "operator": "between", "value": [18, 28] },
  "sort":    [{ "field": "atm_iv", "direction": "asc" }],
  "select":  ["symbol","atm_iv","rv_20d","vrp_20d","term_state"]
}

Below 18 there's no premium to sell, above 28 you're often trading into an event. Pair with vrp_20d to check that realized is behaving.

9. Iron-condor candidates

{
  "filters": { "op": "and", "conditions": [
    { "field": "iron_condor_score", "operator": "gte", "value": 60 },
    { "field": "regime",            "operator": "eq",  "value": "positive_gamma" },
    { "field": "term_state",        "operator": "in",  "value": ["contango","mixed"] }
  ]},
  "sort":   [{ "field": "iron_condor_score", "direction": "desc" }],
  "select": ["symbol","iron_condor_score","regime","term_state","atm_iv","skew_25d"]
}

Pre-computed strategy scores are the killer feature — you don't build the scoring, you just filter on it.

10. Calendar-spread candidates

{
  "filters": { "op": "and", "conditions": [
    { "field": "calendar_spread_score", "operator": "gte", "value": 60 },
    { "field": "term_state",            "operator": "eq",  "value": "contango" }
  ]},
  "sort":   [{ "field": "calendar_spread_score", "direction": "desc" }],
  "select": ["symbol","calendar_spread_score","term_state","term_near_slope_pct","term_far_slope_pct"]
}

11. Multi-sort flow board

Question: dashboard-style ranking combining two signals.

{
  "sort": [
    { "field": "dealer_flow_risk", "direction": "asc" },
    { "field": "harvest_score",    "direction": "desc" }
  ],
  "select": ["symbol","dealer_flow_risk","harvest_score","regime","atm_iv"],
  "limit":  20
}

Primary: lowest risk first. Secondary: tiebreak by highest harvest. Ideal as a morning dashboard.

12. Vol scanner (high IV vs RV)

{
  "filters": { "op": "and", "conditions": [
    { "field": "vrp_20d", "operator": "gte", "value": 5 },
    { "field": "atm_iv",  "operator": "gte", "value": 25 }
  ]},
  "sort":   [{ "field": "vrp_20d", "direction": "desc" }],
  "select": ["symbol","atm_iv","rv_20d","vrp_20d","skew_25d"]
}

Composing your own

Three rules that hold across all twelve:

Start from the question, not the fields. "What trade am I hunting?" then "which fields encode that condition?"
Use AND for cascading. If you're reaching into expiries.X, strikes.X, or contracts.X, cascading AND is what lets you return only the matching children per symbol.
Rank with a formula when a single field doesn't capture the tradeoff. Risk-adjusted scores, ratios, and differences are the right shape for an ordered output.

For the full field list: Field Taxonomy. For the grammar reference: Live Screener spec. For the technical deep-dive: Real-Time Options Screener guide.

All 12 recipes target the FlashAlpha Live Screener. Growth unlocks 10 symbols; Alpha unlocks ~250 symbols, formulas, harvest_score, dealer_flow_risk, vrp_regime, and strategy-specific scores. Free tier at 5 requests/day. Compare plans.

Live Options Screener API — Real-Time Filter, Rank, and Score Across 250 Symbols

tomasz dobrowolski — Sun, 05 Apr 2026 17:25:26 +0000

If you're building an options trading tool, screening is usually the first thing that gets nasty. You have a universe of tickers, a handful of interesting metrics (IV, GEX, VRP, skew, open interest), and you want to rank them in real time. Doing that yourself means millions of option contracts per day, IV solvers, surface fitting, a scheduler, a database — and then every time a trader says "can you also filter by dealer flow risk?", you rebuild half of it.

The Live Screener API at POST /v1/screener/live gives you that entire layer as one request. You send a filter tree, a sort spec, and a list of fields you want back. The server has already pre-computed every metric for ~250 symbols and refreshes them every 5–10 seconds from an in-memory store. No database query at request time. No warm-up lag.

This article explains the data model, the filter grammar, cascading semantics, and formulas — with enough worked examples that you can wire up a screener in an afternoon.

Why one POST endpoint beats a dozen GETs

The usual pattern with options APIs is "one endpoint per ticker, loop over your watchlist, join in your client." That works fine for 10 symbols. Two problems when you scale:

N round trips. You pay the network cost N times. For a 250-symbol scan, that's 250 HTTP requests.

You do the joining. You call /exposure/summary, /volatility, /vrp, merge them in memory, and only then can you rank.

A POST screener inverts both. The server already has every symbol hydrated in memory. You send the filter tree as JSON, the server does the join, the filter, the sort, and the pagination. One request in, a ranked page out.

{
  "filters":  { ... filter tree ... },
  "sort":     [ ... sort specs ... ],
  "select":   [ ... field names ... ],
  "formulas": [ ... custom computed fields ... ],
  "limit":    50,
  "offset":   0
}

Every key is optional. An empty body {} returns every symbol in your plan's universe with a default field set.

The four-level data model

Every symbol is modelled as a nested tree:

Stock (1 per symbol)
 └─ Expiry aggregates (many per symbol)
     └─ Strike aggregates (many per expiry)
         └─ Contracts (2 per strike: C and P)

Each level has its own filterable fields, accessed via a dotted prefix:

regime, net_gex, atm_iv, vrp_20d — stock-level (no prefix)
expiries.days_to_expiry, expiries.atm_iv — per-expiry
strikes.call_oi, strikes.net_gex — per-strike inside each expiry
contracts.type, contracts.delta, contracts.oi — individual calls/puts

This means you can express "positive-gamma symbols, only expiries within 14 days, only strikes with call_oi ≥ 2000, only the 30–50 delta call contracts" in a single query.

Filter grammar: AND, OR, leaves

Filters form a recursive tree. A node is either a leaf or a group (AND / OR with child conditions):

// Leaf
{ "field": "atm_iv", "operator": "gte", "value": 20 }

// Group
{
  "op": "and",
  "conditions": [
    { "field": "regime", "operator": "eq",  "value": "positive_gamma" },
    { "field": "atm_iv", "operator": "gte", "value": 15 }
  ]
}

Groups nest up to 3 levels deep, with a max of 20 total leaf conditions per query. Operators: eq, neq, gt, gte, lt, lte, between, in, is_null, is_not_null. String comparisons are case-insensitive.

Cascading filters — the killer feature

When you combine stock-level + expiry-level + strike-level + contract-level filters inside an AND group, the filter cascades. Non-matching children get trimmed at each level, and symbols with zero survivors are dropped.

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "regime",                   "operator": "eq",  "value": "positive_gamma" },
      { "field": "expiries.days_to_expiry",  "operator": "lte", "value": 14 },
      { "field": "strikes.call_oi",          "operator": "gte", "value": 2000 },
      { "field": "contracts.type",           "operator": "eq",  "value": "C" },
      { "field": "contracts.delta",          "operator": "gte", "value": 0.3 }
    ]
  },
  "select": ["*"],
  "limit": 20
}

That single query returns only the symbols where regime = positive_gamma, only their expiries where DTE ≤ 14, only the strikes inside those expiries with call_oi ≥ 2000, and only the call contracts at those strikes with delta ≥ 0.3.

Without cascading you'd pull everything and filter client-side. Cascading shifts the entire winnowing process server-side.

OR groups behave differently. Nested filters inside an OR use Any() semantics — contracts.delta > 0.3 matches if any contract in the symbol clears the bar. OR does not cascade; the full data comes back for matching symbols.

Formulas: your own computed fields

If the field you want isn't in the catalog, define it inline:

{
  "formulas": [
    { "alias": "vrp_ratio", "expression": "atm_iv / rv_20d" },
    { "alias": "risk_adj",  "expression": "harvest_score / (dealer_flow_risk + 1)" }
  ],
  "sort":   [{ "formula": "risk_adj", "direction": "desc" }],
  "select": ["symbol", "harvest_score", "dealer_flow_risk", "risk_adj"]
}

Supported: + - * /, parentheses, unary negation, numeric literals, any numeric field name. Division by zero returns null. You can also use formulas inline in filter conditions:

{ "formula": "atm_iv - rv_20d", "operator": "gt", "value": 6 }

Formulas are Alpha-tier only.

Pre-computed strategy scores

For every symbol, Alpha-tier responses include 0–100 strategy scores refreshed every 5–10 seconds:

harvest_score — is it safe to sell premium here, right now?
net_harvest_score — harvest score penalized by dealer flow risk
dealer_flow_risk — estimate of how aggressively dealers will hedge against you
short_put_spread_score, short_strangle_score, iron_condor_score, calendar_spread_score — strategy-specific attractiveness

The vrp_regime classifier tags each symbol as harvestable, toxic_short_vol, cheap_convexity, event_only, or surface_distorted — letting you write scans like "only sell premium when harvestable, never when toxic_short_vol."

Five worked examples

1. Negative-gamma alert board

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime",           "operator": "eq",  "value": "negative_gamma" },
    { "field": "dealer_flow_risk", "operator": "gte", "value": 50 }
  ]},
  "sort":   [{ "field": "dealer_flow_risk", "direction": "desc" }],
  "select": ["symbol", "regime", "dealer_flow_risk", "gamma_flip", "net_gex"]
}

2. Harvestable VRP short list

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime",            "operator": "eq",  "value": "positive_gamma" },
    { "field": "vrp_regime",        "operator": "eq",  "value": "harvestable" },
    { "field": "dealer_flow_risk",  "operator": "lte", "value": 40 },
    { "field": "harvest_score",     "operator": "gte", "value": 65 }
  ]},
  "sort":   [{ "field": "harvest_score", "direction": "desc" }],
  "select": ["symbol", "price", "harvest_score", "dealer_flow_risk", "vrp_regime"]
}

3. 0DTE call-seller setup (cascading)

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

4. Macro-conditioned regime scan

{
  "filters": { "op": "and", "conditions": [
    { "field": "regime", "operator": "eq",  "value": "negative_gamma" },
    { "field": "vix",    "operator": "gte", "value": 20 }
  ]},
  "select": ["symbol", "regime", "atm_iv", "vix"]
}

5. Risk-adjusted ranking (formula)

{
  "formulas": [
    { "alias": "risk_adj", "expression": "harvest_score / (dealer_flow_risk + 1)" }
  ],
  "filters": { "field": "harvest_score", "operator": "gte", "value": 50 },
  "sort":    [{ "formula": "risk_adj", "direction": "desc" }],
  "select":  ["symbol", "price", "harvest_score", "dealer_flow_risk", "risk_adj"],
  "limit":   20
}

When to use the screener vs per-symbol endpoints

The screener answers "which symbols?" — ranking, filtering, regime detection across the universe. Per-symbol endpoints (GEX, VRP, Narrative) answer "tell me everything about this one" — per-strike data, surface parameters, historical context.

Typical workflow: screener trims ~250 to 5–10 candidates, then you drill into each one with the detail endpoints for position sizing and entry timing.

Getting started

curl -X POST "https://lab.flashalpha.com/v1/screener/live" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": { "field": "regime", "operator": "eq", "value": "negative_gamma" },
    "sort":    [{ "field": "atm_iv", "direction": "desc" }],
    "select":  ["symbol", "price", "regime", "atm_iv", "net_gex"],
    "limit":   10
  }'

Full field reference: Live Screener docs and Field Taxonomy. Copy-paste recipes: Screener Cookbook.

The Live Screener is part of the FlashAlpha Lab API — Growth for a 10-symbol universe, Alpha for ~250 symbols with formulas and strategy scores. Start with the free tier (5 requests/day) and upgrade when you're ready to scan.

Call Wall, Put Wall & Gamma Flip: The Three GEX Levels That Predict Intraday Ranges

tomasz dobrowolski — Fri, 03 Apr 2026 06:31:53 +0000

Originally published at flashalpha.com

On March 18, 2025, SPY traded in a $2.10 range all day — pinned between two invisible levels. The next morning, a hot CPI print pushed price below a critical threshold. The range that day? $8.40 — four times wider.

Same stock. Same market. Same traders. The only thing that changed was the gamma regime.

Three numbers predicted the entire shift — and if you trade options, equities, or anything correlated to index flows, these are levels you need on your daily dashboard.

The Framework

Options dealers (market makers) take the other side of your trades. To stay delta-neutral, they continuously hedge by buying or selling the underlying. Where they hedge — and in which direction — creates real, measurable support and resistance.

Three levels capture the entire picture:

Call Wall — the strike with the highest call-side gamma. Acts as resistance. As price rises toward it, dealers sell stock to rebalance their hedge. The higher the open interest at that strike, the stronger the selling pressure.

Put Wall — the mirror image. The strike with the highest put-side gamma. Acts as support. As price falls toward it, dealers buy stock to hedge short puts. This creates a floor.

Gamma Flip — the price where net dealer gamma crosses zero. This is the regime boundary. Above it, dealers dampen volatility (buy dips, sell rallies). Below it, they amplify it (sell into declines, buy into rallies). It's the single most important number in gamma exposure analysis.

Why This Matters for Your Portfolio

In positive gamma (price above the flip), SPY stays between the call wall and put wall roughly 70% of sessions. Intraday ranges are compressed. Mean-reversion strategies work. Premium selling has an edge.

In negative gamma (price below the flip), intraday ranges expand 2–4×. Trending moves dominate. Support levels break. This is where cascading selloffs happen — not because of panic, but because of mechanics.

Understanding which regime you're in changes everything about how you size positions, set stops, and select strategies.

The Asymmetry You Need to Know

Call wall breakouts are usually orderly — the market grinds higher as the hedging "ceiling" disappears (traders call this "gamma unclenching").

Put wall breakdowns are violent. When price breaks below the put wall into negative gamma, dealer hedging flips from supportive to destabilizing. The buying pressure that was creating a floor vanishes, and selling pressure accelerates the decline. This is the mechanical explanation behind many of the fastest selloffs in equity markets.

How I Use These Levels

I check three things every morning before the open:

Where is spot relative to the gamma flip? This tells me whether to expect mean-reversion or momentum — the single most important input for strategy selection.
What's the distance to the call wall and put wall? These define the expected range. In positive gamma, I treat them as hard boundaries. In negative gamma, I treat them as zones that may break.
Is there an expiration approaching? Gamma is strongest near OPEX. The levels carry more weight when monthly or quarterly options are about to expire. After OPEX, gamma resets and the levels shift.

Making This Actionable

At FlashAlpha, we compute call wall, put wall, and gamma flip in real time for 6,000+ US equities and ETFs. The data is available through:

→ A free interactive GEX tool (no account needed): flashalpha.com/tools/gamma-exposure
→ A REST API for programmatic access (5 free requests/day): flashalpha.com/docs/lab-api-gex
→ Python, JavaScript, C#, Go, and Java SDKs on GitHub

Whether you're a systematic trader pulling levels into your models, a discretionary trader checking the regime before the open, or a portfolio manager assessing when hedges may become less effective — these three levels belong in your workflow.

📖 The full deep-dive with formulas, code examples, and per-strike breakdowns: flashalpha.com/articles/call-wall-put-wall-gamma-flip-options-levels-explained

🔧 Free GEX tool: flashalpha.com/tools/gamma-exposure

📡 API docs: flashalpha.com/docs/lab-api-gex

OptionsTrading #GammaExposure #GEX #DealerPositioning #QuantFinance #TradingStrategy #OptionsAnalytics #MarketMicrostructure #FlashAlpha

Call Wall, Put Wall & Gamma Flip Explained: The Three GEX Levels Every Options Trader Must Know

tomasz dobrowolski — Fri, 03 Apr 2026 06:30:36 +0000

On March 18, 2025, SPY traded in a $2.10 range all day — pinned between the call wall at $575 and put wall at $567. The next morning, a hot CPI print pushed price below the gamma flip at $565. The range that day? $8.40 — four times wider. Same stock, same market. The only thing that changed was the gamma regime.

This is not a coincidence. It is the direct result of how options dealers hedge — and three numbers predicted the entire shift: the call wall, the put wall, and the gamma flip point.

Most explanations stop at one-sentence definitions. This guide covers the mechanics, the math, and the code so you can pull these levels programmatically and use them with confidence.

If you're new to gamma exposure entirely, start with our complete GEX guide first.

The Three GEX Levels at a Glance

Level	Definition	Market Effect
Call Wall	Highest call-side gamma strike	Resistance — dealers sell stock as price rises toward it
Put Wall	Highest put-side gamma strike	Support — dealers buy stock as price falls toward it
Gamma Flip	Net GEX = 0	Regime boundary — above = dampened vol, below = amplified

$555 Put Wall --- $565 Gamma Flip --- $571 SPOT --- $580 Call Wall
support            regime boundary        current          resistance

What Is a Call Wall?

The call wall is the strike with the largest call-side gamma exposure. It acts as resistance because of the mechanics of dealer hedging.

Most call options are sold by dealers (market makers) to customers. When you buy a call, the dealer is short that call. To stay delta-neutral, the dealer buys stock proportional to the option's delta.

As the underlying rises toward a high-gamma call strike:

The delta of those calls increases (moving ITM)
Gamma means the dealer's hedge adjustment accelerates
The dealer must sell stock into the rally to re-balance
This selling creates natural resistance at the call wall

The formula for identifying the call wall:

Call Wall = argmax_K [ Γ_call(K) × OI_call(K) × 100 × S² ]

When the Call Wall Breaks

Call walls aren't impenetrable. When price pushes through, something important happens: deep ITM calls have low gamma, so the hedging pressure that was acting as resistance disappears. The result is often an acceleration above the old call wall — traders call this "gamma unclenching."

1. SPY @ $578 → Call Wall $580 → dealer selling slows the rally
2. SPY @ $580 → At the wall    → maximum hedging pressure, stall
3. SPY @ $582 → Break!         → gamma decays, selling vanishes
4. SPY @ $587 → New Call Wall $590 → acceleration above old wall

What Is a Put Wall?

The mirror image. The put wall is the strike with the largest put-side gamma exposure, acting as support.

Dealers short put options to customers (protective puts). As price falls toward a high-gamma put strike, those puts gain delta, and dealers must buy stock to hedge — creating a natural floor.

When the Put Wall Breaks

A put wall breach is one of the most dangerous signals in options-driven analysis. The buying pressure that was supporting price vanishes, and the decline accelerates.

Put wall breaks often coincide with negative gamma territory. Once the support is gone and dealers are amplifying moves instead of dampening them, you get a cascading selloff — the "elevator down" effect.

1. SPY @ $558 → Put Wall $555 → dealer buying provides a floor
2. SPY @ $555 → At the wall    → max hedging support, bounce expected
3. SPY @ $553 → BREAK          → gamma decays, buying vanishes
4. SPY @ $545 → Cascade        → negative gamma amplifies selloff

Put wall breaks are asymmetric. Call wall breakouts are usually orderly (grind higher). Put wall breakdowns are often violent because they push price into negative gamma, where dealer hedging amplifies the move.

What Is the Gamma Flip Point?

The gamma flip is the price where aggregate dealer gamma crosses from positive to negative. It's arguably the single most important number in GEX analysis because it defines the volatility regime.

Above the Flip (Positive Gamma)

Dealers buy dips and sell rallies — mean reversion dominates
Realized vol suppressed below implied vol
Premium selling has an edge
Call wall and put wall act as hard boundaries

Below the Flip (Negative Gamma)

Dealers sell into declines and buy into rallies — momentum dominates
Realized vol overshoots implied vol
Premium buying has an edge
Support and resistance levels break easily
Trend days, gaps, and cascading moves are common

Key stats:

2–4× typical increase in intraday range when price crosses below the gamma flip
~70% of sessions where SPY stays between call wall and put wall in positive gamma
$3–8B estimated daily dealer hedging flow in SPY from gamma alone

Pulling GEX Levels from the API

FlashAlpha returns call wall, put wall, and gamma flip in every GEX response. Here's how to pull them:

Python

import requests

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

r = requests.get(f"{BASE}/v1/exposure/gex/SPY", headers=HEADERS)
data = r.json()

print(f"SPY @ ${data['underlying_price']:.2f}")
print(f"Call Wall:   ${data['call_wall']}")
print(f"Put Wall:    ${data['put_wall']}")
print(f"Gamma Flip:  ${data['gamma_flip']}")
print(f"Net GEX:     {data['net_gex']:,.0f}  ({data['net_gex_label']})")

spot = data['underlying_price']
flip = data['gamma_flip']
regime = "POSITIVE GAMMA" if spot > flip else "NEGATIVE GAMMA"
print(f"Regime:      {regime}")
print(f"Distance to flip: {((spot - flip) / spot) * 100:.1f}%")

JavaScript

const res = await fetch("https://lab.flashalpha.com/v1/exposure/gex/SPY", {
    headers: { "X-Api-Key": "YOUR_API_KEY" }
});
const data = await res.json();

console.log(`SPY @ $${data.underlying_price}`);
console.log(`Call Wall:  $${data.call_wall}`);
console.log(`Put Wall:   $${data.put_wall}`);
console.log(`Gamma Flip: $${data.gamma_flip}`);

const regime = data.underlying_price > data.gamma_flip
    ? "POSITIVE GAMMA" : "NEGATIVE GAMMA";
console.log(`Regime:     ${regime}`);

cURL

curl -s "https://lab.flashalpha.com/v1/exposure/gex/SPY" \
  -H "X-Api-Key: YOUR_API_KEY" | jq '{
    symbol, underlying_price, call_wall, put_wall,
    gamma_flip, net_gex, net_gex_label
  }'

Sample output:

SPY @ $571.23
Call Wall:   $580.00
Put Wall:    $555.00
Gamma Flip:  $565.00
Net GEX:     +2,847,391,200 (strongly positive)
Regime:      POSITIVE GAMMA
Distance to flip: 1.1% ⚠ close to regime boundary

Free tier gives you 5 requests/day with single-expiry GEX. Growth ($299/mo) unlocks full-chain aggregation and 2,500 req/day. Alpha ($1,499/mo) adds VRP, vanna, charm, and unlimited requests.

How the Three Levels Work Together

Scenario	Market Behavior	Strategy
Between put wall and call wall, above flip	Tight range, low vol, mean reversion	Sell premium, fade extremes
Approaching call wall from below	Rally slows, dealer selling increases	Take profits on longs
Approaching put wall from above	Decline slows, dealer buying increases	Look for bounce setups
Breaks below gamma flip	Volatility expands, trending moves	Switch to momentum, buy protection
Breaks below put wall in negative gamma	Cascading selloff, no dealer support	Don't catch knives — wait for OPEX reset
Breaks above call wall	Resistance removed, gamma unclenching	Trail stops, new call wall is next target

Common Mistakes

Treating levels as exact prices. The call wall at $580 doesn't mean price stops at $580.00. These are zones of influence ($2–5 range).
Ignoring expiration context. GEX levels are strongest near OPEX because gamma peaks as time-to-expiry shrinks. A call wall from options expiring in 3 days is far more powerful than one from 45-DTE options.
Using stale data. GEX levels shift as new trades execute. EOD data from last night may not reflect morning activity.
Trading levels without regime context. A put wall in positive gamma is strong support. The same put wall in negative gamma is a speed bump. Always check the gamma flip first.
Forgetting GEX is one input. Earnings, FOMC, geopolitical events can all overwhelm dealer hedging. Use GEX alongside price action, volume, and macro context.

Get Started

Visual: Free GEX tool — no account required
Programmatic: GEX API — 5 free requests/day, no credit card
Full stack: Pricing page — Growth and Alpha plans

For the full deep-dive with LaTeX formulas, interactive diagrams, and per-strike breakdowns, read the complete article on FlashAlpha.

Originally published at flashalpha.com

Quantifying Dealer Positioning with GEX, VEX, and CHEX — A Developer's Guide

tomasz dobrowolski — Wed, 01 Apr 2026 11:27:29 +0000

Every time an options market maker sells you a call or put, they inherit Greek exposure they didn't ask for. To stay delta-neutral, they must hedge — and that hedging creates mechanical, involuntary flows that move the underlying.

This isn't sentiment analysis. It's physics.

I've been building tools to quantify these flows programmatically. Here's the framework — with code you can run today.

What GEX Actually Measures

Gamma Exposure (GEX) per strike:

GEX_k = Γ_k × OI_k × 100 × S

Where Γ is option gamma, OI is open interest, S is spot price. The sign convention:

Call OI → positive dealer gamma (customers buy calls → dealers short calls → dealers are long gamma)
Put OI → negative dealer gamma (customers buy puts → dealers short puts → dealers are short gamma)

Positive net GEX: Dealers buy dips, sell rallies. Dampens moves. Compresses realized vol.

Negative net GEX: Dealers sell into declines, buy into rallies. Amplifies moves. Expands realized vol.

GEX tells you how much price will move, not which direction.

Pulling Per-Strike GEX Data

The /v1/exposure/gex/{symbol} endpoint returns per-strike gamma exposure with call/put decomposition. Available on the free tier.

import requests

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

r = requests.get(f"{BASE}/v1/exposure/gex/SPY", headers=HEADERS)
data = r.json()

print(f"SPY @ ${data['underlying_price']:.2f}")
print(f"Net GEX: ${data['net_gex']:,.0f} ({data['net_gex_label']})")
print(f"Gamma Flip: ${data['gamma_flip']:.2f}")

# Top strikes by absolute GEX
strikes = sorted(
    data["strikes"], 
    key=lambda x: abs(x["net_gex"]), 
    reverse=True
)[:10]

for s in strikes:
    print(f"  ${s['strike']:>7.0f}  "
          f"call={s['call_gex']:>12,}  "
          f"put={s['put_gex']:>12,}  "
          f"net={s['net_gex']:>12,}")

Key Levels: Where Flows Concentrate

The /v1/exposure/levels/{symbol} endpoint (also free) extracts the critical levels:

r = requests.get(f"{BASE}/v1/exposure/levels/SPY", headers=HEADERS)
lvl = r.json().get("levels", r.json())

print(f"Gamma Flip:        ${lvl['gamma_flip']:.2f}")
print(f"Call Wall:         ${lvl['call_wall']:.2f}")
print(f"Put Wall:          ${lvl['put_wall']:.2f}")
print(f"Max Positive GEX:  ${lvl['max_positive_gamma']:.2f}")
print(f"0DTE Magnet:       ${lvl['zero_dte_magnet']:.2f}")

Level	What It Means	How to Use It
Gamma flip	Net dealer gamma crosses zero	The most important level. Above = dampened. Below = amplified.
Call wall	Peak positive gamma	Mechanical resistance — dealers sell rallies here.
Put wall	Peak negative gamma	Mechanical support — dealers buy dips here.
Max gamma	Strongest dampening	Price magnet. Expiration pinning is strongest here.
0DTE magnet	Intraday pin from same-day options	Relevant for SPY/QQQ intraday structures.

Beyond GEX: Second-Order Flows

Here's where most GEX analysis stops — and where quantitative positioning analysis starts. Dealers also hedge against volatility changes (vanna) and time decay (charm). These flows are often larger than gamma hedging.

VEX: Vanna Exposure

Vanna = ∂Δ/∂σ — sensitivity of delta to implied volatility.

When IV drops, negative vanna shifts dealer delta → dealers buy shares → supports price → IV drops further. Virtuous cycle for short vol.

When IV rises, the reverse: dealers sell shares → price falls → IV rises further. Vicious cycle.

r = requests.get(f"{BASE}/v1/exposure/vex/SPY", headers=HEADERS)
vex = r.json()
print(f"Net VEX: ${vex['net_vex']:,.0f}")

CHEX: Charm Exposure

Charm = ∂Δ/∂t — sensitivity of delta to time. Even with no price or vol movement, time passing shifts delta and forces dealer rebalancing. This is the primary driver of 0DTE intraday behavior and end-of-day drift.

r = requests.get(f"{BASE}/v1/exposure/chex/SPY", headers=HEADERS)
chex = r.json()
print(f"Net CHEX: ${chex['net_chex']:,.0f}")

All four exposure endpoints (GEX, DEX, VEX, CHEX) are free tier for per-strike data.

Building a Regime Classifier

Combining GEX sign + distance from gamma flip + VEX alignment gives you a multi-dimensional regime model:

def classify_regime(gex_data, vex_data, levels_data, spot):
    net_gex = gex_data.get("net_gex", 0)
    net_vex = vex_data.get("net_vex", 0)
    flip    = levels_data.get("gamma_flip", spot)

    dist = (spot - flip) / spot * 100 if spot > 0 else 0
    gamma_regime = "positive" if net_gex > 0 else "negative"

    # Vanna aligned = supports the gamma regime
    vanna_aligned = (gamma_regime == "positive" and net_vex < 0)

    # Confidence based on distance from flip
    if abs(dist) > 2.0:
        confidence = "high"
    elif abs(dist) > 0.5:
        confidence = "moderate"
    else:
        confidence = "low"  # regime could flip

    return {
        "regime": gamma_regime,
        "vanna_aligned": vanna_aligned,
        "dist_to_flip": dist,
        "confidence": confidence,
    }

Gamma	Vanna	Confidence	What It Means
Positive	Aligned	High	Strongly dampened. Premium selling paradise.
Positive	Adverse	Any	Dampened by gamma, but vanna working against. Watch for vol shift.
Negative	Either	Moderate+	Amplified moves. Defined risk only. Cascades possible.
Any	Any	Low	Near the flip. Reduce exposure or wait.

Multi-Symbol Dashboard

The real power is screening across your universe:

UNIVERSE = ["SPY", "QQQ", "IWM", "AAPL", "TSLA", 
            "NVDA", "META", "AMZN", "AMD", "GOOGL"]

for sym in UNIVERSE:
    gex = requests.get(f"{BASE}/v1/exposure/gex/{sym}", 
                       headers=HEADERS).json()

    # Alpha tier: add VRP intelligence
    vrp = requests.get(f"{BASE}/v1/vrp/{sym}", 
                       headers=HEADERS).json()

    spot = gex["underlying_price"]
    flip = gex["gamma_flip"]
    dist = (spot - flip) / spot * 100
    z    = vrp.get("vrp", {}).get("z_score", 0)

    pos = gex["net_gex"] > 0
    high = z >= 1.0

    if pos and high:     cell = "A"  # Premium Paradise
    elif not pos and high: cell = "B"  # Tempting Trap
    elif pos:            cell = "C"  # Grind
    else:                cell = "D"  # No Trade

    print(f"{sym:<6} Cell {cell}  "
          f"dist={dist:+.1f}%  z={z:+.2f}")

The Bridge: From GEX to VRP

This is the critical distinction:

Free tier (GEX/DEX/VEX/CHEX) tells you what dealers are doing.

Alpha tier (VRP analytics) tells you what it means for your trade:

VRP z-scores & percentiles — is premium statistically elevated?
Directional VRP — is it in puts, calls, or both?
GEX-conditioned harvest score — how favorable is this regime for premium selling?
Strategy scores — which of 5 common structures scores highest right now?
Dealer flow risk (0–100) — how much risk do dealer flows pose?
Unlimited API calls — monitor your entire universe without throttling

The daily workflow: screen for VRP signals → classify gamma regime → select structure → set entry at dealer levels → manage with exit rules. Two API calls per symbol. Runs in 5 minutes.

The complete workflow with Kelly sizing, term VRP selection, and the full runnable morning scanner is in the companion article.

Links:

I Built a 5-Minute VRP Trading Scanner in Python — Here's the Code

tomasz dobrowolski — Wed, 01 Apr 2026 11:26:58 +0000

Options implied volatility overestimates realized vol. This is the variance risk premium (VRP) — and it's one of the most persistent edges in financial markets.

The problem: most people who know this still lose money selling premium. Not because the edge isn't there, but because they lack a repeatable process for deciding when, what, and how much to trade.

I built a 5-step daily workflow that answers all three questions using two API calls per symbol. It runs in under 5 minutes. Here's the full code.

The Stack

Data: FlashAlpha API — pre-computed VRP analytics, GEX regime data, dealer positioning levels across 4,000+ US equities/ETFs
Language: Python (also works in JS/cURL)
Dependencies: requests (that's it)

Step 1: Screen for VRP Signals

The /v1/vrp/{symbol} endpoint returns a full VRP dashboard per symbol. The two fields that matter for screening:

z_score — how many standard deviations above the 252-day mean. Above +1.0 = elevated.
vrp_20d — raw IV minus realized vol over 20 days. Positive = premium exists.

import requests

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

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

signals = []

for sym in WATCHLIST:
    r = requests.get(f"{BASE}/v1/vrp/{sym}", headers=HEADERS)
    if r.status_code != 200:
        continue
    d = r.json()
    vrp = d.get("vrp", {})

    z      = vrp.get("z_score", 0)
    spread = vrp.get("vrp_20d", 0)

    if z >= 1.0 and spread > 2.0:
        signals.append({
            "symbol": sym, 
            "z_score": z,
            "vrp_20d": spread,
            "atm_iv": vrp.get("atm_iv", 0),
            "rv_20d": vrp.get("rv_20d", 0),
            "_raw": d,
        })

signals.sort(key=lambda x: x["z_score"], reverse=True)
print(f"Found {len(signals)} symbols with actionable VRP")

Filter logic: z-score ≥ 1.0 AND vrp_20d > 2.0 vol points. Conservative on purpose. A z-score of +2.0 on a 1-point spread isn't worth the transaction costs.

Step 2: Classify the Gamma Regime

A high VRP signal without regime context is incomplete. The same API response includes GEX-conditioned data — no extra call needed.

The key insight: dealer gamma positioning determines whether your short vol trade gets dampened (positive gamma = dealers buy your dips) or amplified (negative gamma = dealers sell into your drawdown).

for s in signals:
    d = s["_raw"]
    regime = d.get("regime", {})

    s["gamma_regime"] = regime.get("gamma", "unknown")
    s["gamma_flip"]   = regime.get("gamma_flip", 0)
    s["spot"]         = d.get("underlying_price", 0)

    # The 4-cell GEX-VRP matrix
    pos_gamma = s["gamma_regime"] == "positive_gamma"
    high_vrp  = s["z_score"] >= 1.0

    if pos_gamma and high_vrp:
        s["cell"], s["size"] = "A", 1.75   # Premium Paradise
    elif not pos_gamma and high_vrp:
        s["cell"], s["size"] = "B", 0.50   # Tempting Trap
    elif pos_gamma and not high_vrp:
        s["cell"], s["size"] = "C", 0.50   # Grind It Out
    else:
        s["cell"], s["size"] = "D", 0.0    # No Trade

signals = [s for s in signals if s["cell"] != "D"]

This is the core decision matrix:

	High VRP (z ≥ 1.0)	Low VRP
+Gamma	Cell A — full size, any structure	Cell C — half size, tight structures
-Gamma	Cell B — half size, defined risk only	Cell D — no trade

Cell A is where the magic happens: dealers dampen moves (suppressing realized vol) while implied vol is elevated. Your short premium position benefits on both sides.

Cell B is the trap that blows up accounts. Premium looks rich, but dealers are amplifying moves against you.

Step 3: Pick the Structure

The VRP response includes strategy_scores — five common premium structures scored 0–100 based on current VRP, skew, term structure, and regime:

for s in signals:
    scores = s["_raw"].get("strategy_scores", {})
    directional = s["_raw"].get("directional", {})

    s["put_vrp"]  = directional.get("downside_vrp", 0)
    s["call_vrp"] = directional.get("upside_vrp", 0)

    # Cell B = defined risk only
    if s["cell"] == "B":
        eligible = {k: v for k, v in scores.items() 
                    if k in ("iron_condor", "jade_lizard")}
    else:
        eligible = scores

    s["best"] = max(eligible, key=eligible.get) if eligible else "none"

Pro tip: The directional object decomposes VRP into put-side vs. call-side. 70–80% of the time, premium is asymmetric. Defaulting to symmetric iron condors leaves edge on the table. If put VRP is 7.4 and call VRP is 4.2, you want put-heavy structures.

Step 4: Set Entry Levels from Dealer Positioning

Now the second API call — /v1/exposure/levels/{symbol} returns key dealer positioning levels:

for s in signals:
    r = requests.get(
        f"{BASE}/v1/exposure/levels/{s['symbol']}", 
        headers=HEADERS
    )
    if r.status_code != 200:
        continue
    lvl = r.json().get("levels", r.json())

    s["put_wall"]  = lvl.get("put_wall", 0)
    s["call_wall"] = lvl.get("call_wall", 0)
    s["max_gamma"] = lvl.get("max_positive_gamma", 0)

Put wall → place short put strikes here (dealers buy at this level = mechanical backstop)
Call wall → place short call strikes here (dealers sell at this level = structural ceiling)
Max gamma → price magnet, ideal straddle center
Gamma flip → the line in the sand. Above = dampened. Below = amplified.

Step 5: Exit Rules (Define Before Entry)

Four non-negotiable rules:

50% profit target. Captures ~85% of expected P&L with ~40% of the variance. The Sharpe improvement is significant.
Gamma flip breach. If spot drops below the flip, your Cell A trade is now Cell B. Cut half or close.
21 DTE time stop. Gamma accelerates in the final 3 weeks. The remaining theta isn't worth the path risk.
VRP inversion. If z-score drops below -0.5, realized vol is beating implied. Close immediately.

for s in signals:
    vrp = s["_raw"].get("vrp", {})
    z    = vrp.get("z_score", 0)
    flip = s["gamma_flip"]
    spot = s["spot"]
    dist = ((spot - flip) / spot * 100) if spot > 0 else 0

    if z < -0.5:
        status = "EXIT — VRP inversion"
    elif dist < 0:
        status = "EXIT — below gamma flip"
    elif dist < 0.5:
        status = "WARNING — near flip"
    else:
        status = "OK"

    print(f"{s['symbol']:<6} z={z:+.2f} dist={dist:+.1f}% → {status}")

The Complete Morning Script

All 5 steps in one runnable file → outputs a trade plan with symbol, cell classification, structure, strikes, and sizing. Full script is in the original article.

Sample output:

══════════════════════════════════════════════════════════════════
  VRP MORNING SCAN
══════════════════════════════════════════════════════════════════

──────────────────────────────────────────────────────────────────
  SPY — Cell A: PREMIUM PARADISE
──────────────────────────────────────────────────────────────────
  VRP z-score:    +1.34  (82nd percentile)
  ATM IV:         18.5%   RV20d: 13.0%   Spread: +5.4
  Put VRP:        +7.4   Call VRP: +4.2
  Gamma regime:   positive_gamma   Flip: $572.50   Distance: +1.4%
  Best structure: iron_condor (score: 85)
  Size:           1.75x standard
  Levels: put_wall=$570  call_wall=$590  max_gamma=$575

What You Need

The VRP endpoint, strategy scores, directional VRP, GEX-conditioned regime data, and term VRP are on the Alpha plan. Per-strike GEX and key levels are free.

If you're building systematic premium-selling workflows, Alpha is where the actionable analytics live — VRP z-scores, harvest scores, strategy scoring, vanna outlook, dealer flow risk, and unlimited API calls to run this scanner across your entire universe every morning without throttling.

Links:

FlashAlpha API Docs
Python SDK (pip install flashalpha)
Full article with Kelly sizing + term VRP
GEX-Conditioned VRP deep dive

Build a GEX Dashboard with Python: Gamma Exposure Monitor in One API Call

tomasz dobrowolski — Mon, 30 Mar 2026 06:05:14 +0000

If you've tried to compute gamma exposure yourself, you know the pain: source options chains, aggregate OI across all expirations, model dealer positioning assumptions, compute dollar gamma per strike, find the flip level, identify walls. That's months of engineering before you display a single bar chart.

A handful of API calls replace all of it.

What the Endpoints Return

Endpoint	Tier	What You Get
`/v1/exposure/gex/{symbol}`	Free	Per-strike GEX with call/put breakdown, OI, volume, OI change
`/v1/exposure/levels/{symbol}`	Free	Gamma flip, call wall, put wall, max gamma strikes, highest OI, 0DTE magnet
`/v1/exposure/summary/{symbol}`	Growth	Net GEX/DEX/VEX/CHEX, regime, interpretation, dealer hedge estimates
`/v1/exposure/dex/{symbol}`	Free	Delta exposure by strike
`/v1/exposure/vex/{symbol}`	Free	Vanna exposure by strike
`/v1/exposure/chex/{symbol}`	Free	Charm exposure by strike

GEX and levels are free tier. You can build a fully functional gamma exposure dashboard without spending anything.

Quick Start

pip install flashalpha

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
gex = fa.gex("SPY")

print(f"Net GEX:    {gex['net_gex']:,.0f}")
print(f"Gamma flip: {gex['gamma_flip']}")
print(f"Price:      {gex['underlying_price']}")
print(f"Strikes:    {len(gex['strikes'])} levels")

# Top 5 strikes by absolute net GEX
top = sorted(gex["strikes"], key=lambda s: abs(s["net_gex"]), reverse=True)[:5]
for s in top:
    print(f"  {s['strike']:>8.1f}  call={s['call_gex']:>12,.0f}  put={s['put_gex']:>12,.0f}  net={s['net_gex']:>12,.0f}")

Or curl:

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

Free tier: 10 req/day, no credit card. Get your key.

What Each Field Means

The GEX response includes per-strike data:

gamma_flip — the strike where net GEX crosses zero. Above it = positive gamma (pinning). Below it = negative gamma (amplification). The single most important level.
net_gex — total net gamma across all strikes. Positive = dealers long gamma overall.
call_gex / put_gex — per-strike gamma from calls (positive) and puts (negative) separately.
call_oi_change / put_oi_change — day-over-day open interest change. Shows where new positions are being built.

The levels response gives you the key price levels:

levels = fa.exposure_levels("SPY")
lvl = levels["levels"]

print(f"Gamma flip:         {lvl['gamma_flip']}")
print(f"Call wall:          {lvl['call_wall']}")          # Resistance
print(f"Put wall:           {lvl['put_wall']}")           # Support
print(f"Max + gamma:        {lvl['max_positive_gamma']}")  # Strongest pin
print(f"Max - gamma:        {lvl['max_negative_gamma']}")  # Strongest amplifier
print(f"Highest OI:         {lvl['highest_oi_strike']}")   # OI magnet
print(f"0DTE magnet:        {lvl['zero_dte_magnet']}")     # Intraday gravity

Call wall = where call gamma concentrates most heavily (resistance). Put wall = where put gamma concentrates (support, but dangerous if it breaks). 0DTE magnet = where same-day options are pulling price during the current session.

Building the Dashboard

1. GEX by Strike Bar Chart

The centerpiece. Each bar = net gamma at that strike. Positive (green) = call-dominated. Negative (red) = put-dominated.

import matplotlib.pyplot as plt

gex = fa.gex("SPY")

strikes = [s["strike"] for s in gex["strikes"]]
net_gex = [s["net_gex"] for s in gex["strikes"]]
colors = ["#16a34a" if g >= 0 else "#dc2626" for g in net_gex]

fig, ax = plt.subplots(figsize=(14, 6))
ax.bar(strikes, net_gex, color=colors, width=0.8)
ax.axvline(gex["underlying_price"], color="#2563eb", linestyle="--", label="Spot")
ax.axvline(gex["gamma_flip"], color="#f59e0b", linestyle="-", linewidth=2, label="Gamma Flip")
ax.set_xlabel("Strike")
ax.set_ylabel("Net GEX ($)")
ax.set_title(f"SPY Gamma Exposure | Net: {gex['net_gex_label']}")
ax.legend()
plt.tight_layout()
plt.savefig("spy_gex.png", dpi=150)

For web dashboards, map the same data to Chart.js, D3.js, or Lightweight Charts. The strikes array is pre-sorted by strike price.

2. Gamma Flip and Regime

The most important number on the dashboard. Display prominently with context:

price = gex["underlying_price"]
flip = gex["gamma_flip"]

regime = "POSITIVE GAMMA" if price > flip else "NEGATIVE GAMMA"
distance = ((price - flip) / price) * 100

print(f"Gamma Flip: {flip}")
print(f"Spot:       {price}")
print(f"Regime:     {regime}")
print(f"Distance:   {distance:+.2f}%")

Color the background green when price is above the flip (expect pinning) and red when below (expect amplification). This one indicator changes your entire trading approach for the day.

3. Key Levels Panel

All key levels in one call. Display as horizontal lines on a price chart or as a compact summary:

levels = fa.exposure_levels("SPY")
lvl = levels["levels"]

key_levels = [
    ("Call Wall (resistance)", lvl["call_wall"]),
    ("Put Wall (support)",     lvl["put_wall"]),
    ("Max + Gamma (pin)",      lvl["max_positive_gamma"]),
    ("Max - Gamma (amplify)",  lvl["max_negative_gamma"]),
    ("Highest OI (magnet)",    lvl["highest_oi_strike"]),
    ("0DTE Magnet (intraday)", lvl["zero_dte_magnet"]),
    ("Gamma Flip",             lvl["gamma_flip"]),
]

for label, value in key_levels:
    print(f"  {label:<28s} {value:>8.1f}")

Call wall and put wall define the likely range. 0DTE magnet is where intraday price gravitates as same-day options decay. These levels update throughout the trading day.

4. Multi-Expiry Breakdown

Filter by expiration to see where GEX concentrates:

expirations = ["2026-03-30", "2026-04-03", "2026-04-17"]

for exp in expirations:
    gex_exp = fa.gex("SPY", expiration=exp)
    total = sum(s["net_gex"] for s in gex_exp["strikes"])
    top = max(gex_exp["strikes"], key=lambda s: abs(s["net_gex"]))
    print(f"{exp}: net_gex={total:>14,.0f}  top_strike={top['strike']}")

This reveals whether GEX is in 0DTE (short-term pinning) or monthly options (structural positioning). A dashboard that only shows aggregate GEX misses this.

5. OI Change Tracking

Where are new positions being built?

gex = fa.gex("SPY")

oi_movers = sorted(
    gex["strikes"],
    key=lambda s: abs(s["call_oi_change"]) + abs(s["put_oi_change"]),
    reverse=True
)[:10]

print("Top OI Movers (day-over-day):")
for s in oi_movers:
    print(f"  {s['strike']:>8.1f}  call_oi={s['call_oi_change']:>+7,d}  put_oi={s['put_oi_change']:>+7,d}")

Large OI increases strengthen a level as a magnet or wall. OI decreases mean the level is losing significance. Track daily to see how the GEX profile evolves.

The Full Exposure Stack: DEX, VEX, CHEX

GEX alone misses three critical forces. All on the free tier:

Metric	Endpoint	What It Measures	Why It Matters
DEX	`/v1/exposure/dex/{symbol}`	Directional dealer exposure	Shows which direction dealer hedging pushes price
VEX	`/v1/exposure/vex/{symbol}`	Vanna exposure (delta sensitivity to IV)	Drives "vol-down, market-up" dynamic. Explains post-FOMC rallies
CHEX	`/v1/exposure/chex/{symbol}`	Charm exposure (delta sensitivity to time)	Explains predictable flows into the close on expiry days

gex = fa.gex("SPY")
dex = fa.dex("SPY")
vex = fa.vex("SPY")
chex = fa.chex("SPY")

print(f"GEX  net: {gex['net_gex']:>14,.0f}  (gamma - vol regime)")
print(f"DEX  net: {dex['net_dex']:>14,.0f}  (delta - direction)")
print(f"VEX  net: {vex['net_vex']:>14,.0f}  (vanna - IV sensitivity)")
print(f"CHEX net: {chex['net_chex']:>14,.0f}  (charm - time decay flow)")

When all four align in one direction, you have the highest-conviction setup. GEX tells you the volatility regime. DEX tells you direction. VEX tells you what happens if IV moves. CHEX tells you which way time alone pushes the market.

Multi-Symbol Scanner

Monitor GEX across your watchlist and flag regime changes:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
symbols = ["SPY", "QQQ", "IWM", "TSLA", "AAPL", "NVDA", "AMD", "META", "AMZN", "MSFT"]

print(f"{'Symbol':<8} {'Price':>8} {'Flip':>8} {'Regime':<10} {'Net GEX':>14} {'Call Wall':>10} {'Put Wall':>10}")
print("-" * 78)

for sym in symbols:
    try:
        gex = fa.gex(sym)
        levels = fa.exposure_levels(sym)
        lvl = levels["levels"]

        price = gex["underlying_price"]
        flip = gex["gamma_flip"]
        regime = "POS GAMMA" if price > flip else "NEG GAMMA"

        print(f"{sym:<8} {price:>8.2f} {flip:>8.1f} {regime:<10} "
              f"{gex['net_gex']:>14,.0f} {lvl['call_wall']:>10.1f} {lvl['put_wall']:>10.1f}")

        if price < flip:
            print(f"  >> WARNING: {sym} in negative gamma - expect amplified moves")

    except Exception as e:
        print(f"{sym:<8} Error: {e}")

Add alerts when a symbol crosses its gamma flip, approaches a wall, or when net GEX flips sign. These regime transitions are the highest-signal events.

MCP Integration for AI Agents

Connect FlashAlpha to Claude, Cursor, or any MCP-compatible agent:

{
  "mcpServers": {
    "flashalpha": {
      "url": "https://lab.flashalpha.com/mcp",
      "headers": {
        "X-Api-Key": "YOUR_KEY"
      }
    }
  }
}

Ask the agent: "What's the gamma flip for SPY?" or "Is TSLA in positive or negative gamma?" or "Build me a multi-symbol GEX scanner." The agent calls the endpoints directly, interprets the data, and presents analysis. The AI becomes the dashboard.

Why Not Compute GEX Yourself?

You can. Here's the shopping list:

Options chain data source ($200-2,500/mo)
OI aggregation across all expirations, handling weeklies/monthlies/quarterlies/LEAPs
Dealer model assumptions (what fraction of OI is dealer-held)
Dollar gamma computation per strike (BSM or better, needs IV, rates, dividends)
Gamma flip detection (interpolate where cumulative net GEX crosses zero)
Key level identification (call walls, put walls, highest OI, 0DTE magnets)
Higher-order Greeks (delta, vanna, charm exposure — each a substantial computation)
Infrastructure to run intraday for your universe

That's 3-6 months of engineering. The exposure endpoints exist so you don't have to.

API Reference

GET /v1/exposure/gex/{symbol}        # Per-strike gamma exposure
GET /v1/exposure/gex/{symbol}?expiration=2026-03-30  # Filter by expiry
GET /v1/exposure/levels/{symbol}     # Key levels (flip, walls, magnets)
GET /v1/exposure/summary/{symbol}    # Regime + interpretation (Growth)
GET /v1/exposure/dex/{symbol}        # Delta exposure
GET /v1/exposure/vex/{symbol}        # Vanna exposure
GET /v1/exposure/chex/{symbol}       # Charm exposure

Headers:
  X-Api-Key: YOUR_KEY

Rate limits:
  Free:   10 req/day
  Basic:  250 req/day
  Growth: 2,500 req/day
  Alpha:  Unlimited

Get API key — free tier, no credit card
Python SDK — pip install flashalpha
Full GEX endpoint docs
GitHub examples
Live GEX tool — free, any ticker, no signup

Related guides:

Build a VRP Dashboard with Python: Volatility Risk Premium Monitor in One API Call

tomasz dobrowolski — Mon, 30 Mar 2026 06:02:49 +0000

If you've ever tried to compute the volatility risk premium yourself, you know the pain: source options chains, compute ATM IV, calculate realized vol across multiple windows, fit a term structure, decompose put vs call wing premiums, condition on dealer positioning, score strategy suitability. That's 3-6 months of engineering before you display a single number on a dashboard.

One API call replaces all of it.

What the Endpoint Returns

GET /v1/vrp/{symbol} returns the full VRP picture in a single JSON response:

Section	What It Tells You
VRP core	ATM IV, realized vol (5d/10d/20d/30d), VRP spread per window, z-score, percentile
Directional	Put-wing vs call-wing IV, downside VRP vs upside VRP
Term structure	VRP by DTE bucket (7d, 14d, 30d) — which expiration is richest
GEX-conditioned	Gamma regime, harvest score (0-1), interpretation
Strategy scores	Short straddle, strangle, iron condor, calendar, jade lizard scored 0-100
Regime	Positive/negative gamma, VRP regime, net GEX, gamma flip
Macro	VIX, VIX 3M, term slope, 10Y yield, HY spread, fed funds
Risk	Dealer flow risk score, warnings array, net harvest score

No manual IV computation. No realized vol calculation. No regime detection logic. Pre-computed and updated throughout the trading day.

Quick Start

pip install flashalpha

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
vrp = fa.vrp("SPY")

print(f"ATM IV:        {vrp['vrp']['atm_iv']:.1f}%")
print(f"20d RV:        {vrp['vrp']['rv_20d']:.1f}%")
print(f"VRP spread:    {vrp['vrp']['vrp_20d']:.1f}%")
print(f"Z-score:       {vrp['vrp']['z_score']:.2f}")
print(f"Percentile:    {vrp['vrp']['percentile']:.0f}th")
print(f"Harvest score: {vrp['net_harvest_score']:.2f}")
print(f"Best strategy: {max(vrp['strategy_scores'], key=lambda k: vrp['strategy_scores'][k] or 0)}")

Or with curl:

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

Free tier: 10 requests/day, no credit card. Get your key.

Building the Dashboard Piece by Piece

1. The VRP Gauge: Rich or Thin?

The z-score tells you how many standard deviations the current VRP is from its 252-day mean. The percentile gives the same information on a 0-100 scale.

vrp_data = vrp['vrp']

if vrp_data['z_score'] > 1.5:
    signal = "RICH"       # Top ~7% of historical observations
    color = "#16a34a"
elif vrp_data['z_score'] > 0.5:
    signal = "MODERATE"
    color = "#ca8a04"
elif vrp_data['z_score'] > -0.5:
    signal = "FAIR"
    color = "#6b7280"
else:
    signal = "THIN"       # Premium compressed, don't sell
    color = "#dc2626"

print(f"VRP Signal: {signal}")
print(f"Z-score: {vrp_data['z_score']:.2f} ({vrp_data['percentile']}th percentile)")

2. Multi-Window Realized Vol

The response includes realized vol across four windows and the VRP spread for each. If VRP is rich at 5d but thin at 30d, the premium is driven by recent calm, not structural richness.

for window in ['5d', '10d', '20d', '30d']:
    iv = vrp_data['atm_iv']
    rv = vrp_data[f'rv_{window}']
    spread = vrp_data[f'vrp_{window}']
    print(f"  {window}: IV {iv:.1f}% - RV {rv:.1f}% = VRP {spread:+.1f}%")

3. Directional Decomposition

Most VRP analysis treats the premium as symmetric. It isn't. The directional object decomposes VRP into put-side and call-side using 25-delta wing IVs.

d = vrp['directional']

print(f"Put wing IV:  {d['put_wing_iv_25d']:.1f}%")
print(f"Call wing IV: {d['call_wing_iv_25d']:.1f}%")
print(f"Downside VRP: {d['downside_vrp']:+.1f}%")
print(f"Upside VRP:   {d['upside_vrp']:+.1f}%")

if d['downside_vrp'] > d['upside_vrp'] + 1.0:
    print("Put side richer - short put spreads or jade lizards")
elif d['upside_vrp'] > d['downside_vrp'] + 1.0:
    print("Call side richer - covered calls or call credit spreads")
else:
    print("Balanced - symmetric structures (straddles, iron condors)")

When put-side VRP is 5% and call-side is 1%, selling an iron condor is wrong because the premium is concentrated on one side. This is what separates a useful VRP dashboard from a basic IV-vs-RV chart.

4. VRP Term Structure

Which expiration has the richest premium per unit of time:

print("VRP Term Structure:")
for bucket in vrp['term_vrp']:
    bar = "█" * int(bucket['vrp'] * 3)
    print(f"  {bucket['dte']:3d} DTE: IV {bucket['iv']:.1f}% - RV {bucket['rv']:.1f}% = VRP {bucket['vrp']:+.1f}%  {bar}")

richest = max(vrp['term_vrp'], key=lambda b: b['vrp'])
print(f"\nRichest bucket: {richest['dte']} DTE ({richest['vrp']:+.1f}% VRP)")

5. Strategy Scores

Five premium-selling structures scored 0-100 based on current VRP, gamma regime, directional skew, and macro context:

scores = vrp['strategy_scores']
ranked = sorted(scores.items(), key=lambda x: x[1] or 0, reverse=True)

print("Strategy Suitability:")
for name, score in ranked:
    if score is not None:
        bar = "█" * (score // 5)
        print(f"  {name:20s} {score:3d}/100  {bar}")

Iron condor scores high when VRP is elevated and balanced, gamma is positive, and VIX term structure is in contango. Jade lizard scores high when put-side VRP is disproportionately rich. Calendar spreads score high when the term VRP curve is steep. The API does the scoring logic. Your dashboard just renders it.

6. The Harvest Score: Should You Sell Premium?

This is the most important number. It combines VRP richness with the gamma regime into a single 0-1 composite.

gex = vrp['gex_conditioned']
regime = vrp['regime']

print(f"Gamma regime:   {regime['gamma']}")
print(f"VRP regime:     {regime['vrp_regime']}")
print(f"Harvest score:  {gex['harvest_score']:.2f}")
print(f"Interpretation: {gex['interpretation']}")
print(f"Net GEX:        ${regime['net_gex']:,.0f}")
print(f"Gamma flip:     {regime['gamma_flip']}")

if gex['harvest_score'] > 0.7:
    print("FAVORABLE for premium selling")
elif gex['harvest_score'] > 0.4:
    print("ACCEPTABLE with caution")
else:
    print("UNFAVORABLE - consider sitting out")

Elevated VRP in a negative gamma environment is a trap. The premium is rich because the risk is real. The harvest score catches this. TSLA might show a z-score of 2.14 (93rd percentile) but a harvest score of only 0.52 because dealers are short gamma. SPY might show a lower z-score of 1.42 but a harvest score of 0.78 because dealers are long gamma and pinning price. Your dashboard should surface this distinction.

7. Risk Flags

print(f"Dealer flow risk: {vrp['dealer_flow_risk']}/100")

if vrp['warnings']:
    for w in vrp['warnings']:
        print(f"  ⚠ {w}")
else:
    print("No active warnings")

Warnings include negative_gamma, FOMC, earnings, and low_liquidity. Display prominently. They override any positive VRP signal.

Multi-Symbol Scanner

Scan your universe and sort by harvest score:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
universe = ["SPY", "QQQ", "IWM", "TSLA", "NVDA", "AAPL", "AMZN", "META", "GOOGL", "MSFT"]

results = []
for sym in universe:
    try:
        v = fa.vrp(sym)
        results.append({
            'symbol': sym,
            'z_score': v['vrp']['z_score'],
            'percentile': v['vrp']['percentile'],
            'harvest_score': v['net_harvest_score'],
            'best_strategy': max(v['strategy_scores'], key=lambda k: v['strategy_scores'][k] or 0),
            'warnings': v['warnings'],
            'dealer_risk': v['dealer_flow_risk']
        })
    except Exception as e:
        print(f"Skipping {sym}: {e}")

results.sort(key=lambda r: r['harvest_score'], reverse=True)

print(f"\n{'Symbol':>6}  {'Harvest':>8}  {'Z-Score':>8}  {'Pctl':>5}  {'Risk':>5}  {'Strategy':>20}")
print("-" * 65)
for r in results:
    warn = " ⚠" if r['warnings'] else ""
    print(f"{r['symbol']:>6}  {r['harvest_score']:>8.2f}  {r['z_score']:>+8.2f}  {r['percentile']:>4.0f}%  {r['dealer_risk']:>5}  {r['best_strategy']:>20}{warn}")

Example output:

Symbol   Harvest   Z-Score   Pctl   Risk              Strategy
-----------------------------------------------------------------
   SPY      0.78     +1.42    84%     22          iron_condor
  AAPL      0.71     +0.34    58%     18          iron_condor
   QQQ      0.65     +0.88    71%     35       short_strangle
  NVDA      0.61     +1.67    88%     41         jade_lizard
  TSLA      0.52     +2.14    93%     58       short_strangle ⚠

TSLA has the richest raw VRP but the lowest harvest score. The API already factored in the dangerous gamma regime. Your dashboard shows what matters: not just "is premium rich" but "is it safe to harvest."

Using with AI Agents (MCP)

FlashAlpha provides an MCP server. Connect it to Claude, Cursor, or any MCP-compatible agent:

{
  "mcpServers": {
    "flashalpha": {
      "url": "https://lab.flashalpha.com/mcp",
      "headers": {
        "X-Api-Key": "YOUR_KEY"
      }
    }
  }
}

The agent can query VRP data, interpret z-scores and strategy scores, and generate trade recommendations grounded in live data. The AI becomes the dashboard.

Why Not Compute VRP Yourself?

You can. Here's what it takes:

Options chain data source ($200-2,500/mo)
ATM IV calculation with skew and forward price handling
Realized vol across 4 windows with split/dividend adjustment
Rolling z-score and percentile (252-day lookback)
Directional decomposition (25-delta wing extraction)
Term structure fitting across DTE buckets
Gamma regime conditioning (net GEX, dealer positioning) — itself a major project
Strategy scoring model (VRP + skew + gamma + macro + event risk)
Infrastructure to run intraday for your universe

That's 3-6 months of engineering. The VRP endpoint exists so you don't have to.

API Reference

GET /v1/vrp/{symbol}

Headers:
  X-Api-Key: YOUR_KEY

Response: Full VRP analysis (see field table above)

Rate limits:
  Free:   10 req/day
  Basic:  250 req/day
  Growth: 2,500 req/day
  Alpha:  Unlimited

The VRP endpoint is available on all plans including the free tier for basic VRP data. Full strategy scores, GEX conditioning, and macro context require Growth or Alpha.

Get API key — free tier, no credit card
Python SDK — pip install flashalpha
Full VRP endpoint docs
GitHub examples

Related guides:

Build a 0DTE Options Dashboard with One API Call

tomasz dobrowolski — Sun, 29 Mar 2026 19:43:45 +0000

If you've tried building a 0DTE options dashboard from raw market data, you know the pain: intraday chain snapshots, Greeks recomputation every few minutes, pin risk models, gamma aggregation, and infrastructure that needs to run reliably during market hours.

One endpoint replaces all of it: GET /v1/exposure/zero-dte/{symbol}. Pin risk scoring, expected move, gamma acceleration, dealer hedging scenarios, vol context, flow data, and per-strike breakdown. One JSON response.

Why 0DTE Is a Different Engineering Problem

Longer-dated options are stable. Greeks change slowly, hedging flows are predictable, and polling every 15-30 minutes is fine. 0DTE breaks every one of these assumptions.

Property	7DTE	0DTE (Morning)	0DTE (Last Hour)
ATM Gamma	1x (baseline)	2-3x	8-15x
Theta Decay / Hour	Slow, linear	Moderate	4-5x morning rate
Expected Move	Stable	Shrinks 30-40% by 2 PM	Shrinks 70-80% by 3:30 PM
Pin Risk	Negligible	Building	Dominant
Dealer Hedging per $1 Move	Moderate	Large	Massive

Everything changes fast. A 0DTE dashboard showing stale data is worse than no dashboard. You need an API that recomputes continuously through the session.

Quick Start

Install

pip install flashalpha

Python SDK

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
dte = fa.zero_dte("SPY")

print(f"Gamma regime: {dte['regime']['label']}")
print(f"Expected move: +/-{dte['expected_move']['expected_move_pct']:.2f}%")
print(f"Pin score: {dte['pin_risk']['pin_score']}/100")
print(f"Magnet strike: {dte['pin_risk']['magnet_strike']}")

cURL

curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/zero-dte/SPY"

# Custom strike range (default 3% around spot)
curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/exposure/zero-dte/SPY?strike_range=0.05"

JavaScript

const resp = await fetch(
  "https://lab.flashalpha.com/v1/exposure/zero-dte/SPY",
  { headers: { "X-Api-Key": "YOUR_API_KEY" } }
);
const dte = await resp.json();

console.log(`Regime: ${dte.regime.label}`);
console.log(`Pin score: ${dte.pin_risk.pin_score}`);
console.log(`Expected move: ${dte.expected_move.expected_move_pct}%`);

What You Get Back

One call returns everything for a complete 0DTE monitor:

Section	Key Fields	What It Tells You
Regime	`label`, `gamma_flip`, `net_gex`	Positive gamma (mean-revert) or negative (trending)?
Expected Move	`expected_move_pct`, `upper_bound`, `lower_bound`	Real-time intraday range, shrinks through the day
Pin Risk	`pin_score` (0-100), `magnet_strike`, `oi_concentration_top3_pct`	Is price pinned? Where's the magnet?
Hedging	`spot_up_half_pct`, `spot_down_half_pct`, `spot_up_1pct`, `spot_down_1pct`	Dealer share counts & notional at ±0.5% and ±1% moves
Decay	`theta_per_hour_remaining`, `gamma_acceleration`, `charm_description`	How fast is premium bleeding? Gamma accel vs 7DTE
Vol Context	`iv_ratio_0dte_7dte`, `vanna_interpretation`	Is 0DTE IV cheap or expensive vs term structure?
Flow	`net_call_premium`, `net_put_premium`, `put_call_ratio`	Directional sentiment from order flow
Per-Strike	Array of `{strike, call_gex, put_gex, net_gex, call_oi, put_oi, call_volume, put_volume}`	Strike-by-strike breakdown for heatmaps
Exposures	`pct_of_total_gex`, `zero_dte_net_gex`, `full_chain_net_gex`	How much of total GEX comes from 0DTE?

Building the Dashboard Panels

A. Expected Move Gauge

The expected move shrinks in real-time through the day. At 9:30 AM it might be ±0.65%. By 2 PM it's ±0.34%. By 3:45 PM it could be ±0.08%.

em = dte["expected_move"]
hours_left = dte["time_to_close_hours"]

print(f"Expected Move: +/-{em['expected_move_pct']:.2f}%")
print(f"Range: {em['lower_bound']:.2f} - {em['upper_bound']:.2f}")
print(f"Time to Close: {hours_left:.1f} hours")

# Normalize for gauge visualization
gauge_fill = em["expected_move_pct"] / 0.65  # morning baseline

B. Pin Risk Score

The pin score (0-100) composites OI concentration, magnet proximity, time remaining, and gamma magnitude. Above 70 with less than 2 hours to close is a strong pinning signal.

pin = dte["pin_risk"]

print(f"Pin Score: {pin['pin_score']}/100")
print(f"Magnet Strike: {pin['magnet_strike']}")
print(f"Distance: {pin['distance_to_magnet_pct']:.2f}%")
print(f"Top 3 OI Concentration: {pin['oi_concentration_top3_pct']}%")

if pin["pin_score"] > 70 and hours_left < 2:
    print("HIGH PIN RISK - price gravitates to magnet strike")

C. Gamma Acceleration Zone

The gamma_acceleration field shows how much more gamma 0DTE contracts carry vs equivalent 7DTE strikes. Above 3x, hedging flows start to dominate the tape.

decay = dte["decay"]
regime = dte["regime"]

print(f"Gamma Acceleration: {decay['gamma_acceleration']}x vs 7DTE")
print(f"Charm: {decay['charm_description']}")

if regime["label"] == "positive_gamma" and decay["gamma_acceleration"] > 3:
    print("Strong mean-reversion - dealers absorb moves aggressively")
elif regime["label"] == "negative_gamma" and decay["gamma_acceleration"] > 3:
    print("DANGER ZONE - dealer hedging amplifies moves, breakout risk elevated")

D. Dealer Hedging Estimates

What happens if SPY moves ±0.5% or ±1%? Share counts and notional values for each scenario.

hedging = dte["hedging"]

scenarios = [
    ("SPY +0.5%", hedging["spot_up_half_pct"]),
    ("SPY -0.5%", hedging["spot_down_half_pct"]),
    ("SPY +1.0%", hedging["spot_up_1pct"]),
    ("SPY -1.0%", hedging["spot_down_1pct"]),
]

print(f"{'Scenario':<12} {'Dir':<6} {'Shares':>12} {'Notional':>16}")
print("-" * 50)
for label, h in scenarios:
    print(f"{label:<12} {h['direction']:<6} "
          f"{h['dealer_shares_to_trade']:>12,} "
          f"${h['notional_usd']:>14,.0f}")

In positive gamma, dealers sell rallies and buy dips (dampening). In negative gamma, they do the opposite (amplifying). The notional values tell you how much liquidity dealers add or remove at each price level.

E. Per-Strike GEX Heatmap

The per_strike array gives you everything for a heatmap or bar chart:

for strike in dte["per_strike"]:
    bar_len = int(abs(strike["net_gex"]) / 10_000_000)
    sign = "+" if strike["net_gex"] > 0 else "-"
    print(f"{strike['strike']:.0f} | {sign}{'█' * bar_len} | "
          f"Net GEX: ${strike['net_gex']:,.0f}")

F. Vol Context

Compare 0DTE IV against the term structure:

vol = dte["vol_context"]
print(f"0DTE/7DTE IV Ratio: {vol['iv_ratio_0dte_7dte']:.2f}")
print(f"Vanna: {vol['vanna_interpretation']}")

if vol["iv_ratio_0dte_7dte"] > 1.0:
    print("Event premium - 0DTE IV elevated vs term structure")

Below 1.0 is normal. Above 1.0 means 0DTE has event premium (FOMC, CPI, intraday stress). Above 1.15 means 0DTE premium selling has edge.

Intraday Polling Pattern

Poll more frequently as expiration approaches:

import time
from datetime import datetime, time as dtime
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

def get_poll_interval(hours_left):
    if hours_left > 4:   return 900   # 15 min (morning)
    elif hours_left > 2: return 600   # 10 min (midday)
    elif hours_left > 1: return 300   # 5 min (afternoon)
    else:                return 180   # 3 min (last hour)

def is_market_hours():
    now = datetime.now()
    return dtime(9, 30) <= now.time() <= dtime(16, 0)

while is_market_hours():
    dte = fa.zero_dte("SPY")
    hours_left = dte["time_to_close_hours"]

    # Update your dashboard panels here
    update_expected_move(dte["expected_move"])
    update_pin_risk(dte["pin_risk"])
    update_gamma_zone(dte["decay"], dte["regime"])
    update_hedging_chart(dte["hedging"])
    update_gex_heatmap(dte["per_strike"])

    # Alerts
    if dte["pin_risk"]["pin_score"] > 70 and hours_left < 2:
        send_alert(f"HIGH PIN: magnet at {dte['pin_risk']['magnet_strike']}")

    if (dte["regime"]["label"] == "negative_gamma"
        and dte["exposures"]["pct_of_total_gex"] > 50):
        send_alert("NEGATIVE GAMMA DOMINANT: breakout risk elevated")

    time.sleep(get_poll_interval(hours_left))

At this cadence you'll use 60-80 requests per symbol per day. Well within Growth's 2,500 daily limit. Scan 8 symbols and you're still under 640/day.

Multi-Symbol 0DTE Scanner

Scan multiple symbols and rank by pin risk, gamma acceleration, or expected move:

from flashalpha import FlashAlpha
import concurrent.futures

fa = FlashAlpha("YOUR_API_KEY")
symbols = ["SPY", "QQQ", "IWM", "AAPL", "TSLA", "NVDA", "AMZN", "META"]

def scan(symbol):
    try:
        dte = fa.zero_dte(symbol)
        if dte.get("no_zero_dte"):
            return None
        return {
            "symbol": symbol,
            "pin": dte["pin_risk"]["pin_score"],
            "gamma_x": dte["decay"]["gamma_acceleration"],
            "em": dte["expected_move"]["expected_move_pct"],
            "regime": dte["regime"]["label"],
            "pct": dte["exposures"]["pct_of_total_gex"],
            "magnet": dte["pin_risk"]["magnet_strike"]
        }
    except Exception:
        return None

with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(filter(None, pool.map(scan, symbols)))

results.sort(key=lambda x: x["pin"], reverse=True)

print(f"{'Sym':<6} {'Pin':>4} {'GamX':>5} {'EM%':>6} {'Regime':<16} {'0DTE%':>6} {'Magnet':>8}")
print("-" * 55)
for r in results:
    print(f"{r['symbol']:<6} {r['pin']:>4} {r['gamma_x']:>4.1f}x "
          f"{r['em']:>5.2f}% {r['regime']:<16} "
          f"{r['pct']:>5.1f}% {r['magnet']:>8.0f}")

MCP Server for AI Agents

If you're building AI agents that need 0DTE context, FlashAlpha provides an MCP server. Configure it in Claude, Cursor, or any MCP-compatible tool:

{
  "mcpServers": {
    "flashalpha": {
      "url": "https://lab.flashalpha.com/mcp",
      "headers": {
        "X-Api-Key": "YOUR_API_KEY"
      }
    }
  }
}

Once connected, your agent can query conversationally: "What's the pin risk for SPY right now?" or "Scan SPY, QQQ, and IWM for the highest 0DTE pin score." The MCP server exposes the same endpoints as REST. The agent gets structured JSON, interprets it, and responds with actionable analysis.

Supporting Endpoints

Levels (Free tier)

levels = fa.exposure_levels("SPY")
print(f"Gamma Flip: {levels['levels']['gamma_flip']}")
print(f"Call Wall: {levels['levels']['call_wall']}")
print(f"Put Wall: {levels['levels']['put_wall']}")
print(f"0DTE Magnet: {levels['levels']['zero_dte_magnet']}")

Overlay these on your price chart. The zero_dte_magnet is the strike with the highest 0DTE GEX, acting as an intraday attractor.

GEX with Expiration Filter (Free tier)

# 0DTE GEX only, without needing the full zero-dte endpoint
gex = fa.gex("SPY", expiration="2026-03-29")

for strike in gex["strikes"]:
    print(f"{strike['strike']}: net_gex=${strike['net_gex']:,.0f}")

This gives you per-strike 0DTE gamma on the free tier. You don't get pin risk, expected move, or hedging scenarios (those require Growth), but it's enough to see where 0DTE gamma is concentrated.

Why Not Build It Yourself?

Building this from raw data requires solving five problems simultaneously:

Intraday chain snapshots. Real-time chain data costs $500-2,000/mo from exchange vendors. Most free sources give end-of-day only.

Greeks recomputation. Every snapshot requires recalculating delta, gamma, theta, vanna, charm for every strike. For SPY with 100+ 0DTE strikes, that's thousands of BSM evaluations per snapshot.

Pin risk models. Not just max pain. Composites OI concentration, magnet proximity, time remaining, gamma magnitude, and historical pinning behavior.

Gamma aggregation. Summing exposure across strikes with dealer positioning assumptions that need validation against actual market behavior.

Infrastructure. Must run reliably during market hours. Exchange outages, stale quotes, cache invalidation, latency management.

The zero-dte endpoint does all of this server-side. You get JSON. You build the UI.

Pricing

Plan	Price	Daily Requests	0DTE Access
Free	$0	10	GEX with expiration filter, levels
Growth	$299/mo	2,500	Full zero-dte endpoint + all exposure endpoints
Alpha	$1,199/mo annual	Unlimited	+ SVI surfaces, advanced vol, zero cache

Free tier lets you prototype with filtered GEX. Growth unlocks the full zero-dte endpoint with pin risk, expected move, hedging scenarios, and decay analytics.

Get API access — free tier, no credit card
Python SDK: pip install flashalpha
Full 0DTE endpoint docs
GitHub examples

Need a custom computation or field added? Email support@flashalpha.com. You're talking to the engineer who built it. Turnaround is hours, not weeks.

Volatility Risk Premium: The Practical Guide to Trading the Most Persistent Edge in Options

tomasz dobrowolski — Fri, 27 Mar 2026 16:03:15 +0000

The volatility risk premium is the systematic spread between implied volatility and subsequent realized volatility. In plain terms: options are consistently priced as if the underlying will move more than it actually does. The difference between what the market expects (IV) and what actually happens (RV) is the VRP.

The math is straightforward:

VRP = IV(ATM) − RV(window)

If SPY's ATM implied volatility is 20% and the 20-day realized volatility is 16%, the VRP is 4 percentage points. That 4% is what you're being paid — annualized — to sell options. It's the compensation you receive for bearing the risk that realized vol could spike above implied vol.

Why Does This Premium Exist?

The VRP isn't a market inefficiency — it's a structural feature. It exists because of a persistent supply-demand imbalance in the options market:

Institutional hedgers systematically buy protection. Portfolio managers, pension funds, and risk-constrained institutions are required to hedge. They buy puts and pay for collars regardless of whether vol is cheap or expensive. This demand is price-insensitive — they're buying insurance, not speculating on vol.
Insurance buyers overpay by design. Just as homeowners pay more for fire insurance than the actuarial cost of fires, options buyers pay more than the expected payout. The premium compensates sellers for bearing tail risk — the chance that realized vol could be 2x or 3x implied vol on any given day.
The market prices in worst-case scenarios that usually don't materialize. IV reflects the distribution of possible outcomes, weighted by fear. Realized vol reflects what actually happened. The gap between fear and reality is, on average, positive.
Leverage constraints create asymmetric demand. Institutions that want downside protection must buy it in the options market — they can't simply hold more cash or reduce leverage fast enough. This structural demand floor keeps IV elevated relative to RV.

This Is Not a Free Lunch

The VRP is often described as "picking up pennies in front of a steamroller," and there's truth to that characterization. The premium exists precisely because selling volatility has fat-tail risk. You collect small, consistent premiums on most days, then occasionally face outsized losses when realized vol explodes past implied vol.

Historical data tells the story:

VRP is positive roughly 70–75% of trading days across the S&P 500 over the last 30 years.
The average VRP is 2–4 percentage points (IV minus subsequent RV), depending on the window.
The worst drawdowns come in clusters. VRP doesn't go negative gradually — it inverts violently during market stress (2008, 2018 Volmageddon, 2020 COVID, 2022 rate shock). These are the events that destroy undisciplined sellers.
Long-term, systematic VRP harvesting has a positive Sharpe ratio — typically 0.3 to 0.6 depending on implementation — but with meaningful max drawdowns.

The edge is real. The question is whether you're measuring it before you trade, or just assuming it's there.

Why Most Retail Traders Already Trade VRP (Badly)

If you sell covered calls, you're harvesting VRP. If you sell iron condors, you're harvesting VRP. If you write credit spreads, cash-secured puts, or strangles, you're harvesting VRP. Nearly every premium-selling strategy is, at its core, a bet that IV will overstate realized vol.

The problem isn't the strategy — it's the execution. Most retail premium sellers make three critical errors:

Error 1: Selling Premium Without Checking if VRP Is Positive

If you sell a 30-DTE iron condor on SPY every month regardless of conditions, you're assuming VRP is always positive. It isn't. When IV is 18% and 20-day realized vol is 22%, you're selling insurance below cost. You're paying the market for the privilege of taking their risk.

This happens more often than you'd think — especially after sustained trending moves where realized vol spikes but IV hasn't caught up, or during extended low-vol regimes where IV compresses to levels that barely exceed RV.

Error 2: Using Symmetric Strategies When VRP Is Directional

The "total" VRP is an average across puts and calls. But the risk premium on the put side (crash protection) is structurally different from the call side. Selling an iron condor assumes the VRP is equal on both sides. It rarely is. If put VRP is 5% and call VRP is 1%, your iron condor is mostly a put trade with a call leg that's adding risk for minimal premium.

Error 3: Ignoring the Regime

VRP can be 4% — solidly positive — while dealers are in negative gamma and positioned to amplify any downturn. The premium looks attractive, but the tail risk is elevated because dealer hedging will worsen any sell-off. Measuring VRP without accounting for dealer positioning is like checking the weather forecast but not the flood warnings.

The fix for all three errors is the same: measure before you trade.

Before & After — The Same Trade, Different Outcomes

To make this concrete, here's the same trade decision made two ways.

Without VRP Data (How Most Retail Traders Do It)

It's March 15, 2026. SPY is at $572. ATM IV for the 30-DTE cycle is 19.8%. A 10-wide iron condor ($560/$570 puts, $580/$590 calls) collects $2.85 in premium. The trader thinks: "IV is close to 20%, premiums look fat, theta is on my side. I'll sell the condor."

What the trader doesn't know:

20-day realized vol is 23.1% — IV is BELOW realized vol. VRP is −3.3%. The trader is selling insurance below cost.
VRP z-score is −1.4 — deeply negative. This is the 8th percentile of the last year. Premium hasn't been this cheap in months.
Dealers are in negative gamma. The gamma flip is at $578, and SPY is below it. Any sell-off will be amplified by dealer hedging flows.
Put-side VRP is −4.8%. The put spread (which carries most of the condor's risk) has the worst risk/reward of any component.

Over the next week, SPY drops to $561. The iron condor loses $6.80 against $2.85 collected — a 2.4:1 loss ratio. Dealers amplified the move exactly as their positioning predicted. The VRP was negative the entire time — there was never an edge.

With VRP Data (Systematic Approach)

Same day, same setup. The trader pulls the VRP endpoint before placing the trade:

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

print(f"VRP 20d: {data['vrp_spreads']['vrp_20d']:+.2f}%")   # -3.30%
print(f"Z-score: {data['z_score']:+.2f}")                     # -1.42
print(f"Regime:  {data['gex_regime']['label']}")               # negative_gamma
print(f"Put VRP: {data['directional_vrp']['put_vrp_20d']:+.2f}%")  # -4.80%

The data is unambiguous: VRP is deeply negative, z-score is in the 8th percentile, regime is negative gamma, put VRP is worse than total VRP. Every signal says do not sell premium.

The trader passes. No trade. Keeps capital for a better day. A week later, after the sell-off exhausts itself, VRP flips to +4.2% with a z-score of +1.8 in positive gamma. Now the trader sells — with the data confirming the edge exists.

Same trader, same market, same strategy — different outcome because of one API call.

Measuring VRP — The Five Windows

VRP isn't a single number. Because realized vol depends on the lookback window, you get a different VRP reading for each time horizon. The FlashAlpha VRP endpoint returns five simultaneous windows, each telling you something different about the current vol environment.

Window	Calculation	Character	Best For
5-day VRP	ATM IV − RV5	Noisy, fast-reacting, captures intraday regime shifts	Same-week premium selling, 0DTE context
10-day VRP	ATM IV − RV10	Short-term signal with moderate smoothing	Weekly expiration strategies, 5–10 DTE trades
20-day VRP	ATM IV − RV20	The "standard" window, most commonly referenced	Monthly premium selling, iron condors, strangles
30-day VRP	ATM IV − RV30	Smoothed, less reactive to recent outliers	30–45 DTE strategies, structural positioning
60-day VRP	ATM IV − RV60	Structural VRP, captures the macro vol regime	Longer-dated trades, calendar spreads, portfolio-level decisions

Here's how to pull all five VRP spreads for any symbol:

import requests

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

vrp = data["vrp_spreads"]
print("=== SPY Volatility Risk Premium ===")
print(f"ATM IV:     {data['atm_iv']:.1f}%")
print(f"5-day VRP:  {vrp['vrp_5d']:+.2f}%  (RV5 = {vrp['rv_5d']:.1f}%)")
print(f"10-day VRP: {vrp['vrp_10d']:+.2f}%  (RV10 = {vrp['rv_10d']:.1f}%)")
print(f"20-day VRP: {vrp['vrp_20d']:+.2f}%  (RV20 = {vrp['rv_20d']:.1f}%)")
print(f"30-day VRP: {vrp['vrp_30d']:+.2f}%  (RV30 = {vrp['rv_30d']:.1f}%)")
print(f"60-day VRP: {vrp['vrp_60d']:+.2f}%  (RV60 = {vrp['rv_60d']:.1f}%)")

Reading the VRP Spread

VRP Level (20d)	Interpretation	Action
> 6%	Extremely elevated — IV is pricing in far more vol than realized	Aggressive premium selling. Wider strikes for larger credit.
3% to 6%	Healthy — solid compensation for selling vol	Standard premium selling. Full-size positions.
1% to 3%	Thin — you're being paid, but not much	Reduce size. Favor defined-risk structures. Be selective.
0% to 1%	Marginal — barely any edge	Minimal exposure or sit out.
< 0%	Negative — IV understates realized vol	Do not sell premium. Consider buying vol.

The key insight is that not every positive VRP reading is equally tradeable. A VRP of 1.5% is technically positive, but after commissions, slippage, and the risk of a tail event, the expected value is marginal. Save your capital for the 3%+ readings where the edge is clear.

Z-Score and Percentile — Is VRP Rich or Cheap Right Now?

Raw VRP tells you the spread between IV and RV. But "4% VRP" means something very different in a low-vol regime (where 4% is unusually wide) versus a high-vol regime (where 4% might be compressed). You need context.

That's what the z-score and percentile provide, calculated over a rolling 252-day (one year) lookback:

z = (VRP_today − μ_VRP,252d) / σ_VRP,252d

The z-score tells you how many standard deviations today's VRP is from its trailing mean. The percentile tells you where today's VRP falls in the distribution of the last 252 readings.

import requests

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

z = data["z_score"]
pct = data["percentile"]
vrp_20d = data["vrp_spreads"]["vrp_20d"]

print(f"VRP (20d): {vrp_20d:+.2f}%")
print(f"Z-score:   {z:+.2f}")
print(f"Percentile: {pct:.0f}th")

# Decision framework
if z > 1.5:
    print("SIGNAL: VRP is significantly elevated vs history.")
    print("ACTION: Aggressive premium selling. Full size. Wider strikes.")
elif z > 0.5:
    print("SIGNAL: VRP is above average. Healthy edge.")
    print("ACTION: Standard premium selling. Normal position sizing.")
elif z > -0.5:
    print("SIGNAL: VRP is near average. Marginal edge.")
    print("ACTION: Reduce size. Tighter strikes. Be selective.")
elif z > -1.0:
    print("SIGNAL: VRP is compressed. Thin or no edge.")
    print("ACTION: Minimal exposure. Consider sitting out.")
else:
    print("SIGNAL: VRP is deeply compressed or negative. No edge.")
    print("ACTION: Do not sell premium. Consider buying vol.")

Z-Score Decision Matrix

Z-Score Range	Percentile (approx)	Interpretation	Position Sizing
> 2.0	97th+	Extreme VRP expansion — rare, usually post-event	Maximum size. This is the fat pitch.
1.5 to 2.0	90th–97th	Significantly rich — aggressive selling window	75–100% of max size
0.5 to 1.5	70th–90th	Above-average VRP — solid conditions	50–75% of max size
−0.5 to 0.5	30th–70th	Average VRP — marginal edge, be selective	25–50% of max size
−1.0 to −0.5	15th–30th	Compressed VRP — thin or no edge	0–25% of max size
< −1.0	Below 15th	Negative or deeply compressed — selling vol is −EV	Zero. Do not sell premium.

The z-score is the single most important filter for VRP trading. A positive VRP with a z-score of −0.8 is telling you that while IV still exceeds RV, the spread is unusually narrow compared to recent history — the risk/reward has deteriorated. Wait for better conditions.

Directional VRP — The Put Side vs Call Side

Total VRP is an average. It masks the real structure of the premium, which is almost always asymmetric. The VRP endpoint decomposes VRP into put-side and call-side components, revealing where the actual edge sits.

Why Directional VRP Matters

Put options carry a structural premium over calls because institutional hedgers are persistent net buyers of downside protection. This creates a skew premium — the put side of the volatility surface is consistently richer than the call side. When you decompose VRP directionally, you typically see:

Put VRP is larger than call VRP in most environments. The crash protection premium inflates put IV above what downside realized vol justifies. This is the norm — roughly 80% of the time.
Call VRP is smaller but more consistent. Because call-side hedging demand is lower, call IV is closer to "fair value." The premium is thinner but more stable.
The spread between put VRP and call VRP tells you where the edge is. If put VRP is 5.2% and call VRP is 1.1%, the edge is overwhelmingly on the put side.

import requests

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

directional = data["directional_vrp"]
put_vrp = directional["put_vrp_20d"]
call_vrp = directional["call_vrp_20d"]
skew_spread = directional["skew_adjusted_spread"]

print(f"Put-side VRP (20d):  {put_vrp:+.2f}%")
print(f"Call-side VRP (20d): {call_vrp:+.2f}%")
print(f"Skew spread:         {skew_spread:+.2f}%")

# Directional decision
if put_vrp > call_vrp * 2:
    print("\nEDGE: Heavily skewed to puts.")
    print("STRATEGY: Sell put credit spreads or naked puts.")
    print("AVOID: Iron condors (call side adds risk for minimal premium).")
elif call_vrp > put_vrp * 1.5:
    print("\nEDGE: Unusual call-side premium. Check for earnings/events.")
    print("STRATEGY: Sell call credit spreads or covered calls.")
elif abs(put_vrp - call_vrp) < 1.0:
    print("\nEDGE: Roughly symmetric. Iron condors are appropriate.")
    print("STRATEGY: Sell strangles or iron condors.")
else:
    print(f"\nEDGE: Moderately skewed to {'puts' if put_vrp > call_vrp else 'calls'}.")
    print("STRATEGY: Skew your position — larger size on the richer side.")

When Call VRP Exceeds Put VRP

This is rare in broad market indices but does happen in specific situations:

Meme stock euphoria. When a stock experiences extreme upside momentum, call buyers overpay for upside exposure.
Pre-earnings on high-momentum names. Heavy call buying can inflate call IV relative to realized upside vol.
Short squeeze setups. When short interest is high and calls are being used to force a squeeze, call-side IV can become detached from fundamental vol.

Why Iron Condors Are Often Suboptimal

Iron condors assume symmetric VRP — equal edge on both sides. In reality, if put VRP is 4.8% and call VRP is 0.9%, your iron condor is essentially a put credit spread that happens to also have a call spread attached. The call spread adds margin requirement and tail risk but contributes almost no premium.

The directional VRP data lets you make a better decision: sell puts when put VRP is rich, sell calls when call VRP is rich, and only use iron condors when the skew spread is narrow.

GEX-Conditioned Regime — When VRP Is Safe vs Dangerous

VRP tells you the size of the premium. It doesn't tell you about the risk environment. A 4% VRP in a positive gamma regime (dealers dampening moves) is a fundamentally different trade than a 4% VRP in a negative gamma regime (dealers amplifying moves).

VRP harvesting works best when dealer positioning suppresses the very tail events that make selling vol dangerous.

How GEX Regime Affects VRP Trades

Regime	VRP Level	Assessment	Action
Positive gamma	High (z > 1.0)	Best case — fat premium AND dealer dampening	Full size. Aggressive premium selling.
Positive gamma	Low (z < 0)	Safe but thin — dealers are dampening but premium is marginal	Reduce size.
Negative gamma	High (z > 1.0)	Tempting but dangerous — premium is there but tail risk is elevated	Reduce size 50%. Defined risk only.
Negative gamma	Low (z < 0)	Worst case — no premium AND amplified risk	Sit out entirely.

import requests

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

vrp_20d = data["vrp_spreads"]["vrp_20d"]
z = data["z_score"]
regime = data["gex_regime"]

label = regime["label"]
gamma_flip = regime["gamma_flip"]
net_gex = regime["net_gex"]
vanna = regime["vanna_interpretation"]

print(f"VRP (20d): {vrp_20d:+.2f}% | Z-score: {z:+.2f}")
print(f"Regime: {label} | Gamma flip: ${gamma_flip}")
print(f"Net GEX: {net_gex:,.0f} | Vanna: {vanna}")

# GEX-conditioned decision matrix
if label == "positive_gamma" and z > 1.0:
    print("\n*** GREEN LIGHT — Full size premium selling ***")
    print("Dealers are dampening moves AND VRP is elevated.")
elif label == "positive_gamma" and z > 0:
    print("\n*** YELLOW — Standard premium selling ***")
    print("Regime is supportive but VRP is only moderately elevated.")
elif label == "negative_gamma" and z > 1.0:
    print("\n*** CAUTION — Reduce size, widen strikes ***")
    print("VRP is attractive but dealers will amplify any adverse move.")
elif label == "negative_gamma":
    print("\n*** RED — Do not sell premium ***")
    print("No edge AND elevated tail risk. Sit this one out.")

The Gamma Flip and VRP Timing

The gamma_flip level tells you the price at which the regime changes from positive to negative gamma (or vice versa). This is critical for VRP trade management:

If price is well above the gamma flip (positive gamma territory), your short vol position has the structural wind at its back.
If price is near the gamma flip, the regime could flip at any time. Size down and set tighter stops.
If price crosses below the gamma flip into negative gamma, consider closing short vol positions regardless of P&L.

Vanna and Charm Effects on VRP

In a positive gamma + positive vanna environment, any IV compression (which is what you're betting on when you sell premium) also creates supportive dealer buying flows. Your trade has a built-in tailwind.

In a negative gamma + negative vanna environment, any IV expansion creates additional selling pressure from dealer hedging. Your short vol position faces compounding headwinds.

Strategy Suitability Scores

Knowing that VRP is positive and the regime is supportive answers whether to sell premium. But which structure? A short straddle and an iron condor are both short vol, but they behave very differently in different environments.

The VRP endpoint returns strategy suitability scores (0–100) for six common structures, computed from the current VRP level, directional skew, GEX regime, realized vol, and term structure.

import requests

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

scores = data["strategy_scores"]

print("=== Strategy Suitability Scores (0-100) ===")
for strategy, score in sorted(scores.items(), key=lambda x: -x[1]):
    bar = "#" * (score // 5)
    print(f"{strategy:20s} {score:3d}  {bar}")

What Each Score Means

Strategy	Best When	Score Drivers
Short straddle	VRP is high, regime is positive gamma, RV is low	Requires wide VRP AND low realized vol. High scores (80+) are the fat pitch.
Short strangle	VRP is moderate-to-high, positive gamma	Similar to straddle but more forgiving. Scores above 60 are good.
Iron condor	VRP is moderate, you need defined risk, skew is symmetric	Favored when put/call VRP are similar.
Put credit spread	Put VRP >> call VRP, put skew is steep	Scores highest when directional VRP is heavily skewed to puts.
Calendar spread	VRP term structure is steep (front-month richest)	Highest when front-month IV is significantly elevated relative to back-month.
Jade lizard	Call VRP is thin, put VRP is fat	Short put + short call spread — eliminates upside risk.

The strategy scores save you from the most common structural mistake: using the same strategy every time. An iron condor trader who checks the scores might discover that today, a put credit spread scores 82 while the iron condor scores 41 — because put VRP is rich but call VRP is nonexistent.

Dealer Flow Risk — The Hidden Risk in VRP Trades

Most VRP traders think about risk in terms of realized volatility: "If RV spikes above IV, I lose." That's true but incomplete. The more immediate risk is mechanical dealer flow — the forced buying and selling that dealers do to maintain delta neutrality.

How Dealer Positioning Creates Non-Linear Risk

When dealers are net short gamma, every point of market movement forces dealers to hedge in the same direction as the move. If SPY drops $2 and dealers are short gamma, they must sell shares to maintain their hedge. That selling pushes SPY lower, triggering more hedging, which pushes it lower still. This is the gamma feedback loop that turns orderly sell-offs into flash crashes.

For a short vol position, this feedback loop is devastating. A 1% decline in positive gamma might stay at 1%. The same decline in negative gamma can cascade to 2–3% as dealer hedging amplifies the move.

import requests

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

risk = data["dealer_risk"]

print("=== Dealer Flow Risk Assessment ===")
print(f"Gamma regime:    {risk['gamma_regime']}")
print(f"Vanna direction: {risk['vanna_direction']}")
print(f"Hedging flow:    {risk['hedging_flow_magnitude']}")
print(f"Risk level:      {risk['risk_level']}")

if risk["risk_level"] == "elevated":
    print("\nWARNING: Dealer positioning creates amplified tail risk.")
    print("Reduce size by 50% and use defined-risk structures only.")
elif risk["risk_level"] == "high":
    print("\nDANGER: Dealer positioning is actively hostile to short vol.")
    print("Do not sell premium. Consider hedging existing positions.")
else:
    print("\nDealer risk is contained. Proceed with normal sizing.")

Integrating Dealer Risk Into Position Sizing

The simplest approach is a multiplier system:

Dealer risk "low": 100% of intended size. Dealers are dampening moves.
Dealer risk "moderate": 75% of intended size. Some hedging pressure exists.
Dealer risk "elevated": 50% of intended size. Material amplification risk.
Dealer risk "high": 0% of intended size. Do not enter new short vol trades.

This is the edge that separates systematic VRP traders from retail premium sellers. Both might see a 4% VRP and think "sell." The systematic trader also checks dealer risk and discovers that negative gamma + vanna-driven selling pressure means the tail distribution is 2x wider than normal. Same premium, radically different risk.

Building a Systematic VRP Strategy

Here's a complete daily VRP workflow that integrates everything — VRP spreads, z-score, directional analysis, GEX regime, strategy selection, and position sizing.

import requests
from datetime import datetime

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

def get_vrp(symbol):
    """Pull VRP data for a symbol."""
    resp = requests.get(
        f"{BASE}/v1/vrp/{symbol}",
        headers={"X-Api-Key": API_KEY}
    )
    return resp.json()

def assess_trade(symbol):
    """Full VRP trade assessment."""
    data = get_vrp(symbol)

    vrp = data["vrp_spreads"]
    z = data["z_score"]
    pct = data["percentile"]
    directional = data["directional_vrp"]
    regime = data["gex_regime"]
    scores = data["strategy_scores"]
    risk = data["dealer_risk"]

    print(f"\n{'='*50}")
    print(f"  VRP Assessment: {symbol}")
    print(f"  {datetime.now().strftime('%Y-%m-%d %H:%M')}")
    print(f"{'='*50}")

    # Step 1: Is VRP positive and significant?
    print(f"\n1. VRP SPREAD")
    print(f"   20-day VRP: {vrp['vrp_20d']:+.2f}%")
    print(f"   Z-score:    {z:+.2f} ({pct:.0f}th percentile)")

    if z < -0.5:
        print("   VERDICT: VRP is too thin. No trade today.")
        return None

    # Step 2: What's the regime?
    print(f"\n2. GEX REGIME")
    print(f"   Regime: {regime['label']}")
    print(f"   Gamma flip: ${regime['gamma_flip']}")

    if regime["label"] == "negative_gamma" and z < 0.5:
        print("   VERDICT: Negative gamma + thin VRP. No trade.")
        return None

    # Step 3: Dealer risk check
    print(f"\n3. DEALER RISK")
    print(f"   Risk level: {risk['risk_level']}")

    size_multiplier = {
        "low": 1.0, "moderate": 0.75,
        "elevated": 0.5, "high": 0.0
    }.get(risk["risk_level"], 0.5)

    if size_multiplier == 0:
        print("   VERDICT: Dealer risk too high. No trade.")
        return None

    # Step 4: Directional analysis
    print(f"\n4. DIRECTIONAL VRP")
    put_vrp = directional["put_vrp_20d"]
    call_vrp = directional["call_vrp_20d"]
    print(f"   Put VRP:  {put_vrp:+.2f}%")
    print(f"   Call VRP: {call_vrp:+.2f}%")

    # Step 5: Strategy selection
    print(f"\n5. STRATEGY SCORES")
    for strat, score in sorted(scores.items(), key=lambda x: -x[1])[:3]:
        print(f"   {strat:20s} {score:3d}/100")

    best = max(scores, key=scores.get)
    best_score = scores[best]

    # Step 6: Position sizing
    base_size = 1.0
    z_adj = min(z / 2.0, 1.0)
    final_size = base_size * z_adj * size_multiplier

    print(f"\n6. POSITION SIZING")
    print(f"   Base:       {base_size:.0%}")
    print(f"   Z-adj:      {z_adj:.0%}")
    print(f"   Risk adj:   {size_multiplier:.0%}")
    print(f"   Final size: {final_size:.0%}")

    print(f"\n{'='*50}")
    print(f"  RECOMMENDATION: {best} at {final_size:.0%} size")
    print(f"  Score: {best_score}/100 | VRP: {vrp['vrp_20d']:+.2f}%")
    print(f"{'='*50}")

    return {
        "symbol": symbol,
        "strategy": best,
        "score": best_score,
        "size": final_size,
        "vrp": vrp["vrp_20d"],
        "z_score": z,
        "regime": regime["label"]
    }

# Run assessment for a watchlist
watchlist = ["SPY", "QQQ", "IWM", "AAPL", "TSLA"]
results = []

for sym in watchlist:
    try:
        result = assess_trade(sym)
        if result:
            results.append(result)
    except Exception as e:
        print(f"Error processing {sym}: {e}")

# Summary
if results:
    print(f"\n\n{'='*50}")
    print("  TODAY'S TRADEABLE VRP OPPORTUNITIES")
    print(f"{'='*50}")
    for r in sorted(results, key=lambda x: -x["score"]):
        print(f"  {r['symbol']:5s} | {r['strategy']:20s} | "
              f"Score: {r['score']:3d} | Size: {r['size']:.0%} | "
              f"VRP: {r['vrp']:+.2f}% | {r['regime']}")
else:
    print("\nNo tradeable VRP opportunities today. Sit tight.")

Using Historical VRP for Backtesting

import requests
import pandas as pd

resp = requests.get(
    "https://lab.flashalpha.com/v1/vrp/SPY/history",
    headers={"X-Api-Key": "YOUR_API_KEY"},
    params={"start": "2024-01-01", "end": "2025-12-31"}
)
history = resp.json()

df = pd.DataFrame(history["data"])
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")

# Basic stats
print(f"Days with positive VRP: {(df['vrp_20d'] > 0).mean():.1%}")
print(f"Mean VRP: {df['vrp_20d'].mean():.2f}%")
print(f"Median VRP: {df['vrp_20d'].median():.2f}%")

# Win rate by z-score bucket
for low, high, label in [
    (1.5, 999, "z > 1.5"),
    (0.5, 1.5, "0.5 < z < 1.5"),
    (-0.5, 0.5, "-0.5 < z < 0.5"),
    (-999, -0.5, "z < -0.5")
]:
    mask = (df["z_score"] >= low) & (df["z_score"] < high)
    subset = df[mask]
    if len(subset) > 0:
        win_rate = (subset["vrp_20d"] > 0).mean()
        avg_vrp = subset["vrp_20d"].mean()
        print(f"  {label:15s}: {len(subset):4d} days, "
              f"win rate {win_rate:.1%}, avg VRP {avg_vrp:+.2f}%")

Risk Management Rules

No VRP strategy works without discipline on the risk side:

Max portfolio allocation to short vol: Never allocate more than 15–20% of portfolio notional across all names. Concentration kills.
Per-position max loss: For undefined risk (straddles, strangles), set a hard stop at 2x the credit received. For defined risk, the max loss is already defined by the wings.
Regime-based exit: If the GEX regime flips from positive to negative gamma while you're in a trade, close 50% immediately regardless of P&L.
VRP inversion exit: If the VRP z-score drops below −1.0, close all short vol positions.
Calendar-based rules: Reduce size by 50% going into FOMC, CPI, and NFP. Eliminate short vol entirely on the day of the event unless VRP z-score is above 2.0.
Correlation awareness: If you're short vol on SPY, QQQ, and IWM simultaneously, you have one trade, not three. Size as if it's a single position.

Common Mistakes in VRP Trading

Mistake 1: Selling Premium When VRP Is Negative

VRP is negative roughly 25–30% of trading days, and those days often cluster during the exact periods when selling premium feels most tempting. The fix: check VRP before every trade. If vrp_20d is negative or the z-score is below −0.5, don't sell.

Mistake 2: Ignoring Dealer Positioning

A 4% VRP in positive gamma has a fundamentally different risk profile from a 4% VRP in negative gamma. Always check gex_regime and dealer_risk. In negative gamma, cut size by at least 50%.

Mistake 3: Not Adjusting for Term Structure

If front-month VRP is 2% but 60-day VRP is 5%, selling weekly options is suboptimal. Compare VRP across all five windows and sell the richest part of the curve.

Mistake 4: Over-Sizing Because VRP "Seems Safe"

VRP is persistent, but it has fat tails. Size based on worst-case loss, not average return. Cap maximum position size at a level where a 3-sigma adverse move doesn't threaten the portfolio.

Mistake 5: Using Symmetric Strategies When VRP Is Directional

If put VRP is 5% and call VRP is 0.5%, an iron condor is 90% a put trade. Check directional_vrp — if the skew spread is wider than 2%, tilt your structure toward the richer side.

Get the Data

The VRP endpoint returns everything covered in this guide in a single API call:

VRP spreads across 5 windows (5d, 10d, 20d, 30d, 60d)
Z-score and percentile vs trailing 252-day history
Directional VRP — put-side and call-side decomposition
VRP term structure
GEX-conditioned regime — gamma label, flip level, net GEX, vanna
Strategy suitability scores for six common structures
Dealer flow risk — gamma regime, vanna direction, hedging flow magnitude
Macro context — VIX level, VIX term structure, event calendar proximity
Daily history via /v1/vrp/{symbol}/history for backtesting

👉 API Docs | Playground | Pricing

Options Analytics Comparison: FlashAlpha vs SpotGamma vs Unusual Whales — Which Fits Your Stack?

tomasz dobrowolski — Thu, 26 Mar 2026 13:07:17 +0000

SpotGamma, Unusual Whales, and FlashAlpha all serve the options analytics space but they solve fundamentally different problems. SpotGamma essentially created the retail GEX analysis category. Unusual Whales built the largest options flow community in retail trading. FlashAlpha is the newest entrant, focused on API-first computed analytics.

Pick the wrong one and you'll be screenshotting charts when you need an API, or drowning in raw flow data when you need computed exposure levels. This comparison should help.

Full disclosure: I built FlashAlpha. I'll call out where each platform wins, including where mine falls short.

The TL;DR

	SpotGamma	Unusual Whales	FlashAlpha
Primary model	Dashboard + expert analysis	Dashboard + API	API-first
Core strength	GEX levels + daily commentary	Options flow + dark pool + breadth	Computed exposure analytics + vol surfaces
API access	No public API	Yes, 100+ endpoints, MCP server	Yes, REST + Python SDK
Free tier	7-day trial	Limited free dashboard	5 req/day, no time limit, no credit card
Established	~5 years, pioneered retail GEX	~5 years, massive community	New (2026), founder-operated
Support model	Tiered support + community Q&A	Community Discord + support tickets	Direct access to the engineer who built it
Best for	Discretionary traders wanting expert daily analysis	Flow traders, data scientists, broad market intelligence	Quant developers building systems on exposure/vol data

What Each Platform Actually Does

SpotGamma — The Pioneer of Retail GEX Analysis

SpotGamma pioneered making gamma exposure accessible to retail traders. Founded by Brent Kochuba, a former derivatives broker and portfolio manager with 20+ years of experience, SpotGamma has built a strong track record proving that their GEX-based levels work as intraday support and resistance.

You get daily key levels (gamma flip, call wall, put wall) for major indices and 3,500+ stocks, twice-daily Founder's Notes with expert analysis and market context, real-time indicators (HIRO), a volatility dashboard, and an S&P 500 heatmap (TRACE). The platform integrates with TradingView, NinjaTrader, ThinkorSwim, Bookmap, Sierra Chart, eSignal, and others.

Strengths:

The Founder's Notes are genuinely useful. If you're a discretionary trader who wants an experienced derivatives professional to interpret the GEX landscape every morning, SpotGamma is hard to beat. The daily levels have years of track record behind them. The chart platform integrations mean you can overlay levels directly where you trade without switching tools. The educational content is strong and helps traders understand the mechanics behind the data.

Limitations:

There is no public API or programmatic access to the data. If you want to build automated systems, scanners, or bots using SpotGamma's levels, you can't. The data lives in the dashboard and chart integrations. For developers building automated systems, this is the fundamental constraint. The platform is also more expensive than the alternatives at the entry level since there's no free tier beyond a 7-day trial.

Support is through a help center and subscriber Q&A sessions. You won't get custom computations or endpoint modifications regardless of your plan.

Pricing: Standard ~$89/mo (~$67/mo annual, indices only), Pro ~$129/mo (~$97/mo annual, adds 3,500+ stocks), Alpha ~$299/mo (~$224/mo annual, adds HIRO real-time indicator + TRACE heatmap). All plans include a 7-day free trial. Verify current prices at spotgamma.com as they change periodically.

Unusual Whales — The Broadest Data Platform

Unusual Whales started as an options flow tracker and has grown into one of the most comprehensive market data platforms available to retail and professional traders. Their community is massive (large Twitter/X following, active Discord, Substack newsletter) and notable organizations like Public and Perplexity use their data.

The API has 100+ endpoints covering options flow, dark pool trades, congressional trading (politician portfolio tracking), institutional holdings (13F filings), insider transactions, earnings calendars, crypto whale transactions, ETF flows, news headlines, market-wide analytics, and more. They recently added an MCP server for AI agent integration, Kafka streaming for real-time feeds, and WebSocket support.

Strengths:

Breadth is unmatched. No other platform in this price range gives you congressional trading, dark pool flow, institutional holdings, options flow, insider transactions, AND market analytics through a single API. The 100+ endpoint count is real and well-documented with an OpenAPI spec. The MCP server is forward-thinking for the AI/vibe coding wave. The dashboard is polished with strong flow visualization, net flow charts, and 0DTE flow tracking. The community and brand recognition are significant advantages that newer platforms can't replicate easily.

Limitations:

UW's core strength is telling you WHAT traded: flow, volume, sweeps, blocks, unusual activity. It's less focused on telling you WHY prices move mechanically. They have some Greek exposure endpoints, but deep exposure analytics (per-strike dealer gamma with regime classification, SVI-calibrated vol surfaces, second-order exposure aggregation like vanna and charm exposure) aren't the primary focus.

The developer experience is functional but without SDK-level ergonomics. You're writing raw HTTP requests against well-documented endpoints. Most experienced developers won't mind this, but it adds friction compared to a dedicated SDK with typed exceptions and retry logic.

At their scale (thousands of users, 100+ endpoints), support is necessarily standardized. Feature requests go through a public roadmap. If you need a specific computation or custom field that doesn't exist in their API, you're waiting for it to be prioritized alongside everyone else's requests.

Pricing: Dashboard starts at ~$50/mo. API is separately priced with multiple tiers (recently increased by $25-50 per tier in mid-2025). Historical option trades data is $250/mo additional. Enterprise pricing on request. Verify current prices at unusualwhales.com/pricing as they updated recently.

FlashAlpha — API-First Computed Analytics

Full disclosure: I built FlashAlpha.

FlashAlpha is an API-first platform focused on pre-computed options analytics. Instead of giving you raw option chains or flow data, FlashAlpha returns computed exposure analytics: per-strike gamma exposure (GEX), delta exposure (DEX), vanna exposure (VEX), charm exposure (CHEX), SVI-calibrated volatility surfaces, full BSM Greeks through third order, volatility risk premium analysis, and key levels (gamma flip, call/put walls, max pain) for 6,000+ US equities and ETFs.

Strengths:

The computed analytics are the differentiator. One API call returns per-strike dollar gamma, net GEX, gamma flip, call wall, put wall, and regime classification. You don't compute anything, you don't maintain fitting code, you don't need a separate data feed. The Python SDK (pip install flashalpha) wraps everything with typed exceptions, automatic retries, and pass-through responses.

For quant teams, the Alpha plan includes raw SVI parameters per expiry, total variance surface grids, butterfly/calendar arbitrage detection, variance swap fair values, and vanna/charm/volga/speed surfaces. One API call replaces thousands of lines of in-house vol surface infrastructure.

The free tier (5 req/day, no credit card, no time limit) lets you prototype before committing.

Because FlashAlpha is founder-operated, you talk directly to the person who built the compute infrastructure. If you need a custom field added to an endpoint, a specific computation for your workflow, or help debugging an integration, you're not filing a support ticket into a queue. Response time is measured in hours, not business days. Several current customers have had custom fields added to endpoints within days of requesting them. This level of responsiveness is structurally impossible at larger platforms with thousands of users and tiered support teams. If FlashAlpha doesn't compute something you need, ask. If it's feasible, it ships fast.

Limitations:

No options flow data. If you want to see what traded (sweeps, blocks, unusual activity, dark pool), FlashAlpha doesn't provide it. No congressional trading, no institutional holdings, no insider transactions, no news. The platform is narrow: exposure analytics and volatility only.

No chart platform integrations. There's no TradingView plugin, no NinjaTrader overlay. It's API and web tools only. If you trade on a charting platform and want levels overlaid, SpotGamma has much better integrations today.

The platform is new (launched 2026). SpotGamma and Unusual Whales have years of track record, large communities, established educational content, and proven reliability through multiple market regimes. FlashAlpha doesn't have that history yet. The community is small. There's no expert daily commentary, no educational course library, no large Discord community of active traders sharing setups. If you value community and learning alongside the data, the incumbents offer substantially more.

The founder-operated model is both a strength and a risk. You get fast support and custom work now, but it also means the platform depends on one person. Larger platforms have teams, redundancy, and operational maturity that a solo-founder operation doesn't.

Some low-liquidity tickers in the 6,000+ coverage universe may return sparse data when options open interest is thin. The analytics are only as good as the underlying options activity.

No mobile app. No email alerts or notification system (you'd build your own on top of the API). No portfolio tracking.

Pricing: Free $0 (5 req/day), Basic $49/mo (100 req/day), Growth $299/mo (2,500 req/day, adds 0DTE + volatility), Alpha $1,199/mo annual (unlimited, SVI surfaces, zero cache, direct support).

Head-to-Head: Six Use Cases

1. "I want to check GEX levels before the open"

SpotGamma wins if you want expert interpretation. The Founder's Notes tell you what the levels mean in today's specific market context, backed by years of experience. This is the use case SpotGamma was built for.

FlashAlpha if you want to pull levels into your own script or dashboard programmatically.

Unusual Whales has some exposure endpoints but this isn't their primary focus.

2. "I'm building a trading bot that uses dealer positioning"

FlashAlpha is purpose-built for this. API-first, Python SDK, typed exceptions, structured JSON.

Unusual Whales is possible with their API but you'd be working with flow data rather than pre-computed exposure analytics. Different signal, more computation on your side to derive positioning.

SpotGamma doesn't offer programmatic access, so automated systems using their data aren't possible.

3. "I want to track unusual options activity and dark pool trades"

Unusual Whales wins clearly. This is their core product and nobody else in this comparison comes close. Flow feed, dark pool, sweeps, blocks, net flow, sector flow, congressional trading, insider transactions.

SpotGamma has some flow tools (TAPE) but it's secondary to GEX analysis.

FlashAlpha doesn't offer flow data.

4. "I need SVI vol surfaces and arbitrage detection for my pricing models"

FlashAlpha is the only option here. Raw SVI parameters, total variance grids, butterfly/calendar arb checks, variance swap fair values, greeks surfaces. One API call.

SpotGamma has a volatility dashboard for visual analysis but no API access to surface parameters.

Unusual Whales has volatility data (IV, IV rank, skew) but not SVI-calibrated surfaces or static arbitrage detection.

5. "I want the broadest market data from one provider"

Unusual Whales wins. Options flow + dark pool + congressional + institutional + insider + earnings + crypto + ETF flows + news + market analytics. 100+ endpoints. Nothing else in this comparison matches that breadth.

FlashAlpha is narrow: exposure analytics and volatility only.

SpotGamma is narrow: GEX/positioning analysis only, delivered via dashboard.

6. "I need a custom computation that doesn't exist in any standard API"

FlashAlpha wins. You email the founder, explain what you need, and if it's feasible it ships within days. Custom fields on existing endpoints, new aggregation methods, specific output formats for your pipeline. This is the advantage of working with a small, founder-operated platform.

Unusual Whales and SpotGamma have standardized product roadmaps driven by their broader user base. Custom work for individual users isn't their operating model, which is understandable at their scale.

The Developer Experience

SpotGamma

SpotGamma is a dashboard product with chart platform integrations, not a developer tool. It integrates with TradingView, NinjaTrader, and others via plugins, which is its own form of integration, but it's point-and-click configuration, not code. For traders who live in charting platforms, this works well. For developers who need data in their own systems, SpotGamma isn't designed for that use case.

Unusual Whales

import requests

headers = {"Authorization": "Bearer YOUR_KEY"}
resp = requests.get(
    "https://api.unusualwhales.com/api/stock/SPY/option-contracts",
    headers=headers
)
data = resp.json()

Well-documented API with OpenAPI spec, MCP server for AI integration, Kafka streaming, and WebSocket support. The endpoint coverage is impressive (100+) and clearly structured. The developer experience is solid "raw API": good docs, clear patterns, but you handle retries, error parsing, and response mapping yourself. The MCP server is a differentiator for AI agent workflows that neither of the other platforms currently matches.

FlashAlpha

from flashalpha import FlashAlpha, RateLimitError, TierRestrictedError

fa = FlashAlpha("YOUR_KEY")

gex = fa.gex("SPY")
print(f"Net GEX: ${gex['net_gex']:,.0f}")
print(f"Regime: {gex['regime']}")

levels = fa.exposure_levels("SPY")
print(f"Gamma flip: {levels['levels']['gamma_flip']}")

try:
    zdte = fa.zero_dte("SPY")
except TierRestrictedError as e:
    print(f"Requires {e.required_plan}")

Official Python SDK with typed exceptions, automatic retries, zero dependencies beyond requests. Response fields match the API docs exactly. The developer experience is polished but the platform is narrower in scope than Unusual Whales and newer with less battle-testing.

Integration support is direct. If you hit an issue, you're not reading through a knowledge base hoping to find your edge case. You're talking to the person who wrote the code. For complex integrations (feeding exposure data into ML pipelines, custom aggregation across tickers, integration with proprietary trading systems), this direct line to the engineer matters more than documentation.

The Support Experience

This is worth calling out separately because it's a meaningful difference when you're building production systems.

SpotGamma: Support center, subscriber Q&A sessions with the founder, educational courses. Strong for learning and understanding the data. Not designed for "I need this specific field added to the response."

Unusual Whales: Discord community, support tickets, Substack with walkthroughs. The community is a genuine asset for learning and troubleshooting. At their scale, feature requests are prioritized across thousands of users, so individual custom work isn't the model.

FlashAlpha: You email the founder. He reads it that day. If you need a custom computation, a new field, or help with a tricky integration, the turnaround is hours to days, not weeks. The tradeoff: there's no large community to learn from, no course library, and the founder-operated model means less redundancy. But if what you care about is "can I get exactly the data I need in the format I need it," no larger platform can match the responsiveness of a founder who controls the entire stack.

Pricing Comparison

Tier	SpotGamma	Unusual Whales	FlashAlpha
Free / Trial	7-day trial	Limited free dashboard	Free tier, 10 req/day, no time limit
Entry	~$89/mo (indices only)	~$50/mo (dashboard)	$49/mo (100 req/day, 6,000+ tickers)
Mid	~$129/mo (adds stocks)	API tiers vary	$299/mo (2,500 req/day, 0DTE + vol)
Top	~$299/mo (HIRO + TRACE)	Enterprise (custom)	$1,199/mo annual (unlimited, SVI, direct support)
Historical data	Not available via API	$250/mo (full market tape)	Coming soon (Alpha plan)
Custom work	Not available	Enterprise only	Available on all paid plans

Note: SpotGamma and Unusual Whales competitor prices are approximate and should be verified on their respective pricing pages. Both adjust pricing periodically.

When to Use Each

Use SpotGamma if you're a discretionary trader who wants expert analysis delivered daily. You want someone with 20+ years of derivatives experience interpreting the GEX landscape for you. You trade on charting platforms and want levels integrated directly. You value a proven track record, educational content, and community over programmatic access.

Use Unusual Whales if you need the broadest market data coverage from one provider. You want flow data, dark pool, congressional trading, and institutional holdings through a single API. You're building a multi-signal model that needs diverse data sources. You value a large active community, strong brand, and the widest feature set available to retail traders.

Use FlashAlpha if you're a developer building automated systems on top of options market structure data. You need pre-computed exposure analytics (GEX/DEX/VEX/CHEX) and volatility surfaces via API with a Python SDK. You want a free tier to prototype before committing. You value direct access to the engineer who built the system and the ability to request custom computations that ship fast. You're comfortable with a newer, founder-operated platform that trades track record and community for deeper computed analytics and faster iteration.

Use FlashAlpha + Unusual Whales together for the most complete picture: FlashAlpha for computed exposure and vol surfaces (the "why" behind price movement) and Unusual Whales for flow and dark pool (the "what" that's actually trading). The two platforms cover different dimensions of options market intelligence and don't overlap much.

Use SpotGamma + FlashAlpha together if you want expert daily analysis from SpotGamma for your discretionary trading AND programmatic access to exposure data from FlashAlpha for your automated systems or custom dashboards.

Try It Yourself

FlashAlpha: flashalpha.com/pricing — free tier, no credit card. pip install flashalpha.

SpotGamma: spotgamma.com — 7-day free trial on all plans.

Unusual Whales: unusualwhales.com/pricing — free dashboard, paid API tiers.

The right platform depends on your use case, not on which one is "best." A discretionary trader who never writes code would be wasting money on FlashAlpha. A quant developer who needs per-strike exposure data via API would be frustrated with SpotGamma. A data scientist building broad market models would find FlashAlpha too narrow and SpotGamma too closed.

Know what you need, then pick accordingly.

FlashAlpha Python SDK: Open-Source Tools for Options Analytics

tomasz dobrowolski — Thu, 26 Mar 2026 12:51:45 +0000

Building real-time options analytics from scratch is a serious engineering problem. You need an options data feed ($500-5,000/mo), Greeks computation with American exercise and dividend adjustments, exposure aggregation across thousands of strikes, infrastructure to run during market hours, and ongoing maintenance as 0DTE volumes evolve.

FlashAlpha eliminates all of that. One API key, one SDK, one line of code. Five open-source GitHub repos give you working code to learn from, modify, and deploy.

Getting Started in 60 Seconds

pip install flashalpha

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Gamma exposure for SPY
gex = fa.gex("SPY")
print(f"Net GEX: ${gex['net_gex']:,.0f}")
print(f"Gamma flip: {gex['gamma_flip']}")
print(f"Regime: {'Positive - mean reverting' if gex['net_gex'] > 0 else 'Negative - trending'}")

No HTTP setup, no headers, no JSON parsing. The SDK handles auth, retries on transient failures, and raises typed exceptions for every error condition.

The key levels endpoint returns the five structural levels that define dealer positioning:

levels = fa.exposure_levels("SPY")
lvl = levels["levels"]

print(f"Gamma flip:          {lvl['gamma_flip']}")
print(f"Call wall:           {lvl['call_wall']}")
print(f"Put wall:            {lvl['put_wall']}")
print(f"Max positive gamma:  {lvl['max_positive_gamma']}")
print(f"Max negative gamma:  {lvl['max_negative_gamma']}")
print(f"0DTE magnet:         {lvl['zero_dte_magnet']}")

These are structural levels created by billions of dollars of mechanical dealer hedging flow, not chart patterns.

Get your API key: flashalpha.com/pricing — free tier, 10 req/day, no credit card.

SDK Architecture

Principle	Detail
Zero dependencies	Only `requests`. No framework lock-in.
Typed exceptions	`AuthenticationError`, `TierRestrictedError`, `RateLimitError`, `NotFoundError`
Automatic retries	Exponential backoff on 5xx and timeouts
Pass-through responses	Field names match the API docs exactly

Complete Method Reference

Category	Methods	Min. Plan
Exposure analytics	`gex()`, `dex()`, `vex()`, `chex()`, `exposure_levels()`, `exposure_summary()`, `narrative()`	Free / Growth
0DTE analytics	`zero_dte()`	Growth
Market data	`stock_quote()`, `option_quote()`, `stock_summary()`, `surface()`	Free / Growth
Historical data	`historical_stock_quote()`, `historical_option_quote()`	Free
Pricing & greeks	`greeks()`, `iv()`, `kelly()`	Free / Growth
Volatility	`volatility()`, `adv_volatility()`	Growth / Alpha
Reference	`tickers()`, `options()`, `symbols()`, `account()`, `health()`	Free

Error Handling

from flashalpha import (
    FlashAlpha,
    AuthenticationError,    # 401 - bad or missing API key
    TierRestrictedError,    # 403 - endpoint requires higher plan
    NotFoundError,          # 404 - ticker not found
    RateLimitError,         # 429 - daily quota exceeded
)

fa = FlashAlpha("YOUR_API_KEY")

def get_full_analysis(symbol):
    result = {"symbol": symbol}

    try:
        result["gex"] = fa.exposure_levels(symbol)
    except NotFoundError:
        print(f"{symbol}: not found - skipping")
        return None
    except RateLimitError as e:
        print(f"Rate limited - retry after {e.retry_after}s")
        return None

    # 0DTE requires Growth - handle gracefully
    try:
        result["zero_dte"] = fa.zero_dte(symbol)
    except TierRestrictedError as e:
        print(f"0DTE requires {e.required_plan} (you have {e.current_plan})")
        result["zero_dte"] = None

    return result

This pattern — try the call, catch the specific exception, continue with what you have — is the recommended way to build multi-endpoint workflows.

Build a GEX Dashboard — Multi-Symbol Scanner

Repo: github.com/FlashAlpha-lab/gex-explained

When net GEX is positive, dealers buy dips and sell rallies — stabilizing price. When negative, they amplify moves. This scanner checks your entire watchlist:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
watchlist = ["SPY", "QQQ", "TSLA", "NVDA", "AAPL", "AMZN", "META", "AMD"]

print(f"{'Symbol':<8} {'Net GEX':>12} {'Regime':<12} {'Flip':>10} {'Call Wall':>11} {'Put Wall':>10}")
print("-" * 73)

for symbol in watchlist:
    try:
        levels = fa.exposure_levels(symbol)
        summary = fa.exposure_summary(symbol)
        lvl = levels["levels"]

        regime = "POSITIVE" if summary["net_gex"] > 0 else "NEGATIVE"

        print(f"{symbol:<8} ${summary['net_gex']:>11,.0f} {regime:<12} "
              f"{lvl['gamma_flip']:>10} {lvl['call_wall']:>11} {lvl['put_wall']:>10}")

        if regime == "NEGATIVE":
            print(f"  >> WARNING: {symbol} in negative gamma - expect amplified moves")
        if lvl.get("zero_dte_magnet"):
            print(f"  >> 0DTE magnet at {lvl['zero_dte_magnet']} - watch for pin into close")

    except Exception as e:
        print(f"{symbol:<8} Error: {e}")

This 25-line script replaces a Bloomberg terminal's GEX screen. Run it before the open to know which symbols are safe to sell premium and which are dangerous.

What each level means:

Gamma flip — the most important level. Above it, dealers stabilize. Below it, dealers amplify.
Call wall — highest call gamma. Resistance. Dealers sell into rallies here.
Put wall — highest put gamma. Support, but dangerous. Break below triggers cascading selling.
0DTE magnet — strongest gravitational pull from zero-day options. Dominant in the last 2 hours.

0DTE Morning Pre-Flight

Repo: github.com/FlashAlpha-lab/0dte-options-analytics

Zero-day options are now 40%+ of SPY volume. Gamma is 2-10x higher than weeklies. The zero_dte() endpoint packs everything into one call:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
zdte = fa.zero_dte("SPY")

# Regime
regime = zdte["regime"]
print(f"Regime:        {regime['label']}")
print(f"Gamma flip:    {regime['gamma_flip']}")

# Pin risk
pin = zdte["pin_risk"]
print(f"Pin score:     {pin['pin_score']}/100")
print(f"Magnet strike: ${pin['magnet_strike']}")

# Expected move
em = zdte["expected_move"]
print(f"Implied 1SD:   +-${em['implied_1sd_dollars']:.2f}")
print(f"Straddle:      ${em['straddle_price']:.2f}")

# Theta decay
decay = zdte["decay"]
print(f"Theta/hr:      ${decay['theta_per_hour_remaining']:.2f}")
print(f"Gamma accel:   {decay['gamma_acceleration']:.4f}")

# Vol context
vol = zdte["vol_context"]
print(f"0DTE IV:       {vol['zero_dte_atm_iv']:.1f}%")
print(f"7DTE IV:       {vol['seven_dte_atm_iv']:.1f}%")
print(f"IV ratio:      {vol['iv_ratio_0dte_7dte']:.2f}")

# Decision framework
if pin["pin_score"] >= 70:
    print("HIGH PIN RISK - sell butterflies around magnet strike")
if vol["iv_ratio_0dte_7dte"] > 1.15:
    print("0DTE IV ELEVATED - premium selling has edge")
if regime["label"] == "Negative Gamma":
    print("NEGATIVE GAMMA - trending day, use momentum strategies")

Complete decision framework in under 2 seconds. Every signal has a direct trading implication.

Volatility Scanner — VRP Opportunities

Repo: github.com/FlashAlpha-lab/volatility-surface-python

The volatility risk premium — the spread between implied and realized vol — is one of the most persistent edges in options. This scanner finds the best opportunities:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
watchlist = ["SPY", "QQQ", "AAPL", "TSLA", "NVDA", "AMZN", "META", "AMD", "MSFT", "GOOGL"]

results = []
for symbol in watchlist:
    try:
        vol = fa.volatility(symbol)
        results.append({
            "symbol": symbol,
            "atm_iv": vol["atm_iv"],
            "rv_20d": vol["realized_vol"]["rv_20d"],
            "vrp_20d": vol["iv_rv_spreads"]["vrp_20d"],
            "assessment": vol["iv_rv_spreads"]["assessment"],
        })
    except Exception as e:
        print(f"{symbol}: {e}")

results.sort(key=lambda x: x["vrp_20d"], reverse=True)

print(f"\n{'Symbol':<8} {'ATM IV':>8} {'RV 20d':>8} {'VRP':>9} {'Assessment'}")
print("-" * 50)
for r in results:
    print(f"{r['symbol']:<8} {r['atm_iv']:>7.1f}% {r['rv_20d']:>7.1f}% "
          f"{r['vrp_20d']:>+8.1f}% {r['assessment']}")

Positive VRP = IV overpricing actual movement = sell premium. Negative VRP = market underpricing risk = buy protection.

The endpoint also returns full skew profiles across expirations:

vol = fa.volatility("SPY")

for profile in vol["skew_profiles"]:
    print(f"{profile['expiry']}: "
          f"25d Put={profile['put_25d_iv']:.1f}% "
          f"ATM={profile['atm_iv']:.1f}% "
          f"25d Call={profile['call_25d_iv']:.1f}% "
          f"Skew={profile['skew_25d']:+.1f}%")

A skew of -5% means 25-delta puts are 5 points more expensive than calls. Track this over time to spot when the market shifts from complacency to fear.

Production Client Wrapper

For production code, wrap the SDK with caching and graceful degradation:

import logging
from datetime import datetime, timedelta
from flashalpha import FlashAlpha, RateLimitError, NotFoundError

logger = logging.getLogger("flashalpha")

class FAClient:
    def __init__(self, api_key, cache_ttl_seconds=300):
        self.fa = FlashAlpha(api_key)
        self.cache = {}
        self.ttl = timedelta(seconds=cache_ttl_seconds)

    def _cached(self, key, fn):
        now = datetime.now()
        if key in self.cache:
            data, ts = self.cache[key]
            if now - ts < self.ttl:
                return data
        try:
            data = fn()
            self.cache[key] = (data, now)
            return data
        except RateLimitError as e:
            logger.warning(f"Rate limited - retry after {e.retry_after}s")
            if key in self.cache:
                return self.cache[key][0]  # Return stale data
            raise
        except NotFoundError:
            logger.warning(f"Not found: {key}")
            return None

    def levels(self, symbol):
        return self._cached(f"levels:{symbol}", lambda: self.fa.exposure_levels(symbol))

    def zero_dte(self, symbol):
        return self._cached(f"0dte:{symbol}", lambda: self.fa.zero_dte(symbol))

    def vol(self, symbol):
        return self._cached(f"vol:{symbol}", lambda: self.fa.volatility(symbol))

5-minute cache, fallback to stale data on rate limits, structured logging. Every production example builds on this pattern.

SVI Parameters and Advanced Volatility

For quant teams, the Alpha plan returns raw SVI parameters per expiry (Gatheral's a, b, rho, m, sigma), total variance surface grids, butterfly/calendar arbitrage detection, variance swap fair values, and second/third-order greeks surfaces (vanna, charm, volga, speed).

data = fa.adv_volatility("SPY")

for s in data["svi_parameters"]:
    print(f"{s['expiry']} ({s['days_to_expiry']}d): "
          f"a={s['a']:.6f}  b={s['b']:.6f}  rho={s['rho']:.4f}  "
          f"ATM IV={s['atm_iv']:.1f}%")

# Arb detection
flags = data["arbitrage_flags"]
if flags:
    for f in flags:
        print(f"[{f['type']}] {f['expiry']}: {f['description']}")
else:
    print("Surface is arbitrage-free")

Alpha plan: $14,388/year ($1,199/mo annual). A single engineer maintaining SVI fitting infrastructure costs 10x that. A Bloomberg terminal is $24,000/year and doesn't give you raw SVI parameters via API.

Open Source Repos

Repo	What It Does
flashalpha-python	The SDK itself. Source code, typed exceptions, retry logic.
gex-explained	GEX theory + practical scanner code
0dte-options-analytics	0DTE pre-flight, pin risk, theta decay
volatility-surface-python	IV surface building, SVI calibration, arb detection
flashalpha-examples	Standalone scripts for every endpoint

Pricing

Plan	Price	Requests/day	Highlights
Free	$0	10	GEX, DEX, levels, quotes, Greeks
Growth	$299/mo	2,500	+ 0DTE, volatility, all exposure endpoints
Alpha	$1,199/mo annual	Unlimited	+ SVI surfaces, advanced vol, zero cache

Free tier: no credit card required. Enough to run every example in this guide.

Get API access
Full API docs
PyPI: pip install flashalpha
Interactive GEX tool (free, any ticker)

Related guides: