Help us double down on what's working, instead of guessing. Takes 5 seconds, totally optional.
The 0DTE Flow Leaderboard and Strike-Flow API: Scan the Market, Then Drill In
Two Alpha endpoints that work as a pair. The 0DTE flow leaderboard ranks the whole market by heat, pin risk, raw flow, or charm intensity so you find the hottest same-day names in one call. Strike-flow then drills into any name for the per-strike signed aggressor delta-dollars, gamma-dollars, and contracts driving the move. Scan, then drill. Alpha plan.
If you want a 0DTE options scanner that ranks symbols by dealer-flow intensity, or a per-strike signed-flow feed to see which strikes are moving a name, these two endpoints are it: GET /v1/flow/zero-dte/leaderboard and GET /v1/flow/zero-dte/strike-flow/{symbol}. They are the cross-symbol and per-strike ends of the live 0DTE flow family — the full surface is in the pillar, The Live 0DTE Flow API.
Read this first. Both endpoints are built on FlashAlpha's flow model — effective open interest plus aggressor-classified trades — so the rankings and per-strike dollars are estimates, not exact order flow. The JSON below uses illustrative placeholder numbers. Read them as a relative map of where pressure is concentrating.
The Leaderboard: Scan the Whole Market
GET /v1/flow/zero-dte/leaderboard?metric=heat&n=20 (Alpha plan) ranks every actively-sampled 0DTE symbol by a single metric, descending. One call, the whole landscape.
The metric parameter changes the question you are asking the market:
metric
Ranks by
Use it to find
heat
Cumulative dealer hedge-flow normalized by net GEX
Names where flow is large relative to standing gamma — "something is happening here."
pin_risk
Current pin score (0-100)
Names where a magnet is locking price in — pin-trade candidates.
abs_flow
Absolute call + put hedge-flow in the latest bar
Raw activity — the busiest chains right now, regardless of regime.
charm_intensity
Absolute charm-dollars-per-hour
Names where time decay is forcing the fastest re-hedging into the close.
n caps the list (1-100, default 20). The leaderboard is cached for ~30 seconds server-side, so a tight scan loop is cheap. Pick the metric to match your style: a premium seller scans pin_risk, a momentum trader scans heat or abs_flow, a closing-hour specialist scans charm_intensity.
SDK note: the leaderboard is the one endpoint in this family without a typed SDK wrapper today, so call it as a direct REST request (shown below). The rest of the family - flow_zero_dte_snapshot, _series, _hedge_flow, _heatmap, and _strike_flow - ships typed methods in the Python, JavaScript, C#, Go, and Java packages.
Rank every 0DTE name by heat, pin risk, flow, or charm — in one call
Then drill into any name's per-strike signed flow. Alpha plan.
Once the leaderboard names a symbol, GET /v1/flow/zero-dte/strike-flow/{symbol}?bar=1m&minutes=60 (Alpha plan) shows you which strikes are doing the work. For each bar it returns three parallel arrays — signed delta-dollars, signed gamma-dollars, and contract counts — indexed against a shared strikes_grid.
Ascending strikes; index j aligns with index j in each bar's three arrays.
signed_delta_dollars
Net signed aggressor delta-dollars at that strike this bar. Positive = net bullish-delta flow (call buying or put selling); negative = bearish-delta flow.
signed_gamma_dollars
The gamma-dollar equivalent — where the convexity is being added.
contracts
Signed net contract count at that strike this bar.
gap_intervals
Windows the sampler skipped; render as blanks.
Strike-flow is the model input the heatmap aggregates and the hedge-flow sums. Reach for it when you need to attribute a move to specific strikes — to see, for example, that QQQ's "heat" is almost entirely one strike's call buying rather than a broad bid.
Scan, Then Drill: the Pattern
The two endpoints are designed to chain. Scan the market for the hottest names, pull a snapshot on the leader for the decision layer, then drop to strike-flow to see exactly where the pressure sits:
import requests
from flashalpha import FlashAlpha
H = {"X-Api-Key": "YOUR_KEY"}
fa = FlashAlpha("YOUR_KEY")
# 1. Scan: the leaderboard has no SDK wrapper yet — call it directly
board = requests.get(
"https://lab.flashalpha.com/v1/flow/zero-dte/leaderboard",
headers=H, params={"metric": "heat", "n": 10},
).json()
top = board["entries"][0]["symbol"]
print(f"Hottest 0DTE name: {top} (heat {board['entries'][0]['value']:.2f})")
# 2. Drill: strike-flow has a typed SDK method
sf = fa.flow_zero_dte_strike_flow(top, bar="1m", minutes=30)
strikes = sf["strikes_grid"]
last = sf["bars"][-1]
# Rank strikes by absolute signed delta-dollars this bar
ranked = sorted(zip(strikes, last["signed_delta_dollars"]),
key=lambda x: abs(x[1]), reverse=True)
print(f"{top} spot {last['spot']} — top strikes by signed delta-$:")
for k, v in ranked[:3]:
lean = "bullish" if v > 0 else "bearish"
print(f" {k}: {v:+,.0f} ({lean})")
# 1. Scan the market by heat
curl -H "X-Api-Key: YOUR_KEY" \
"https://lab.flashalpha.com/v1/flow/zero-dte/leaderboard?metric=heat&n=10"
# 2. Drill into the leader's per-strike signed flow
curl -H "X-Api-Key: YOUR_KEY" \
"https://lab.flashalpha.com/v1/flow/zero-dte/strike-flow/QQQ?bar=1m&minutes=30"
$ leaderboard ranks the market | strike-flow explains a single name
API Access and Pricing
Both endpoints are on the Alpha plan — the model-input granularity of the 0DTE flow family. The decision endpoints (snapshot, series, hedge-flow) are one tier down on Growth.
Yes. GET /v1/flow/zero-dte/leaderboard ranks every actively-sampled 0DTE symbol by one of four metrics — heat (flow relative to gamma), pin_risk (pin score), abs_flow (raw latest-bar activity), or charm_intensity (decay-driven re-hedging) — descending, in a single call. Set n for the list length (1-100). It is on the Alpha plan and cached around 30 seconds, so a tight scan loop is cheap.
Heat is cumulative dealer hedge-flow normalized by net GEX — flow relative to the standing gamma it is acting against. A high heat value means today's flow is large compared to the gamma base, which is the "something is happening here" signal. It differs from abs_flow, which is just raw recent activity: a quiet chain with a small gamma base can rank high on heat without ranking high on raw flow.
Strike-flow returns the signed aggressor detail per strike per bar — net delta-dollars, gamma-dollars, and contract counts — the raw model input. The heatmap aggregates a single chosen metric (GEX, DEX, signed flow, and so on) per strike into a value matrix optimized for plotting. Use the heatmap to visualize where positioning concentrates over time; use strike-flow to attribute the exact signed dollars and contracts driving a single name.
A positive signed_delta_dollars at a strike means net bullish-delta aggressor flow there in that bar (call buying or put selling); negative means bearish-delta flow. The contracts array carries the signed net contract count, and signed_gamma_dollars shows where convexity is being added. All three arrays are parallel to the strikes_grid by index, so values[j] corresponds to strikes_grid[j]. They are model estimates, so read them as relative pressure, not exact order flow.
Both are on the Alpha plan (from $1,199/mo, unlimited requests), alongside the 0DTE heatmap. They are the model-input granularity of the flow family; the decision endpoints snapshot, series, and hedge-flow are one tier down on Growth. Calling either below Alpha returns a 403 tier_restricted with the required plan name.
