Build a Key Levels Monitor with an API: Put/Call Walls, Gamma Flip, and Max Pain Tracker

If you're searching for a put/call wall API, a gamma flip data source, a max pain API, or trying to build a key options levels tracker without computing gamma exposure yourself, this is the guide. A single free endpoint gives you every level that matters: gamma flip, call wall, put wall, max positive gamma, max negative gamma, highest OI strike, and 0DTE magnet. No options chain sourcing, no dealer modelling, no gamma computation.

What Each Level Means

Key levels are specific price points derived from how options market makers are positioned. Each level tells you something different about where dealer hedging will create predictable price behavior.

Gamma Flip

The gamma flip is the price where dealer hedging flips from stabilising to amplifying. Above the flip, dealers are long gamma: they buy dips and sell rips, dampening volatility and pinning price. Below the flip, dealers are short gamma: they hedge in the same direction as the move, amplifying it. This single number tells you whether to expect mean reversion or trend continuation.

Call Wall

The call wall is the strike with the highest concentration of call gamma. It acts as resistance because as price approaches this level, dealers who are long those calls must sell the underlying to stay hedged. The closer price gets, the stronger the selling pressure. Think of it as a ceiling enforced by hedging flows.

Put Wall

The put wall is the strike with the highest concentration of put gamma. It acts as support because as price falls toward this level, dealers who are long those puts must buy the underlying to stay hedged. It's a floor enforced by dealer buying.

Max Pain

Max pain is the strike price where the total value of outstanding options (calls and puts combined) would be at its lowest if the underlying expired there. It acts as a gravitational pull toward expiration, particularly for monthly and weekly opex. Market makers have incentive to pin price near max pain because it minimises their payout.

0DTE Magnet

The zero DTE magnet is the strike where same-day expiration flows concentrate during the current session. With 0DTE options now representing a massive share of total volume, this intraday gravitational price level can dominate short-term price action. It changes every session and often shifts throughout the day as new 0DTE positions are opened.

Highest OI Strike

The most crowded strike by total open interest. Large OI concentrations act as magnets because delta-hedging activity is highest where the most contracts exist. When price approaches a high-OI strike, the hedging flows from all those contracts create strong support or resistance depending on whether calls or puts dominate.

The API Approach: One Call, All Levels

The FlashAlpha /v1/exposure/levels/{symbol} endpoint returns every key level in a single JSON response. It's on the free tier — no credit card, no trial expiration. Here's how the endpoints stack up:

The levels endpoint is the gateway. You get the actionable numbers on the free plan. When you need the per-strike detail behind those numbers, the GEX endpoint shows you the full gamma profile. When you need regime analysis and dealer hedging estimates, the summary endpoint on the Growth plan adds that layer.

Quick Start: All 6 Languages

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
levels = fa.exposure_levels("SPY")

print(f"Gamma Flip:     {levels['gamma_flip']}")
print(f"Call Wall:      {levels['call_wall']}")
print(f"Put Wall:       {levels['put_wall']}")
print(f"Max Pain:       {levels['highest_oi_strike']}")
print(f"0DTE Magnet:    {levels['zero_dte_magnet']}")
print(f"Price:          {levels['underlying_price']}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_KEY');
const levels = await fa.exposureLevels('SPY');

console.log(`Gamma Flip:  ${levels.gamma_flip}`);
console.log(`Call Wall:   ${levels.call_wall}`);
console.log(`Put Wall:    ${levels.put_wall}`);
console.log(`0DTE Magnet: ${levels.zero_dte_magnet}`);
console.log(`Price:       ${levels.underlying_price}`);

using FlashAlpha;

var fa = new FlashAlphaClient("YOUR_KEY");
var levels = await fa.ExposureLevelsAsync("SPY");

Console.WriteLine($"Gamma Flip:  {levels.GammaFlip}");
Console.WriteLine($"Call Wall:   {levels.CallWall}");
Console.WriteLine($"Put Wall:    {levels.PutWall}");
Console.WriteLine($"Price:       {levels.UnderlyingPrice}");

package main

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

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

    fmt.Printf("Gamma Flip:  %.1f\n", levels.GammaFlip)
    fmt.Printf("Call Wall:   %.1f\n", levels.CallWall)
    fmt.Printf("Put Wall:    %.1f\n", levels.PutWall)
    fmt.Printf("0DTE Magnet: %.1f\n", levels.ZeroDteMagnet)
}

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

FlashAlphaClient fa = new FlashAlphaClient("YOUR_KEY");
JsonObject levels = fa.exposureLevels("SPY");

System.out.println("Gamma Flip: " + levels.get("gamma_flip").getAsDouble());
System.out.println("Call Wall:  " + levels.get("call_wall").getAsDouble());
System.out.println("Put Wall:   " + levels.get("put_wall").getAsDouble());

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

Full Response Walkthrough

Here's what the /v1/exposure/levels/SPY response looks like:

{
  "symbol": "SPY",
  "underlying_price": 587.23,
  "as_of": "2026-03-29T15:45:00Z",
  "levels": {
    "gamma_flip": 585.0,
    "call_wall": 600.0,
    "put_wall": 570.0,
    "max_positive_gamma": 590.0,
    "max_negative_gamma": 575.0,
    "highest_oi_strike": 590.0,
    "zero_dte_magnet": 587.0
  }
}

Note: the seven level values are nested under the levels key. Access them as resp["levels"]["call_wall"] in Python, resp.levels.callWall in JS, etc. underlying_price stays at the top level so you can compare against the levels in one response.

Every field is immediately actionable:

• underlying_price — Current price of the underlying. Compare against every level to determine proximity and regime.
• gamma_flip (585.0) — Price is at 587.23, which is above the flip. Dealers are long gamma. Expect mean reversion and pinning behavior.
• call_wall (600.0) — Resistance ceiling. As price approaches 600, dealer hedging creates selling pressure. A break above requires significant volume or a shift in positioning.
• put_wall (570.0) — Support floor. Dealer buying intensifies as price falls toward 570. Provides a cushion.
• max_positive_gamma (590.0) — The strike with the largest positive gamma. Strongest pinning effect here.
• max_negative_gamma (575.0) — The strike with the largest negative gamma. Most amplified moves if price reaches this level.
• highest_oi_strike (590.0) — Where the most contracts sit. Gravitational pull for price.
• zero_dte_magnet (587.0) — Where 0DTE flows are pulling price today. Changes each session.
• as_of — Snapshot timestamp. Levels update throughout the trading day as OI and positioning shift.

Building the Monitor: Section by Section

1. Price vs. Levels Gauge

The most basic view: where is price relative to the key levels? Build a gauge that shows price position within the put wall to call wall range, with the gamma flip as the regime boundary.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
levels = fa.exposure_levels("SPY")

price = levels["underlying_price"]
flip = levels["gamma_flip"]
cw = levels["call_wall"]
pw = levels["put_wall"]

# Regime
regime = "POSITIVE GAMMA" if price > flip else "NEGATIVE GAMMA"

# Position within range (0% = put wall, 100% = call wall)
range_pct = (price - pw) / (cw - pw) * 100

print(f"Price:      {price:.2f}")
print(f"Put Wall:   {pw:.1f}")
print(f"Call Wall:  {cw:.1f}")
print(f"Gamma Flip: {flip:.1f}")
print(f"Regime:     {regime}")
print(f"Range Pos:  {range_pct:.1f}%  (0% = put wall, 100% = call wall)")

if range_pct > 85:
    print("WARNING: Price near call wall resistance")
elif range_pct < 15:
    print("WARNING: Price near put wall support")

On a web dashboard, render this as a horizontal bar with color zones. Green above gamma flip, red below. Markers for each level. Price as a moving indicator.

2. Level Distance Table

A compact table showing distance from current price to each level in dollars and percentage. Sort by proximity to identify the nearest support/resistance.

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

level_map = [
    ("Gamma Flip", levels["gamma_flip"]),
    ("Call Wall", levels["call_wall"]),
    ("Put Wall", levels["put_wall"]),
    ("Max +Gamma", levels["max_positive_gamma"]),
    ("Max -Gamma", levels["max_negative_gamma"]),
    ("Highest OI", levels["highest_oi_strike"]),
    ("0DTE Magnet", levels["zero_dte_magnet"]),
]

# Sort by absolute distance
level_map.sort(key=lambda x: abs(price - x[1]))

print(f"{'Level':<16} {'Strike':>8} {'Dist ($)':>10} {'Dist (%)':>10} {'Direction':>10}")
print("-" * 60)
for label, strike in level_map:
    dist = strike - price
    pct = (dist / price) * 100
    direction = "above" if dist > 0 else "below"
    print(f"{label:<16} {strike:>8.1f} {dist:>+10.2f} {pct:>+9.2f}% {direction:>10}")

This table answers the question traders care about most: how far is price from the nearest level, and what happens when it gets there?

3. Level Breach Alerts

The highest-signal events are when price crosses a key level. A gamma flip breach changes the entire regime. A wall breach means the old support/resistance has failed. Poll the levels endpoint and compare against previous values.

import time

fa = FlashAlpha("YOUR_KEY")
prev_regime = None

while True:
    levels = fa.exposure_levels("SPY")
    price = levels["underlying_price"]
    flip = levels["gamma_flip"]
    regime = "POS" if price > flip else "NEG"

    if prev_regime and regime != prev_regime:
        print(f"ALERT: Gamma regime change! {prev_regime} -> {regime}")
        print(f"  Price: {price:.2f}, Flip: {flip:.1f}")
        # Send notification: email, Slack, Discord, etc.

    # Check wall proximity
    cw_dist = abs(price - levels["call_wall"]) / price * 100
    pw_dist = abs(price - levels["put_wall"]) / price * 100

    if cw_dist < 0.3:
        print(f"ALERT: Price within 0.3% of call wall ({levels['call_wall']})")
    if pw_dist < 0.3:
        print(f"ALERT: Price within 0.3% of put wall ({levels['put_wall']})")

    prev_regime = regime
    time.sleep(300)  # Poll every 5 minutes

4. Multi-Symbol Levels Heatmap

Scan your watchlist and compare where each symbol sits relative to its levels. A heatmap reveals which names are near support, near resistance, or in negative gamma territory.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
symbols = ["SPY", "QQQ", "IWM", "TSLA", "AAPL", "NVDA", "AMD", "META"]

print(f"{'Sym':<6} {'Price':>8} {'Flip':>8} {'Regime':<6} {'CW':>8} {'PW':>8} {'Range%':>7} {'0DTE':>8}")
print("-" * 72)

for sym in symbols:
    lv = fa.exposure_levels(sym)
    p = lv["underlying_price"]
    flip = lv["gamma_flip"]
    cw = lv["call_wall"]
    pw = lv["put_wall"]
    regime = "+" if p > flip else "-"
    rng = (p - pw) / (cw - pw) * 100 if cw != pw else 50

    print(f"{sym:<6} {p:>8.2f} {flip:>8.1f} {'POS' if regime == '+' else 'NEG':<6} "
          f"{cw:>8.1f} {pw:>8.1f} {rng:>6.1f}% {lv['zero_dte_magnet']:>8.1f}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_KEY');
const symbols = ['SPY', 'QQQ', 'IWM', 'TSLA', 'AAPL', 'NVDA'];

const rows = await Promise.all(
  symbols.map(async (sym) => {
    const lv = await fa.exposureLevels(sym);
    const p = lv.underlying_price;
    const rangePct = ((p - lv.put_wall) / (lv.call_wall - lv.put_wall)) * 100;
    return {
      symbol: sym,
      price: p,
      gamma_flip: lv.gamma_flip,
      regime: p > lv.gamma_flip ? 'POS' : 'NEG',
      call_wall: lv.call_wall,
      put_wall: lv.put_wall,
      range_pct: rangePct.toFixed(1),
    };
  })
);

// Sort by distance to gamma flip (closest first)
rows.sort((a, b) =>
  Math.abs(a.price - a.gamma_flip) - Math.abs(b.price - b.gamma_flip)
);
console.table(rows);

Symbols where Range% is above 85% are near their call wall (resistance). Below 15%, near their put wall (support). Negative regime symbols deserve extra attention — moves will be amplified.

5. Intraday Level Tracking

Key levels shift throughout the trading day as new options are opened and closed. Poll the levels endpoint periodically and chart how levels move relative to price.

import time
import csv

fa = FlashAlpha("YOUR_KEY")

with open("spy_levels_intraday.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["timestamp", "price", "gamma_flip", "call_wall",
                     "put_wall", "zero_dte_magnet", "highest_oi"])

    for _ in range(78):  # 6.5 hours at 5-min intervals
        lv = fa.exposure_levels("SPY")
        writer.writerow([
            lv["as_of"],
            lv["underlying_price"],
            lv["gamma_flip"],
            lv["call_wall"],
            lv["put_wall"],
            lv["zero_dte_magnet"],
            lv["highest_oi_strike"],
        ])
        time.sleep(300)

Plot price as a line with gamma flip, call wall, and put wall as horizontal lines that shift over time. The 0DTE magnet is particularly interesting to track intraday — it often converges toward price as same-day options decay.

6. Combining Levels with GEX Chart

The levels endpoint tells you WHERE the key levels are. The GEX endpoint tells you WHY they exist by showing per-strike gamma exposure. Overlay the levels as horizontal lines on a GEX bar chart for the complete picture.

import matplotlib.pyplot as plt
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
gex = fa.gex("SPY")
levels = fa.exposure_levels("SPY")

strikes = [s["strike"] for s in gex["strikes"]]
net_gex = [s["net_gex"] for s in gex["strikes"]]
colors = ["#16a34a" if g >= 0 else "#dc2626" for g in net_gex]

fig, ax = plt.subplots(figsize=(14, 6))
ax.bar(strikes, net_gex, color=colors, width=0.8)

# Overlay key levels as vertical lines
ax.axvline(levels["gamma_flip"], color="#f59e0b", linewidth=2, label="Gamma Flip")
ax.axvline(levels["call_wall"], color="#3b82f6", linewidth=2, linestyle="--", label="Call Wall")
ax.axvline(levels["put_wall"], color="#ef4444", linewidth=2, linestyle="--", label="Put Wall")
ax.axvline(levels["zero_dte_magnet"], color="#8b5cf6", linewidth=1.5, linestyle=":", label="0DTE Magnet")
ax.axvline(gex["underlying_price"], color="#e4e4e7", linewidth=1, linestyle="-", label="Spot Price")

ax.set_xlabel("Strike")
ax.set_ylabel("Net GEX ($)")
ax.set_title(f"SPY: GEX by Strike with Key Levels")
ax.legend(loc="upper left")
plt.tight_layout()
plt.savefig("spy_gex_levels.png", dpi=150)

This view makes the connection explicit: the call wall is where the tallest green bar is, the put wall is where the tallest red bar is, and the gamma flip is where the bars cross from negative to positive. The visual reinforces what the numbers already tell you.

Trading Signals from Key Levels

Key levels translate directly into trading heuristics. These are not guaranteed outcomes, but they represent the statistical tendencies created by dealer hedging flows.

Gamma Regime Signals

• Price above gamma flip (positive gamma) — Dealers hedge against moves. Expect mean reversion, lower realised vol, tighter ranges. Favour selling volatility: short straddles, iron condors, credit spreads. Intraday dips are likely to be bought by dealers.
• Price below gamma flip (negative gamma) — Dealers hedge with moves. Expect trend continuation, higher realised vol, wider ranges. Favour buying volatility: long straddles, debit spreads, momentum strategies. Intraday moves are amplified by dealer hedging.

Wall Signals

• Price approaching call wall — Likely resistance. Dealer selling intensifies. Fade rallies into the wall or tighten stops on longs. A break above the call wall is significant — it means the old resistance is gone and positioning must adjust.
• Price approaching put wall — Likely support. Dealer buying intensifies. Consider long entries near the wall or tighten stops on shorts. A break below the put wall removes the floor and often triggers accelerated selling.

Convergence Signals

• Multiple levels clustered at the same strike — When gamma flip, highest OI, and 0DTE magnet converge near the same price, that level has outsized gravitational pull. Price is likely to pin there.
• Price between put wall and gamma flip — Negative gamma territory with support below. Volatile but with a cushion. Expect choppy, mean-reverting-within-a-range behavior.
• Tight call wall to put wall range — Walls are close together. Dealers are concentrating hedging in a narrow band. Expect a compressed range — until it breaks.

Multi-Symbol Scanner: Distance to Gamma Flip

Scan your watchlist and sort by distance to gamma flip. Symbols closest to their flip are the ones most likely to experience a regime change — and regime changes are the highest-signal events in GEX analysis.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")
watchlist = ["SPY", "QQQ", "IWM", "TSLA", "AAPL", "NVDA", "AMD", "META", "AMZN", "MSFT"]

results = []
for sym in watchlist:
    lv = fa.exposure_levels(sym)
    price = lv["underlying_price"]
    flip = lv["gamma_flip"]
    dist_pct = ((price - flip) / price) * 100
    results.append({
        "symbol": sym,
        "price": price,
        "flip": flip,
        "dist_pct": dist_pct,
        "regime": "POS" if price > flip else "NEG",
        "call_wall": lv["call_wall"],
        "put_wall": lv["put_wall"],
    })

# Sort by absolute distance to gamma flip (closest first)
results.sort(key=lambda r: abs(r["dist_pct"]))

print(f"{'Symbol':<8} {'Price':>8} {'Flip':>8} {'Dist%':>8} {'Regime':<6} {'CW':>8} {'PW':>8}")
print("-" * 62)
for r in results:
    print(f"{r['symbol']:<8} {r['price']:>8.2f} {r['flip']:>8.1f} {r['dist_pct']:>+7.2f}% "
          f"{r['regime']:<6} {r['call_wall']:>8.1f} {r['put_wall']:>8.1f}")

Run this at market open to see which names are sitting right on their gamma flip. Those are the ones to watch for regime transitions during the session.

Historical Level Tracking

Key levels change daily as options positioning shifts. Store the levels each day and chart them over time to see trends: is the call wall rising (bullish positioning) or falling (bearish)? Is the gamma flip trending toward price (regime change imminent)?

import json
from datetime import datetime
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_KEY")

# Daily snapshot (run via cron or scheduler)
levels = fa.exposure_levels("SPY")
snapshot = {
    "date": datetime.now().strftime("%Y-%m-%d"),
    "price": levels["underlying_price"],
    "gamma_flip": levels["gamma_flip"],
    "call_wall": levels["call_wall"],
    "put_wall": levels["put_wall"],
    "highest_oi": levels["highest_oi_strike"],
    "zero_dte_magnet": levels["zero_dte_magnet"],
}

# Append to daily log
with open("spy_levels_history.jsonl", "a") as f:
    f.write(json.dumps(snapshot) + "\n")

# Read and chart
import matplotlib.pyplot as plt

history = []
with open("spy_levels_history.jsonl") as f:
    for line in f:
        history.append(json.loads(line))

dates = [h["date"] for h in history]
prices = [h["price"] for h in history]
flips = [h["gamma_flip"] for h in history]
cws = [h["call_wall"] for h in history]
pws = [h["put_wall"] for h in history]

fig, ax = plt.subplots(figsize=(14, 6))
ax.plot(dates, prices, label="Price", color="#e4e4e7", linewidth=2)
ax.plot(dates, flips, label="Gamma Flip", color="#f59e0b", linewidth=1.5)
ax.plot(dates, cws, label="Call Wall", color="#3b82f6", linestyle="--")
ax.plot(dates, pws, label="Put Wall", color="#ef4444", linestyle="--")
ax.fill_between(dates, pws, cws, alpha=0.08, color="#6ee7b7")
ax.legend()
ax.set_title("SPY Key Levels Over Time")
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig("spy_levels_history.png", dpi=150)

Tracking levels historically reveals patterns: the call wall tends to rise during sustained rallies (new call writing at higher strikes), and the put wall drops during selloffs (new put buying at lower strikes). These trends in positioning can confirm or contradict price-based technical analysis.

AI Agents and MCP Integration

If you're building AI-powered trading tools, the FlashAlpha MCP server gives Claude, Cursor, Windsurf, and other AI assistants direct access to key levels data. No REST calls, no SDK — the agent calls the tools natively.

Add the MCP server to your claude_desktop_config.json or .cursor/mcp.json:

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

Once configured, you can ask the agent:

• "Where is the gamma flip for SPY right now?"
• "Is TSLA near its call wall or put wall?"
• "Scan my watchlist and find which symbols are in negative gamma."
• "Show me all key levels for QQQ and tell me what to expect today."
• "Track SPY levels every 5 minutes and alert me on a gamma flip breach."

The agent calls the levels endpoint, interprets the data, and presents actionable analysis. This is how you build a key levels monitor without writing any frontend code — the agent IS the monitor.

Why Not Compute Key Levels Yourself?

You can. Here's what that requires:

1. Options chain data source — Raw chains for all strikes and expirations, updated throughout the day. Budget $200-2,500/mo from providers like Intrinio, Polygon, or ThetaData.
2. Open interest aggregation — Aggregate OI across all expirations for each strike. Handle weeklies, monthlies, quarterlies, LEAPs. Track day-over-day changes.
3. Gamma computation — Calculate dollar gamma for every option at every strike using Black-Scholes or a more sophisticated model. Requires implied volatility, risk-free rates, dividends, and days to expiration per contract.
4. Dealer model — Assume what fraction of OI is dealer-held. The standard assumption is that market makers are net short options, but this varies by strike, expiry, and symbol.
5. Level extraction — From the computed gamma profile, identify the gamma flip (where cumulative net GEX crosses zero), call wall (max call gamma strike), put wall (max put gamma strike), and max pain (minimise total option value).
6. 0DTE processing — Separate same-day expiration contracts, compute their gamma contribution, and identify the magnet strike. This changes throughout the session.
7. Infrastructure — Run all of this intraday for your universe. Handle data quality issues, missing strikes, corporate actions, and API failures.

That's 3-6 months of engineering to produce seven numbers. The FlashAlpha levels endpoint returns them in one free API call.

API Access and Pricing

The levels endpoint is available on the free tier. No credit card, no trial period. Here's the full breakdown:

The free tier gives you 5 levels calls per day — enough to check key levels for your primary symbol at the open and throughout the session. The Basic plan at $63/mo covers a single-symbol monitor polling every 5 minutes. For a multi-symbol scanner, the Growth plan provides 2,500 calls/day and adds the summary endpoint with regime analysis and dealer hedging estimates.

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

Frequently Asked Questions

Related Reading

• Build a GEX Dashboard with an API
• GEX Trading Guide: Gamma Exposure for SPY and TSLA
• Real-Time GEX by Strike: Dealer Gamma Exposure and Key Levels
• Build a Dealer Positioning Tracker with an API
• Key Levels API Documentation
• Interactive API Playground
• Build a Max Pain Dashboard - pain curve, dealer alignment, pin probability