Help us double down on what's working, instead of guessing. Takes 5 seconds, totally optional.
The 0DTE Gamma Heatmap API: Strike-by-Time GEX, a HIRO and Heatseeker Alternative
A strike-by-time gamma heatmap is the chart SpotGamma TRACE and Skylit Heatseeker are known for. The FlashAlpha /v1/flow/zero-dte/heatmap endpoint returns the same strike x time matrix for today's 0DTE chain as plain JSON - six metrics (GEX, DEX, VEX, CHEX, OI, signed flow), raw or delta mode - so you can render it in your own stack or feed it to a model. A developer-first HIRO and Heatseeker alternative. Alpha plan.
If you want a 0DTE gamma heatmap API, an intraday GEX-by-strike matrix, a SpotGamma TRACE alternative, or a Skylit Heatseeker alternative you can pull from code instead of staring at a dashboard, this is the endpoint. GET /v1/flow/zero-dte/heatmap/{symbol} returns a strike-by-time value matrix for the chain expiring today, on the Alpha plan. For the whole live-0DTE surface this sits inside, start with the pillar, The Live 0DTE Flow API.
Read this first. The heatmap is built on FlashAlpha's flow model — effective open interest plus aggressor-classified trades — not a dealer's actual book. The values are estimates. The JSON below uses illustrative placeholder numbers. Read the bands, the shifts, and the signs as a relative map of where positioning sits, not as exact dealer inventory.
What a Strike-by-Time Gamma Heatmap Shows
A single GEX snapshot tells you where dealer gamma sits right now. A heatmap adds the second dimension every 0DTE trader actually wants: how that profile is moving through the session. Strikes run down one axis, time runs across the other, and color encodes the metric at each cell. Read across a row to see how one strike's gamma builds or bleeds; read down a column to see the whole profile at one instant; watch the bright bands migrate to see the magnet and the walls shift in real time.
That migration is the signal. When a bright positive-gamma band locks onto a strike and stays there, that strike is pinning. When the band that was bracketing price thins out, the walls are weakening and a breakout gets easier. On a 0DTE chain this all happens within hours, which is why a static morning chart misses it and a live matrix does not.
The strike-by-time 0DTE heatmap, as JSON you can render anywhere
Six metrics, raw or delta mode. No dashboard lock-in. Alpha plan.
GET /v1/flow/zero-dte/heatmap/{symbol}?bar=1m&metric=gex&mode=raw&minutes=60 (Alpha plan). The response pulls the strikes out into a top-level strikes_grid, and each bar's values array is parallel by index — so you index it as values[bar][strike], exactly the shape a heatmap plotting library wants. That layout is roughly 30% smaller on the wire than per-cell objects.
The y-axis: every strike in the matrix, ascending. Index j here lines up with index j in every bar's values.
bars[].t
The x-axis: the timestamp of this column (UTC).
bars[].spot
Underlying spot at that bar — overlay it as a line to see price walk through the gamma field.
bars[].values
The metric value at each strike for that bar, parallel to strikes_grid. This is the color channel.
tier_used
Which storage tier served the data (raw intraday). Informational.
gap_intervals
Any windows where the sampler did not write (rare). Render them as blanks rather than interpolating.
Six Metrics: Choosing the Lens
The metric parameter swaps what the color channel represents. Same grid, different question.
metric
Reads as
gex
Gamma exposure per strike. The default. Bright positive bands are pin/stabilizing zones; deep negative bands are accelerant zones.
dex
Delta exposure — directional dealer positioning by strike.
vex
Vega exposure — where the chain is sensitive to a vol move.
chex
Charm exposure — where time decay is forcing the fastest delta re-hedging into the close.
oi
Effective open interest by strike — the raw positioning mass.
signed_flow
Net signed aggressor flow — where customers are actively buying (positive) or selling (negative) right now.
Raw vs Delta Mode: Level vs Change
The mode parameter is the one that separates a static picture from a flow read:
mode=raw shows the level of the metric at each cell — the standing gamma/OI/flow profile. Use it to see where the walls and magnet sit.
mode=delta shows the bar-over-bar change — where positioning is landing this minute. This is the closest analog to a HIRO-style "what just changed" read: a strike lighting up in delta mode is where fresh flow is concentrating, often before it is obvious in the raw level.
A common workflow is to render both: raw mode as the background field, delta mode as the overlay that flags the active strikes.
Pull It and Plot It
The matrix layout drops straight into any heatmap library. Here it is pulled and rendered with matplotlib in a dozen lines:
import numpy as np
import matplotlib.pyplot as plt
from flashalpha import FlashAlpha
fa = FlashAlpha("YOUR_KEY")
d = fa.flow_zero_dte_heatmap("SPX", metric="gex", mode="raw", bar="1m", minutes=120)
strikes = d["strikes_grid"] # y-axis
times = [b["t"][11:16] for b in d["bars"]] # x-axis (HH:MM)
spot = [b["spot"] for b in d["bars"]]
# values[bar][strike] -> transpose to grid[strike][bar] for imshow
grid = np.array([b["values"] for b in d["bars"]]).T
plt.imshow(grid, aspect="auto", origin="lower", cmap="RdBu_r",
extent=[0, len(times), strikes[0], strikes[-1]])
plt.plot(np.arange(len(times)) + 0.5, spot, color="black", lw=1) # spot overlay
plt.colorbar(label=f"{d['metric'].upper()} ({d['mode']})")
plt.title(f"{d['symbol']} 0DTE {d['metric'].upper()} heatmap")
plt.show()
import { FlashAlpha } from 'flashalpha';
const fa = new FlashAlpha('YOUR_KEY');
const d = await fa.flowZeroDteHeatmap('SPX', { metric: 'gex', mode: 'delta', bar: '1m', minutes: 120 });
// Plotly-ready: z is values[bar][strike], so transpose for [strike][bar]
const z = d.strikes_grid.map((_, j) => d.bars.map(b => b.values[j]));
const trace = {
type: "heatmap", colorscale: "RdBu", reversescale: true,
x: d.bars.map(b => b.t), y: d.strikes_grid, z,
};
Plotly.newPlot("chart", [trace], { title: `${d.symbol} 0DTE ${d.metric}` });
# Raw GEX level, last hour, 1-minute bars
curl -H "X-Api-Key: YOUR_KEY" \
"https://lab.flashalpha.com/v1/flow/zero-dte/heatmap/SPX?metric=gex&mode=raw&bar=1m&minutes=60"
# Where is fresh positioning landing? signed_flow in delta mode
curl -H "X-Api-Key: YOUR_KEY" \
"https://lab.flashalpha.com/v1/flow/zero-dte/heatmap/SPY?metric=signed_flow&mode=delta&bar=1m"
$ values[bar][strike] is parallel to strikes_grid | transpose for most plotters
FlashAlpha vs SpotGamma TRACE vs Skylit Heatseeker
SpotGamma's TRACE and Skylit's Heatseeker both popularized the intraday strike-by-time heatmap, and both are excellent dashboards. The gap they leave is programmatic access: you watch their chart, you do not pull their matrix. FlashAlpha closes that gap.
FlashAlpha 0DTE Heatmap
SpotGamma TRACE
Skylit Heatseeker
Delivery
REST API + SDKs (JSON matrix)
Dashboard
Dashboard
Render in your own stack
Yes
No
No
Metrics selectable
6 (GEX/DEX/VEX/CHEX/OI/signed flow)
Fixed set
Heat / flow
Raw level + delta (change) mode
Yes
Partial
Partial
Pairs with numeric pin score + setup classifier
Yes
No
No
Feed to a model / backtest
Yes (structured JSON)
No
No
The point is not that the heatmap is better looking — it is that it is callable. You can render it in your own dashboard, alert on a band crossing a strike, or feed the matrix straight into a model.
The Layer Underneath: Strike-Flow
The heatmap aggregates a metric per strike. When you want the signed aggressor detail that feeds it — net delta-dollars, gamma-dollars, and contract counts per strike per bar — call the companion endpoint, GET /v1/flow/zero-dte/strike-flow/{symbol}, also on Alpha. It returns three parallel arrays against the same strikes_grid, covered in the strike-flow and leaderboard guide.
API Access and Pricing
The heatmap and strike-flow endpoints are on the Alpha plan — they are the model-input granularity of the 0DTE flow family. The decision endpoints (snapshot, series, hedge-flow) sit one tier down on Growth.
Yes. GET /v1/flow/zero-dte/heatmap/{symbol} returns a strike-by-time value matrix for today's 0DTE chain as JSON. You choose the metric (GEX, DEX, VEX, CHEX, OI, or signed flow) and the mode (raw level or bar-over-bar delta). The strikes are a top-level array and each bar's values line up with it by index, so it drops straight into any heatmap plotting library. It is on the Alpha plan.
Raw mode shows the level of the metric at each strike-time cell — the standing profile, where the walls and magnet sit. Delta mode shows the bar-over-bar change — where positioning is landing this minute. Delta mode is the closest analog to a "what just changed" read and often flags an active strike before it is obvious in the raw level. Many traders render raw as the background and delta as the overlay.
It covers the same strike-by-time heatmap those products are known for, but as a developer API rather than a dashboard. You pull the matrix as JSON and render it in your own stack, alert on it, or feed it to a model — and it pairs with FlashAlpha's numeric pin score, calibrated probabilities, and trade-setup classifier. The data is FlashAlpha's own, derived from effective open interest and aggressor-classified trades; it is not resold from SpotGamma or Skylit.
The response has a single strikes_grid array (ascending strikes) and one bar per timestamp. Each bar's values array is parallel by index, so values[j] is the metric at strikes_grid[j] for that bar. To feed a typical heatmap plotter you transpose to grid[strike][bar]. The gap_intervals array marks any windows the sampler skipped, which you should render as blanks rather than interpolate.
The 0DTE heatmap and strike-flow endpoints are on the Alpha plan (from $1,199/mo, unlimited requests). They are the model-input granularity of the flow family; the decision endpoints (snapshot, series, hedge-flow) are one tier down on Growth. Calling the heatmap below Alpha returns a 403 tier_restricted with the required plan name.
