The Quant Data gamma exposure API (the GEX API) returns per-strike gamma exposure for SPY, SPX, QQQ, NDX, and 6,000+ tickers via REST or a hosted MCP server: the call and put gamma sitting at every strike, straight from exchange-licensed options data that updates live through the trading day. It's the same Greek exposure, options flow, and dark pool data behind every Quant Data dashboard, and it's the fastest way to get gamma exposure data programmatically in Python, a trading bot, or an AI agent.
This is the deep-dive companion to the Quant Data API overview, start there for account setup and the full endpoint list; this guide goes deep on GEX, dealer positioning, and Greek exposure specifically.
What is gamma exposure (GEX)?
Gamma exposure (GEX) is an estimate of how much dealers' delta-hedging shifts for each move in the underlying. It is one of the clearest reads on dealer positioning and short-term market mechanics. Quant Data computes it per strike from live, full-chain, exchange-licensed options data. For a full conceptual walkthrough of how gamma exposure works, see What is Gamma Exposure (GEX)?. This guide focuses on getting that data through the API.
A few terms the rest of this guide uses:
Per-strike gamma, the call-side and put-side gamma sitting at each strike. This is what the Quant Data GEX API returns directly.
Net gamma per strike, call gamma plus put gamma at a strike. Summed across strikes, it tells you whether the book is net long or net short gamma.
Positive (long) gamma regime, dealers hedge against the move (buy dips, sell rips), which tends to dampen volatility and favor mean-reversion and pinning.
Negative (short) gamma regime, dealers hedge with the move (sell weakness, buy strength), which tends to amplify volatility and favor trends.
One thing to know up front: the Quant Data API returns per-strike call and put gamma as raw fields, straight from exchange-licensed options data. You get the exposure itself, not a black-box score, and you aggregate it however your strategy needs.
What GEX is, and isn't: GEX is an estimate built from options-chain data plus a signing convention for call and put exposure. It is not a direct look into any single dealer's real inventory or hedging. Read it as a positioning and hedge-flow proxy, not a guaranteed prediction.
Figure 1: The two gamma regimes. In positive (long) gamma dealers dampen moves, so the tape chops and mean-reverts; in negative (short) gamma they amplify moves, so it trends and gets volatile.
Get GEX data in 60 seconds
There are two ways to pull gamma exposure: ask in plain English over the MCP server (no code), or call the REST API directly. Both hit the same exchange-licensed data.
Path A (MCP, no code): ask Claude, ChatGPT, or Cursor
Connect the hosted Quant Data MCP server to any MCP-compatible client, Claude Desktop, Claude Code, ChatGPT (Pro+), or Cursor, and ask for gamma exposure in plain English. The MCP server (named quantdata-mcp) exposes all 30+ Quant Data endpoints as named tools, including qd_get_exposure_by_strike (the per-strike gamma snapshot) and qd_get_interval_map (intraday gamma by strike), so the model pulls the gamma data and reasons over it for you.
MCP server URL: https://api.quantdata.us/mcp
Auth: Bearer <your qd_… API key>
Once connected, ask:
"What does SPY's gamma exposure look like today, and is the book net long or short gamma?"
The assistant calls qd_get_exposure_by_strike (or qd_get_interval_map for the intraday view), reads the per-strike gamma, and answers in plain English, no code required. See the overview article for per-client setup (Claude Desktop, ChatGPT, Cursor, Claude Code).
Figure 2: The Quant Data MCP server answering a plain-English gamma exposure question in Claude via the qd_get_exposure_by_strike tool. (Representative render; swap for a real screen capture if you prefer.)
Path B (REST): auth, curl, then Python
Every endpoint is a POST under https://api.quantdata.us/v1, authenticated with a Bearer key (your 35-character qd_… key, shown once when you generate it). The GEX endpoint is /v1/options/tool/exposure-by-strike.
Auth one-liner, send your key on every request:
Authorization: Bearer qd_your_key_here
Get SPY gamma exposure by strike (curl):
curl -X POST https://api.quantdata.us/v1/options/tool/exposure-by-strike \
-H "Authorization: Bearer $QD_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"sessionDate": "2026-06-23",
"greekMode": "GAMMA",
"representationMode": "PER_ONE_PERCENT_MOVE",
"filter": { "ticker": "SPY" }
}'
The same call in Python (copy-paste, only needs requests):
import os
import requests
QD_API_KEY = os.environ["QD_API_KEY"] # your qd_… key
resp = requests.post(
"https://api.quantdata.us/v1/options/tool/exposure-by-strike",
headers={"Authorization": f"Bearer {QD_API_KEY}"},
json={
"sessionDate": "2026-06-23", # any recent weekday; omit for latest session
"greekMode": "GAMMA", # GAMMA | DELTA | CHARM | VANNA
"representationMode": "PER_ONE_PERCENT_MOVE", # or PER_ONE_DOLLAR_MOVE | RAW
"filter": {"ticker": "SPY"},
},
timeout=30,
)
resp.raise_for_status()
data = resp.json()["data"]["SPY"]
spot = data["stockPrice"]
exposure_map = data["exposureMap"] # { expiry: { strike: {callExposure, putExposure} } }
print(f"SPY spot: {spot}")
That's the whole quickstart. The chart below is rendered from a real response to exactly this call.
Figure 3: Real SPY gamma exposure by strike (session 2026-06-23, 0DTE expiry, spot $734.20). Green = call gamma, red = put gamma. Rendered directly from the API response.
What you get back
The response is a data object keyed by ticker, with an exposureMap of expiry → strike → {callExposure, putExposure}, plus the spot stockPrice. Here's a real, unedited slice of the SPY response (a few near-spot strikes on the 2026-06-23 expiry):
{
"data": {
"SPY": {
"exposureMap": {
"2026-06-23": {
"730.0": { "callExposure": 6341736, "putExposure": -366249195 },
"732.0": { "callExposure": 33126920, "putExposure": -894036602 },
"735.0": { "callExposure": 0, "putExposure": -4961569769 },
"738.0": { "callExposure": 152048664, "putExposure": 0 },
"740.0": { "callExposure": 229657315, "putExposure": -133801410 },
"745.0": { "callExposure": 39828837, "putExposure": 0 }
}
},
"stockPrice": 734.2
}
}
}
Field reference
Field | Type | Direct from API or computed? | Meaning |
| number | API | Spot price of the underlying for the session. |
| object | API | Map of expiry date → strike → exposure object. |
| number | API | Call-side gamma at that strike/expiry (dealer $ gamma per 1% move under |
| number | API | Put-side gamma at that strike/expiry. Negative. A side may be omitted when it's zero. |
Net gamma per strike | number | aggregation |
|
A note on signs: raw option gamma is positive for both calls and puts. Quant Data returns exposure already dealer-signed, the standard GEX convention: callExposure is positive and putExposure is negative. That is why net gamma at a strike is just callExposure + putExposure, and the sign of that sum across strikes gives the net long or short gamma regime.
Honest by design: callExposure and putExposure are the real API fields, straight from exchange-licensed options data. Anything beyond them, like a net-per-strike view or a net long/short gamma read, is a simple aggregation you do on top, shown in the recipes below.
The same endpoint also serves the other Greeks via greekMode, change one parameter to get delta, charm, or vanna exposure (see GEX vs DEX vs VEX vs CHEX).
Snapshot vs intraday: the interval-map endpoint
exposure-by-strike is a snapshot of where gamma sits right now. To watch the gamma map evolve through the session as gamma builds and decays at each strike, use POST /v1/options/tool/interval-map, which returns a per-minute time series of gamma by strike (the same data behind the dashboard's Interval Map).
curl -X POST https://api.quantdata.us/v1/options/tool/interval-map \
-H "Authorization: Bearer $QD_API_KEY" \
-H "Content-Type: application/json" \
-d '{"sessionDate":"2026-06-23","greekMode":"GAMMA","filter":{"ticker":"SPY"}}'
The response is keyed by epoch-millisecond timestamp → expiry → strike, with CALL/PUT gamma at each strike. Note the field names differ from exposure-by-strike: here they are CALL/PUT, not callExposure/putExposure, and a side is omitted when its gamma is zero.
{
"data": {
"1782245640000": {
"2026-06-23": {
"729.0": { "PUT": -151883390 }
}
}
}
}
A single SPY session returns roughly 405 one-minute buckets. Use exposure-by-strike for "where is gamma stacked right now," and interval-map for "how did the gamma map move through the day."
Why Quant Data for GEX
Quant Data gives you the entire options-positioning picture through one exchange-licensed API and one key: gamma plus the full Greek set (delta, charm, vanna), a real-time and intraday view of the gamma map, live options flow, and dark pool, all for a flat $149.99/mo with no per-endpoint or per-call metering. You are not buying a single GEX endpoint and paying extra for add-ons. You get the whole feed for one price and use only the parts your strategy needs.
Everything the GEX API includes, under one key:
Capability | What you get |
Greek exposure | Gamma, Delta, Charm, and Vanna, per-strike and as an intraday time series |
Intraday | Per-minute gamma-by-strike time series via |
Coverage | 6,000+ tickers, 365+ days of history |
Freshness | Live data, every ticker, no per-plan throttling |
Options flow | Sweeps, blocks, and net flow |
Dark pool | Dark Flow and Dark Pool Levels |
Access | REST and a hosted MCP server, one key, 240 requests/minute, no monthly quota |
Price | Flat $149.99/mo ($124.99 annual), no per-endpoint or per-call metering |
🟦 One feed, one key, flat price. Gamma and every Greek, the intraday gamma map, options flow, and dark pool all sit behind the same key for one flat fee, with nothing metered per endpoint or per call. If GEX is all you need today, you are not paying a premium for a thinner product; if you later want flow or dark-pool confluence, there is nothing new to buy or integrate. That "use what you need, it is all already there" model, one flat price for gamma, every Greek, flow, and dark pool together, is the part a feed that stops at exposure and flow cannot match.
GEX vs DEX vs VEX vs CHEX
All four are the same exposure-by-strike endpoint with a different greekMode, they measure dealer exposure to a different Greek. Change one parameter and the call/put exposure fields come back for that Greek.
Exposure | What it measures |
| Use it to read |
GEX (gamma) | Dealer hedging per 1% move |
| Pinning pressure, net long/short gamma regime |
DEX (delta) | Estimated net directional exposure |
| Directional pressure / hedging imbalance |
VEX (vanna) | How delta-hedging shifts as IV moves |
| Vol-driven flows (vanna rallies, OPEX) |
CHEX (charm) | How delta shifts as time passes |
| End-of-day / into-expiry drift |
Accuracy note: Quant Data's greekMode accepts exactly GAMMA, DELTA, CHARM, and VANNA. "VEX" here maps to VANNA (vanna exposure, sensitivity of delta to implied vol), not Vega. A dedicated Vega-exposure mode is not currently exposed by the API.
Figure 4: GEX/DEX/VEX/CHEX → greekMode quick reference.
Recipes
Three short, copy-paste examples. Each assumes QD_API_KEY is in your environment and reuses the helper below.
import os, requests
BASE = "https://api.quantdata.us/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['QD_API_KEY']}"}
def exposure_by_strike(ticker, greek="GAMMA", session=None):
body = {"greekMode": greek, "representationMode": "PER_ONE_PERCENT_MOVE",
"filter": {"ticker": ticker}}
if session:
body["sessionDate"] = session
r = requests.post(f"{BASE}/options/tool/exposure-by-strike",
headers=HEADERS, json=body, timeout=30)
r.raise_for_status()
return r.json()["data"][ticker]
Recipe 1: Net gamma by strike (the GEX chart)
Aggregate call plus put gamma per strike across expiries, then plot it. That is the bar chart in Figure 3.
from collections import defaultdict
def net_gamma_by_strike(node):
"""Sum callExposure + putExposure per strike across every expiry."""
agg = defaultdict(float)
for expiry, strikes in node["exposureMap"].items():
for strike, exp in strikes.items():
agg[float(strike)] += exp.get("callExposure", 0) + exp.get("putExposure", 0)
return dict(sorted(agg.items()))
node = exposure_by_strike("SPY")
spot = node["stockPrice"]
net = net_gamma_by_strike(node)
for strike, gamma in net.items():
if abs(strike - spot) <= 10: # near-spot strikes
print(f"{strike:>7}: {gamma:>16,.0f}")
# Feed `net` into Recharts/Plotly for the by-strike bar chart in Figure 3.
Recipe 2: Net long vs short gamma regime
Sum net gamma across the whole book. A positive total means dealers are net long gamma and hedge against moves (dampening, mean-reversion); a negative total means net short gamma and hedge with moves (amplification, trends). It is the sign of the aggregate, not a price level.
node = exposure_by_strike("SPY")
net = net_gamma_by_strike(node) # from Recipe 1
total = sum(net.values())
regime = "long gamma (moves dampened, mean-reverting)" if total > 0 \
else "short gamma (moves amplified, trending)"
print(f"SPY net gamma total: {total:,.0f} -> dealers are net {regime}")
Recipe 3: GEX + dark pool in one view
Pull the net-gamma-by-strike profile and the dark pool levels from the same key and line them up. Where heavy dealer gamma sits near a real dark-pool print is a spot worth watching.
# Dark pool levels come from the equities side of the API.
dp = requests.post(f"{BASE}/equities/tool/dark-pool-levels",
headers=HEADERS, json={"filter": {"ticker": "SPY"}},
timeout=30).json()
node = exposure_by_strike("SPY")
net = net_gamma_by_strike(node) # from Recipe 1
print(f"Net gamma by strike (dealer hedging): {net}")
print(f"Dark pool levels (real prints): {dp.get('data')}")
# Overlay the two: heavy dealer gamma near a dark-pool print is a spot to watch.
Endpoint names for the equities/dark-pool side (dark-pool-levels, dark-flow) follow the same /v1/equities/tool/<name> pattern. Confirm exact request bodies in the API docs.
Pricing & limits
The Quant Data API is $149.99/mo (or $124.99/mo billed annually), with a 240-requests-per-minute rate limit and no monthly request quota. One plan covers all 30+ endpoints, options flow, gamma/Greek exposure, and dark pool, over both REST and MCP, with 365+ days of historical lookback.
Price | $149.99/mo · $124.99/mo billed annually · Enterprise on request |
Rate limit | 240 requests/minute (no monthly quota) |
History | 365+ days lookback |
Endpoints | 30+ (options + equities + news), all included |
Access | REST + hosted MCP server, one key |
🟦 Start building. Generate an API key and pull live gamma exposure today → quantdata.us/pricing. One key, both REST and MCP, every endpoint included. (Pricing verified 2026-06-30; confirm current terms on the pricing page.)
FAQ
Does Quant Data have a gamma exposure (GEX) API?
Yes. Quant Data exposes gamma exposure through POST /v1/options/tool/exposure-by-strike with greekMode: "GAMMA", returning per-strike call and put gamma for 6,000+ tickers, straight from exchange-licensed options data. You work with the raw per-strike gamma directly, or aggregate it into a net-per-strike view.
How do I get GEX data in Python?
Send a POST to https://api.quantdata.us/v1/options/tool/exposure-by-strike with the requests library, a Bearer key, and a body of {"greekMode": "GAMMA", "representationMode": "PER_ONE_PERCENT_MOVE", "filter": {"ticker": "SPY"}}. The full copy-paste snippet is in the 60-seconds section above.
What's the difference between GEX, DEX, VEX, and CHEX?
They're the same exposure-by-strike endpoint with a different greekMode: GAMMA (GEX), DELTA (DEX), VANNA (what's marketed as VEX), and CHARM (CHEX). GEX reads dealer hedging pressure and the net long/short gamma regime, DEX reads directional positioning, VEX/vanna reads vol-driven flows, and CHEX reads time-decay drift.
How much history does the GEX API include?
The Quant Data API provides a 365+ day historical lookback. Pass any past weekday as sessionDate to pull gamma exposure for that session; omit it to get the latest session.
Can I get gamma exposure data through an MCP server / in Claude?
Yes. Connect the hosted MCP server at https://api.quantdata.us/mcp (Bearer-authed) to Claude Desktop, Claude Code, ChatGPT Pro+, or Cursor, and ask in plain English, for example, "What does SPY's gamma exposure look like today?" The MCP server exposes all 30+ endpoints as named tools (the gamma ones are qd_get_exposure_by_strike and qd_get_interval_map), so no code is required.
How is Quant Data different from FlashAlpha or SpotGamma?
Quant Data gives you the whole options-positioning stack through one exchange-licensed API and one key: gamma exposure and the full Greek set, an intraday gamma map, options flow, and dark pool, delivered live across 6,000+ tickers, for a flat $149.99/mo. A cheaper-looking entry tier elsewhere usually trades away scope. FlashAlpha's Basic plan, for instance, covers only a short list of index and ETF symbols (SPY, QQQ, IWM, SPX, VIX, RUT), serves 15-second-delayed data, and caps you at 100 requests a day; live data and wider coverage sit on far pricier tiers. Quant Data is live rather than delayed, spans 6,000+ tickers rather than a handful, includes dark pool data, which is not part of FlashAlpha's published plans, and still lands below their comparable multi-symbol tier. Compared at equal scope, Quant Data is the fresher and cheaper option, not the pricier one. (Competitor details as of June 2026 and subject to change; verify current terms with the provider.)
What does the GEX API cost?
$149.99/mo, or $124.99/mo billed annually, with Enterprise pricing on request. One plan includes all 30+ endpoints (including dark pool), a 240 req/min rate limit with no monthly quota, and both REST and MCP access. See quantdata.us/pricing.