Dealer Positioning & GEX: A Quantitative Approach to Options Flow

What GEX Actually Measures

Gamma exposure (GEX) quantifies how many shares dealers must buy or sell to stay delta-neutral when the underlying moves by $1. It is a mechanical, involuntary flow - not a prediction, not a sentiment indicator, not a guess.

Where \(\Gamma_k\) is the option gamma at strike \(k\), \(\text{OI}_k\) is open interest, and \(S\) is the spot price. The factor of 100 converts contracts to shares. The sign convention matters:

• Call OI creates positive dealer gamma. Customers buy calls → dealers are short calls → hedging = long gamma on the dealer book.
• Put OI creates negative dealer gamma. Customers buy puts → dealers are short puts → hedging = short gamma on the dealer book.

Net GEX across all strikes:

The sign of net GEX determines the regime:

What GEX Does Not Tell You

• Direction - GEX is a volatility modifier, not a directional predictor. It tells you how far, not which way.
• Timing - when the rebalancing occurs (intraday, end of day, delayed) depends on dealer risk limits and vol of vol.
• Whether the premium is worth trading - that requires VRP data (discussed later).
• Second-order effects - vanna and charm generate flows that are often larger than gamma hedging itself.

Per-Strike GEX: The Raw Positioning Map

The /v1/exposure/gex/{symbol} endpoint is available on all tiers, including free. It returns per-strike gamma exposure with call/put decomposition:

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 10 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}  call={s['call_gex']:>12,}  put={s['put_gex']:>12,}  net={s['net_gex']:>12,}")

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(`Net GEX: $${data.net_gex.toLocaleString()} (${data.net_gex_label})`);
console.log(`Gamma Flip: $${data.gamma_flip}`);

const top = data.strikes.sort((a, b) => Math.abs(b.net_gex) - Math.abs(a.net_gex)).slice(0, 10);
top.forEach(s => console.log(`  $${s.strike}  net=${s.net_gex.toLocaleString()}`));

curl -s "https://lab.flashalpha.com/v1/exposure/gex/SPY" \
  -H "X-Api-Key: YOUR_API_KEY" | jq '{
    symbol, underlying_price, net_gex, net_gex_label, gamma_flip,
    top_strikes: [.strikes | sort_by(-.net_gex | fabs) | .[:5][] | {strike, net_gex}]
  }'

Key Levels: Where Dealer Flows Concentrate

The /v1/exposure/levels/{symbol} endpoint (free tier) extracts the critical levels from the full positioning map:

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

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"Highest OI Strike:  ${lvl['highest_oi_strike']:.2f}")
print(f"Zero-DTE Magnet:    ${lvl['zero_dte_magnet']:.2f}")

Beyond GEX: Second-Order Dealer Flows

GEX captures the first-order hedging flow - delta rebalancing in response to spot price changes. But dealers also hedge against changes in volatility (vanna) and time (charm). These second-order flows are often larger than GEX itself, and understanding them separates quantitative positioning analysis from surface-level GEX chart reading.

Vanna Exposure (VEX)

Vanna creates a feedback loop between volatility and price:

# VEX endpoint  - free tier
r = requests.get(f"{BASE}/v1/exposure/vex/SPY", headers=HEADERS)
vex = r.json()

print(f"Net VEX: ${vex['net_vex']:,.0f}")
print(f"Interpretation: {vex.get('vex_interpretation', '')}")

for s in sorted(vex["strikes"], key=lambda x: abs(x["net_vex"]), reverse=True)[:5]:
    print(f"  ${s['strike']:.0f}: call_vex={s['call_vex']:>12,}  put_vex={s['put_vex']:>12,}  net={s['net_vex']:>12,}")

Charm Exposure (CHEX)

Even if spot and vol do not move, the passage of time shifts delta - and dealers must rebalance. Charm flows are most significant for near-expiration options and are the primary driver of 0DTE price behavior and end-of-day drift.

# CHEX endpoint  - free tier
r = requests.get(f"{BASE}/v1/exposure/chex/SPY", headers=HEADERS)
chex = r.json()

print(f"Net CHEX: ${chex['net_chex']:,.0f}")
print(f"Interpretation: {chex.get('chex_interpretation', '')}")

for s in sorted(chex["strikes"], key=lambda x: abs(x["net_chex"]), reverse=True)[:5]:
    print(f"  ${s['strike']:.0f}: call_chex={s['call_chex']:>12,}  put_chex={s['put_chex']:>12,}  net={s['net_chex']:>12,}")

The Complete Flow Picture

The Summary Endpoint: Aggregated Intelligence

Per-strike data is useful for detailed analysis, but most daily workflows need a fast read on the current regime. The /v1/exposure/summary/{symbol} endpoint (Growth+) aggregates all four exposures into a single response with hedging estimates and 0DTE decomposition:

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

print(f"SPY @ ${summary['underlying_price']:.2f}")
print(f"Regime: {summary['regime']}")
print(f"Net GEX:  ${summary['net_gex']:>14,}")
print(f"Net DEX:  ${summary['net_dex']:>14,}")
print(f"Net VEX:  ${summary['net_vex']:>14,}")
print(f"Net CHEX: ${summary['net_chex']:>14,}")
print(f"\n{summary['interpretation']}")

# Hedging estimate  - how much must dealers trade for a 1% move?
hedge = summary.get("hedging_estimate", {})
down = hedge.get("spot_down_1pct", {})
print(f"\nIf spot drops 1%:")
print(f"  Dealers {down['direction']} {down['dealer_shares_to_trade']:,} shares")
print(f"  Notional: ${down['notional_usd']:,.0f}")

# 0DTE impact
zdte = summary.get("zero_dte", {})
print(f"\n0DTE GEX: ${zdte['net_gex']:,.0f} ({zdte['pct_of_total_gex']:.1f}% of total)")

const res = await fetch(`${BASE}/v1/exposure/summary/SPY`, { headers: HEADERS });
const summary = await res.json();

console.log(`SPY @ $${summary.underlying_price}`);
console.log(`Regime: ${summary.regime}`);
console.log(`Net GEX: $${summary.net_gex.toLocaleString()}`);
console.log(`Interpretation: ${summary.interpretation}`);

const { spot_down_1pct } = summary.hedging_estimate;
console.log(`If -1%: dealers ${spot_down_1pct.direction} ${spot_down_1pct.dealer_shares_to_trade} shares`);
console.log(`0DTE: ${summary.zero_dte.pct_of_total_gex}% of total GEX`);

The summary gives you three things the raw per-strike data does not:

1. Regime classification - one string: positive or negative gamma
2. Hedging estimates - how many shares and dollars dealers must trade for a given spot move
3. 0DTE decomposition - what percentage of total gamma comes from same-day expirations

Building a Quantitative Regime Model

The simplest regime model uses three inputs: net GEX sign, spot distance from gamma flip, and VEX sign. This gives you a multi-dimensional classification with confidence weighting:

def classify_regime(gex_data, vex_data, levels_data, spot):
    """
    Classify dealer regime using GEX + VEX + distance to flip.
    Returns regime dict with confidence level.
    """
    net_gex = gex_data.get("net_gex", 0)
    net_vex = vex_data.get("net_vex", 0)
    flip    = levels_data.get("gamma_flip", spot)

    dist_to_flip = (spot - flip) / spot * 100 if spot > 0 else 0

    # Primary regime: gamma sign
    gamma_regime = "positive" if net_gex > 0 else "negative"

    # Secondary: vanna alignment
    # Negative VEX + positive gamma → vol drop causes buying → virtuous cycle
    # Negative VEX + negative gamma → vol rise causes selling → vicious cycle
    vanna_aligned = (gamma_regime == "positive" and net_vex < 0)

    # Confidence: distance from flip
    if abs(dist_to_flip) > 2.0:
        confidence = "high"
    elif abs(dist_to_flip) > 0.5:
        confidence = "moderate"
    else:
        confidence = "low"  # near the flip  - regime could change

    return {
        "regime":        gamma_regime,
        "vanna_aligned": vanna_aligned,
        "dist_to_flip":  dist_to_flip,
        "confidence":    confidence,
        "net_gex_bn":    net_gex / 1e9,
        "net_vex_mn":    net_vex / 1e6,
    }

Regime Interpretation

Delta-Hedging P&L: Why Gamma Regime Determines Your Returns

To understand why the gamma regime matters so much for premium sellers, consider the P&L decomposition of a delta-hedged short option position:

The first term is the VRP - the spread between implied and realized variance. This is what premium sellers are harvesting. But the second term - the vanna flow - is what the gamma regime amplifies or dampens:

• In positive gamma: The vanna term reinforces the VRP term. Dealers dampen spot moves, which suppresses realized vol, which makes the first term larger. Vanna flows further support the position.
• In negative gamma: The vanna term works against the VRP term. Dealers amplify spot moves, inflating realized vol. Even with a positive VRP at entry, realized variance can exceed implied variance mid-trade - inverting the edge.

This is why the same VRP z-score in different gamma regimes produces radically different outcomes. The GEX regime is not just a filter - it is a fundamental determinant of how the premium is realized.

0DTE Gamma: The Growing Tail

Zero-DTE options now represent 40–50% of total SPY options volume on many trading days. Their gamma is concentrated and decays rapidly, creating intraday dynamics that did not exist five years ago.

# From the summary endpoint (Growth+)
r = requests.get(f"{BASE}/v1/exposure/summary/SPY", headers=HEADERS)
summary = r.json()

zdte = summary.get("zero_dte", {})

print(f"0DTE GEX:        ${zdte.get('net_gex', 0):,.0f}")
print(f"% of Total GEX:  {zdte.get('pct_of_total_gex', 0):.1f}%")
print(f"Expiration:       {zdte.get('expiration', '?')}")

if zdte.get("pct_of_total_gex", 0) > 30:
    print("\n0DTE gamma is dominant. Implications:")
    print("  - Stronger intraday pinning behavior")
    print("  - Rapid gamma decay into the close")
    print("  - Positioning resets daily  - overnight levels less reliable")
    print("  - End-of-day volatility spike as positions expire")

The Bridge: From GEX to VRP

GEX tells you the regime. VRP tells you the premium. Together, they tell you whether to trade and how.

This is where the analysis crosses from Growth-tier data to Alpha-tier analytics. The /v1/vrp/{symbol} endpoint (Alpha plan) returns a complete volatility risk premium dashboard that includes GEX-conditioned analysis:

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

# VRP data
v = vrp.get("vrp", {})
print(f"ATM IV:      {v.get('atm_iv', 0):.1f}%")
print(f"RV (20d):    {v.get('rv_20d', 0):.1f}%")
print(f"VRP (20d):   {v.get('vrp_20d', 0):+.1f} vol points")
print(f"Z-Score:     {v.get('z_score', 0):+.2f}  ({v.get('percentile', 0)}th percentile)")

# GEX-conditioned intelligence (Alpha-exclusive)
gex_cond = vrp.get("gex_conditioned", {})
print(f"\nRegime:        {gex_cond.get('regime', '?')}")
print(f"Harvest Score: {gex_cond.get('harvest_score', 0):.2f}")
print(f"Interpretation: {gex_cond.get('interpretation', '')}")

# Strategy scores (Alpha-exclusive)
scores = vrp.get("strategy_scores", {})
for name, score in sorted(scores.items(), key=lambda x: -x[1]):
    bar = chr(9608) * (score // 5) + chr(9617) * (20 - score // 5)
    print(f"  {name:<18} {bar} {score}")

# Vanna outlook (Alpha-exclusive)
vanna = vrp.get("vanna_conditioned", {})
print(f"\nVanna Outlook: {vanna.get('outlook', '')}")
print(f"Net Harvest Score: {vrp.get('net_harvest_score', 0):.2f}")
print(f"Dealer Flow Risk:  {vrp.get('dealer_flow_risk', 0)}/100")

What Alpha Adds to the Analysis

Multi-Symbol Regime Dashboard

The real power of quantitative dealer positioning is screening across your entire universe. Here is a complete multi-symbol dashboard that combines free-tier GEX data with Alpha-tier VRP analytics:

import requests

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

UNIVERSE = [
    "SPY", "QQQ", "IWM", "DIA",
    "AAPL", "MSFT", "NVDA", "TSLA", "META", "AMZN", "AMD", "GOOGL",
    "XLF", "XLE", "XLK", "XLV",
]

results = []

for sym in UNIVERSE:
    # GEX for regime (free tier)
    gex_r = requests.get(f"{BASE}/v1/exposure/gex/{sym}", headers=HEADERS)
    if gex_r.status_code != 200:
        continue
    gex = gex_r.json()

    # VRP for premium intelligence (Alpha tier)
    vrp_r = requests.get(f"{BASE}/v1/vrp/{sym}", headers=HEADERS)
    vrp = vrp_r.json() if vrp_r.status_code == 200 else {}

    spot      = gex["underlying_price"]
    net_gex   = gex["net_gex"]
    flip      = gex["gamma_flip"]
    dist_flip = (spot - flip) / spot * 100 if spot > 0 else 0

    v        = vrp.get("vrp", {})
    z        = v.get("z_score", 0)
    harvest  = vrp.get("gex_conditioned", {}).get("harvest_score", 0)
    dlr_risk = vrp.get("dealer_flow_risk", 0)

    # Classify
    pos = net_gex > 0
    high = z >= 1.0
    if pos and high:      cell = "A"
    elif not pos and high: cell = "B"
    elif pos and not high: cell = "C"
    else:                  cell = "D"

    results.append({
        "sym": sym, "spot": spot, "gex_bn": net_gex / 1e9,
        "flip": flip, "dist": dist_flip, "z": z,
        "harvest": harvest, "risk": dlr_risk, "cell": cell,
    })

# Sort: Cell A first, then by z-score descending
cell_order = {"A": 0, "B": 1, "C": 2, "D": 3}
results.sort(key=lambda x: (cell_order.get(x["cell"], 9), -x["z"]))

Intraday Regime Monitoring

Regimes can shift intraday - especially when spot approaches the gamma flip. A production system should poll periodically during market hours:

import requests, time
from datetime import datetime

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

SYMBOLS    = ["SPY", "QQQ"]
POLL_SECS  = 300   # 5 minutes
FLIP_WARN  = 0.5   # warn within 0.5% of flip

last_regime = {}

while True:
    now = datetime.now().strftime("%H:%M:%S")

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

        spot   = d["underlying_price"]
        flip   = d["gamma_flip"]
        regime = "positive" if d["net_gex"] > 0 else "negative"
        dist   = (spot - flip) / spot * 100 if spot > 0 else 0

        prev    = last_regime.get(sym, {})
        changed = prev.get("regime") and prev["regime"] != regime

        if changed:
            print(f"[{now}] *** {sym} REGIME CHANGE: {prev['regime']} -> {regime} ***")
        elif abs(dist) < FLIP_WARN:
            print(f"[{now}] {sym} WARNING: {dist:+.1f}% from flip (${flip:.2f})")
        else:
            print(f"[{now}] {sym}: {regime} gamma, {dist:+.1f}% from flip")

        last_regime[sym] = {"regime": regime, "dist": dist}

    time.sleep(POLL_SECS)

Rate Limits for Polling

The Practitioner's Daily Checklist

Steps 1–4 are free. Step 5 requires Growth. Steps 6–9 require Alpha. The free tier gives you regime awareness. Alpha gives you tradeable intelligence.

Related Reading

• What Is GEX? - gamma exposure fundamentals
• GEX Trading Guide - practical GEX strategies for SPY and TSLA
• Why GEX Isn't Enough - VEX and CHEX deep dive
• Vanna & Charm Guide - second-order Greek mechanics
• GEX-Conditioned VRP - the 4-cell matrix for premium selling
• VRP Trading in Practice - from signal to execution workflow
• Real-Time GEX by Strike - SPY key levels and dealer gamma map
• Build a Dealer Positioning Tracker - tutorial for building your own monitor
• Max Pain Explained - dealer hedging mechanics and expiration pinning
• Historical VRP API: Leak-Free Backtests - date-bounded percentiles so the regime you measured matches what was actually knowable at the time
• Replay Dealer Positioning Since 2018 - minute-level GEX, VRP, and dealer-flow history for any ticker