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.
The leaderboard and strike-flow endpoints are the wide and narrow ends of the same lens. The leaderboard scans the entire 0DTE market by heat, pin risk, raw flow, or charm intensity, so you spend attention only where it pays; strike-flow then drills into any one name for the per-strike signed delta-dollars, gamma-dollars, and contracts driving it. Scan with one call, drill with the next, and route a snapshot in between for the decision layer - the whole same-day market, ranked and explained, from three endpoints.
