Build a Dealer Positioning Tracker with an API: Options Flow Monitor for Developers

If you're searching for a dealer positioning API, a gamma regime data source, or trying to figure out how to build a dealer flow dashboard without computing everything yourself, this is the guide. The FlashAlpha exposure endpoints return net GEX/DEX/VEX/CHEX, gamma regime classification, dealer hedging estimates, key levels (gamma flip, call wall, put wall), 0DTE contribution, natural language narratives, and per-strike breakdowns — all from a handful of API calls covering 6,000+ US equities and ETFs.

What Is Dealer Positioning?

Options market makers (dealers) are generally short options. When a retail trader or institution buys a call, the dealer sells it. To stay delta-neutral, the dealer must hedge by buying the underlying stock. When that same call decays or the trader sells it back, the dealer sells stock to unwind the hedge. This creates predictable, mechanical flows that move markets.

Dealer positioning tracking answers three questions:

1. Are dealers long or short gamma? This determines whether dealer hedging dampens moves (positive gamma, dealers buy dips and sell rips) or amplifies them (negative gamma, dealers sell into selloffs and buy into rallies).
2. Where are the key levels? The gamma flip point, call wall, and put wall define the price range where dealer behavior changes. These act as support and resistance driven by hedging flows, not technical patterns.
3. How much hedging pressure exists? Net GEX tells you the dollar amount dealers must trade per 1% move. At $2 billion of net positive gamma, dealers will buy roughly $2 billion of stock on a 1% decline. That is a powerful stabilizing force.

The Four Dimensions of Dealer Exposure

Gamma exposure (GEX) gets the headlines, but dealers hedge against more than just directional moves. A complete dealer positioning tracker monitors four dimensions:

GEX alone misses half the picture. A market with positive gamma but large negative vanna exposure can still sell off violently if IV spikes — the vanna-driven hedging overwhelms the gamma cushion. A proper dealer positioning tracker shows all four dimensions.

The API Approach: Exposure Endpoints

FlashAlpha provides seven exposure endpoints that cover every angle of dealer positioning. Two endpoints return the aggregated summary and narrative (Growth+ plan). Five endpoints return per-strike breakdowns (Free+ plan).

The summary endpoint is the core of your dealer positioning tracker. One call returns the full aggregated picture. The per-strike endpoints let you build detailed visualizations showing exactly where the exposure is concentrated.

Quick Start: Your First Dealer Positioning Call

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
summary = fa.exposure_summary("SPY")

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

print(f"Net GEX:    ${summary['exposures']['net_gex']:,.0f}")
print(f"Regime:     {summary['regime']}")
print(f"Gamma flip: {summary['gamma_flip']}")
print(f"Call wall:  {levels['call_wall']}")
print(f"Put wall:   {levels['put_wall']}")
print(f"Hedging on -1%: ${summary['hedging_estimate']['spot_down_1pct']['notional_usd']:,.0f}")
print(f"Hedging on +1%: ${summary['hedging_estimate']['spot_up_1pct']['notional_usd']:,.0f}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_KEY');
const summary = await fa.exposureSummary('SPY');

console.log(`Net GEX: ${summary.exposures.net_gex}`);
console.log(`Regime: ${summary.regime}`);
console.log(`Gamma flip: ${summary.gamma_flip}`);
console.log(`Hedging on -1%: ${summary.hedging_estimate.spot_down_1pct.notional_usd}`);

using FlashAlpha;

var fa = new FlashAlphaClient("YOUR_KEY");
var summary = await fa.ExposureSummaryAsync("SPY");

Console.WriteLine($"Net GEX: {summary.NetGex:N0}");
Console.WriteLine($"Regime: {summary.Regime}");
Console.WriteLine($"Gamma flip: {summary.Levels.GammaFlip}");

package main

import (
    "context"
    "fmt"
    flashalpha "github.com/FlashAlpha-lab/flashalpha-go"
)

func main() {
    fa := flashalpha.NewClient("YOUR_KEY")
    summary, _ := fa.ExposureSummary(context.Background(), "SPY")

    fmt.Printf("Net GEX: %d\n", summary.NetGex)
    fmt.Printf("Regime: %s\n", summary.Regime)
    fmt.Printf("Gamma flip: %.2f\n", summary.Levels.GammaFlip)
}

import com.flashalpha.FlashAlphaClient;
import com.google.gson.JsonObject;

FlashAlphaClient fa = new FlashAlphaClient("YOUR_KEY");
JsonObject summary = fa.exposureSummary("SPY");

System.out.println("Net GEX: " + summary.get("net_gex").getAsLong());
System.out.println("Regime: " + summary.get("regime").getAsString());
System.out.println("Gamma flip: " + summary.getAsJsonObject("levels").get("gamma_flip"));

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

Full Response Walkthrough

Here is what the exposure summary endpoint returns for SPY during market hours:

{
  "symbol": "SPY",
  "underlying_price": 573.42,
  "as_of": "2026-03-28T15:45:00Z",
  "gamma_flip": 565.0,
  "regime": "positive_gamma",
  "exposures": {
    "net_gex": 1847293000,
    "net_dex": 4291000000,
    "net_vex": -312400000,
    "net_chex": 87200000
  },
  "interpretation": {
    "gamma": "Dealers long gamma — expect range-bound, mean-reverting price action",
    "vanna": "Negative vanna — IV spikes can trigger amplifying selling",
    "charm": "Positive charm — time decay supports dealers"
  },
  "hedging_estimate": {
    "spot_down_1pct": {
      "dealer_shares_to_trade": 3220000,
      "direction": "BUY",
      "notional_usd": 1847000000
    },
    "spot_up_1pct": {
      "dealer_shares_to_trade": -3220000,
      "direction": "SELL",
      "notional_usd": 1847000000
    }
  },
  "zero_dte": {
    "net_gex": 631600000,
    "pct_of_total_gex": 34.2,
    "expiration": "2026-03-28"
  }
}

Use the /v1/exposure/levels/{symbol} endpoint for call wall, put wall, max-gamma strikes, and the 0DTE magnet. Use /v1/exposure/gex/{symbol} for the per-strike OI changes.

Every field your dealer positioning tracker needs is in this single response. Let's break down how to use each section in a dashboard.

Building the Dashboard: Section by Section

1. Gamma Regime Indicator

The regime field is the single most important piece of dealer positioning data. It determines whether the market is in a dampened (positive gamma) or amplified (negative gamma) state.

summary = fa.exposure_summary("SPY")

regime = summary['regime']
price = summary['underlying_price']
flip = summary['gamma_flip']

if regime == "positive_gamma":
    status = "PINNED"
    color = "#16a34a"  # green
    msg = f"Dealers long gamma. Buying dips, selling rips. Price pinned above flip at {flip}."
else:
    status = "FRAGILE"
    color = "#dc2626"  # red
    msg = f"Dealers short gamma. Amplifying moves. Price below flip at {flip}."

distance_to_flip = ((price - flip) / price) * 100
print(f"Regime: {status}")
print(f"Distance to gamma flip: {distance_to_flip:+.1f}%")
print(msg)

Display the regime as a large, color-coded badge at the top of your dashboard. When the regime is positive, the market trades in a "sticky" range. When it flips to negative, expect accelerated moves and higher realized volatility. The interpretation field provides a human-readable explanation you can display directly.

2. Dealer Hedging Impact

The hedging_estimate object tells you exactly how much stock dealers must buy or sell on a 1% move. This is the mechanical flow that creates mean reversion in positive gamma and momentum in negative gamma.

hedge = summary['hedging_estimate']
down_notional = hedge['spot_down_1pct']['notional_usd']
up_notional = hedge['spot_up_1pct']['notional_usd']

print(f"If SPY drops 1%:")
print(f"  Dealers {hedge['spot_down_1pct']['direction']} ${down_notional:,.0f} of stock")
print(f"If SPY rises 1%:")
print(f"  Dealers {hedge['spot_up_1pct']['direction']} ${up_notional:,.0f} of stock")

# Context: SPY average daily volume is ~$30B
avg_daily_volume = 30_000_000_000
pct_of_volume = (down_notional / avg_daily_volume) * 100
print(f"\nHedging flow = {pct_of_volume:.1f}% of avg daily volume")

When dealer hedging flow represents 5%+ of daily volume, it is a material force on price. Display this as a bar gauge showing hedging pressure relative to typical daily volume.

3. Net Exposure Gauges (GEX/DEX/VEX/CHEX)

Display all four exposure dimensions as gauges. The sign tells you direction; the magnitude tells you importance.

e = summary['exposures']
exposures = {
    'GEX':  e['net_gex'],
    'DEX':  e['net_dex'],
    'VEX':  e['net_vex'],
    'CHEX': e['net_chex'],
}

print("Net Dealer Exposure:")
for name, value in exposures.items():
    direction = "+" if value > 0 else "-"
    bar = "#" * min(int(abs(value) / 200_000_000), 30)
    print(f"  {name}: {direction}${abs(value):>14,.0f}  {bar}")

# Interpret the combination
if e['net_gex'] > 0 and e['net_vex'] < 0:
    print("\nWARNING: Positive gamma but negative vanna.")
    print("IV spike could trigger selling that overwhelms gamma cushion.")

The combination matters more than any single number. Positive GEX with negative VEX means the market is pinned until IV spikes — then vanna-driven selling can break through the gamma cushion. Your dashboard should highlight conflicting signals.

4. Key Levels from Dealer Positioning

The levels object defines the price grid where dealer behavior changes. These are not arbitrary support/resistance lines — they are prices where hedging mechanics shift.

resp = fa.exposure_levels("SPY")
levels = resp['levels']
price = resp['underlying_price']

print(f"Current price: {price}")
print(f"Call wall:       {levels['call_wall']}  ({((levels['call_wall'] - price) / price * 100):+.1f}%)")
print(f"Max pos gamma:   {levels['max_positive_gamma']}")
print(f"Highest OI:      {levels['highest_oi_strike']}")
print(f"0DTE magnet:     {levels['zero_dte_magnet']}")
print(f"Gamma flip:      {levels['gamma_flip']}  ({((levels['gamma_flip'] - price) / price * 100):+.1f}%)")
print(f"Max neg gamma:   {levels['max_negative_gamma']}")
print(f"Put wall:        {levels['put_wall']}  ({((levels['put_wall'] - price) / price * 100):+.1f}%)")

The call wall acts as a ceiling — massive dealer hedging sells stock as price approaches it. The put wall acts as a floor for the same reason in reverse. The gamma flip is the price where dealers transition from long gamma to short gamma. Visualize these as horizontal lines on a price chart with color coding: green above the gamma flip, red below.

5. OI Change Tracking

Day-over-day open interest changes reveal where new positions are being opened. This tells you whether the current dealer positioning is strengthening or weakening.

# OI changes live on per-strike GEX, not the summary
gex = fa.gex("SPY")

call_change = sum(s['call_oi_change'] for s in gex['strikes'])
put_change = sum(s['put_oi_change'] for s in gex['strikes'])
total_change = call_change + put_change

biggest = max(gex['strikes'],
              key=lambda s: abs(s['call_oi_change']) + abs(s['put_oi_change']))

print(f"Total OI change:  {total_change:+,d} contracts")
print(f"  Calls:          {call_change:+,d}")
print(f"  Puts:           {put_change:+,d}")
print(f"Biggest mover:    {biggest['strike']} (call {biggest['call_oi_change']:+,d}, put {biggest['put_oi_change']:+,d})")

ratio = call_change / max(put_change, 1)
print(f"\nCall/Put OI change ratio: {ratio:.2f}")
if ratio > 1.5:
    print("Heavy call opening - call wall may be strengthening")
elif ratio < 0.67:
    print("Heavy put opening - put wall may be strengthening")

If the call wall is at 580 and OI is increasing at 580, that wall is getting stronger. If OI is decreasing, the wall is weakening and price is more likely to break through.

6. Natural Language Narrative Panel

The narrative endpoint provides a full market positioning analysis in natural language with structured data. This is ideal for display panels, Slack alerts, or AI agent consumption.

narrative = fa.narrative("SPY")
n = narrative['narrative']

# Each section is a sentence you can drop into a panel
print(n['regime'])
print(n['gex_change'])
print(n['key_levels'])
print(n['flow'])
print(n['outlook'])

# Structured data backing the prose
data = n['data']
print(f"\nRegime:     {data['regime']}")
print(f"GEX change: {data['net_gex_change_pct']:+.1f}%")
print(f"VIX:        {data['vix']}")

The narrative combines all exposure dimensions, key levels, OI flow, and regime analysis into a coherent paragraph that explains what dealer positioning means for the current session. Display this as a text panel on your dashboard — it gives traders the "so what?" that raw numbers alone cannot.

7. Multi-Timeframe Exposure

The per-strike endpoints return data across all expirations by default, but you can filter to specific expiration dates to compare near-term vs longer-dated positioning:

# Per-strike GEX for all expirations
all_gex = fa.gex("SPY")

# Check 0DTE contribution from summary
zero_dte = summary['zero_dte']
print(f"0DTE accounts for {zero_dte['pct_of_total_gex']:.1f}% of total GEX")
print(f"0DTE GEX value: ${zero_dte['net_gex']:,.0f}")

total_gex = summary['exposures']['net_gex']
longer_dated = total_gex - zero_dte['net_gex']
print(f"Longer-dated GEX: ${longer_dated:,.0f}")

if zero_dte['pct_of_total_gex'] > 50:
    print("WARNING: Majority of gamma is 0DTE - positioning resets daily")

When 0DTE accounts for more than half of total GEX, the dealer positioning picture resets every day at close. Your dashboard should flag this because it means today's levels may not hold tomorrow.

Regime Change Detector

The highest-value alert in a dealer positioning tracker is the gamma regime flip. When the market crosses the gamma flip price, dealer behavior reverses and volatility characteristics change dramatically. Here is a polling script that detects this crossover:

from flashalpha import FlashAlpha
import time

fa = FlashAlpha("YOUR_KEY")
symbol = "SPY"
last_regime = None

while True:
    try:
        summary = fa.exposure_summary(symbol)
        current_regime = summary['regime']
        price = summary['underlying_price']
        flip = summary['gamma_flip']

        if last_regime and current_regime != last_regime:
            distance = ((price - flip) / price) * 100
            print(f"REGIME CHANGE: {last_regime} -> {current_regime}")
            print(f"  Price: {price}, Gamma flip: {flip}")
            print(f"  Distance from flip: {distance:+.2f}%")
            print(f"  Net GEX: ${summary['exposures']['net_gex']:,.0f}")
            # Send alert via Slack, Discord, email, etc.
            send_alert(symbol, last_regime, current_regime, price, flip)

        last_regime = current_regime
        time.sleep(300)  # Poll every 5 minutes
    except Exception as e:
        print(f"Error: {e}")
        time.sleep(60)

When the regime flips from positive to negative, it is a signal to reduce short premium positions and widen stops. When it flips back to positive, mean-reversion strategies become favorable again. This single alert is worth more than most technical indicators because it reflects actual mechanical flows, not pattern recognition.

Multi-Symbol Dealer Positioning Scanner

Scan your universe for unusual dealer positioning:

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:
        s = fa.exposure_summary(sym)
        lv = fa.exposure_levels(sym)['levels']
        price = s['underlying_price']
        flip_dist = ((price - s['gamma_flip']) / price) * 100

        results.append({
            'symbol': sym,
            'regime': s['regime'],
            'net_gex': s['exposures']['net_gex'],
            'flip_distance': flip_dist,
            'call_wall': lv['call_wall'],
            'put_wall': lv['put_wall'],
            'zero_dte_pct': s['zero_dte']['pct_of_total_gex'],
        })
    except Exception as e:
        print(f"Skipping {sym}: {e}")

# Sort by proximity to gamma flip (most likely to flip regime)
results.sort(key=lambda r: abs(r['flip_distance']))

print(f"{'Symbol':>6}  {'Regime':>16}  {'Net GEX':>14}  {'Flip Dist':>10}  {'0DTE%':>6}")
print("-" * 65)
for r in results:
    print(f"{r['symbol']:>6}  {r['regime']:>16}  ${r['net_gex']:>13,.0f}  {r['flip_distance']:>+9.1f}%  {r['zero_dte_pct']:>5.1f}%")

Symbols closest to their gamma flip point are the ones most likely to see a regime change. These are your highest-conviction watchlist candidates for volatility expansion or contraction trades.

Using Dealer Positioning Data with AI Agents

FlashAlpha provides an MCP (Model Context Protocol) server that lets AI coding assistants query dealer positioning data directly. If you are building with Claude, Cursor, Windsurf, or any MCP-compatible agent, connect to the FlashAlpha MCP server and the agent can pull exposure analytics as part of its reasoning.

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

The agent can call exposure summary, retrieve key levels, read the narrative, and synthesize a dealer positioning report without you writing any dashboard code. Ask the agent "What is the current gamma regime for SPY and how far is price from the gamma flip?" and it will call the API, interpret the response, and answer in natural language.

The narrative endpoint is particularly useful for agents because it returns pre-interpreted analysis that the agent can reference directly rather than having to reason about raw numbers.

Why Not Build It Yourself?

You can. Here is what that requires:

1. Options chain data source — Raw chains for all strikes and expirations across 6,000+ symbols. Budget $200-2,500/mo from providers like Intrinio, Polygon, or ThetaData.
2. Dealer model assumptions — Decide how to split open interest between dealers and customers. The standard assumption (dealers short all options) is a simplification. Handling the ambiguity correctly matters.
3. Gamma exposure computation — For each strike: compute option gamma, multiply by open interest, multiply by spot price squared, divide by 100, apply dealer sign convention. Do this across every strike and expiration.
4. Delta, vanna, and charm exposure — Same computation with different Greeks. Vanna and charm require second-order sensitivities that most free Greeks providers do not supply.
5. Key level detection — Find the gamma flip point (where net GEX crosses zero), call wall (strike with largest positive gamma), and put wall (strike with largest negative gamma). Handle multiple zero-crossings.
6. Regime classification — Determine positive vs negative gamma. Track transitions. Build alerting logic.
7. 0DTE handling — Same-day expirations require real-time chain data and produce rapidly changing gamma profiles. Most providers do not supply intraday OI updates.
8. Infrastructure — Process millions of contracts daily. Handle corporate actions, splits, and special dividends. Monitor data quality. Run reliably during market hours.

That is 3-6 months of engineering before your dashboard displays a single number. The FlashAlpha exposure endpoints exist specifically so you can skip all of this.

API Access and Pricing

Per-strike exposure data (GEX, DEX, VEX, CHEX, levels) is available on the Free tier. The aggregated summary and narrative endpoints require the Growth plan or higher.

To evaluate before committing, the interactive API playground lets you test exposure calls in the browser with your API key. The per-stock dashboards visualize every metric the API returns, so you can see exactly what you are building against before writing code.

SDKs available in Python, JavaScript, C#, Go, and Java. All SDKs include typed exceptions (RateLimitError, TierRestrictedError) and automatic retries.

Frequently Asked Questions

Related Reading

• Build a GEX Dashboard with an API
• What Is Gamma Exposure (GEX) Explained
• Why GEX Isn't Enough: Vanna and Charm Exposure
• GEX-Conditioned VRP: Dealer Positioning Meets Volatility Premium
• Build a VRP Dashboard with an API
• Exposure API Documentation
• Interactive API Playground