Build an Options Screener with an API: IV Scanner, Exposure Alerts, and Flow Detection

If you're searching for an options screener API, a way to scan for high IV stocks programmatically, or trying to build a screening tool without computing everything yourself, this is the guide. One endpoint per ticker returns IV rank, IV percentile, VRP, GEX regime, skew, term structure, and exposure data - everything you need to score and rank 6,000+ US equities.

What Makes a Good Options Screener

A useful options screener filters the universe of tradeable tickers down to actionable opportunities. The screening dimensions that matter:

Building all of this from raw option chains for 6,000 tickers requires sourcing millions of rows of data per day, computing IV for every strike (which requires a root-finding algorithm per contract), fitting vol surfaces, calculating realized vol across multiple windows, estimating dealer positioning, and maintaining the pipeline. That's a multi-month engineering project.

The API Approach: Which Endpoints for Each Dimension

FlashAlpha pre-computes all of these analytics. Here's which endpoint covers each screening dimension:

The key insight: for cross-sectional scans, POST /v1/screener is your workhorse. It ranks the universe server-side on metrics like iv_rank_30d and returns the matching rows in a single request - no per-ticker loop. When you then want a full per-symbol snapshot (price, ATM IV, historical vol, VRP, skew, IV term structure, and nested exposure data under exposure.* and volatility.*), drill in with /v1/stock/{symbol}/summary. Note that IV rank lives on the screener as iv_rank_30d; it is not a field on the summary response.

Quick Start: Install and First Scan

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
rows = fa.screener(
    sort=[("iv_rank_30d", "desc")],
    select=["symbol", "iv_rank_30d", "regime"],
    limit=5,
)
for r in rows:
    print(f"{r['symbol']}: IV Rank {r['iv_rank_30d']}, Regime: {r['regime']}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha("YOUR_API_KEY");
const rows = await fa.screener({
  sort: [{ field: "iv_rank_30d", direction: "desc" }],
  select: ["symbol", "iv_rank_30d", "regime"],
  limit: 5,
});
rows.forEach(r => console.log(`${r.symbol}: IV Rank ${r.iv_rank_30d}, Regime: ${r.regime}`));

using FlashAlpha;

var fa = new FlashAlphaClient("YOUR_API_KEY");
var rows = await fa.ScreenerAsync(new ScreenerQuery {
    Sort = new[] { new Sort("iv_rank_30d", "desc") },
    Select = new[] { "symbol", "iv_rank_30d", "regime" },
    Limit = 5,
});
foreach (var r in rows)
    Console.WriteLine($"{r["symbol"]}: IV Rank {r["iv_rank_30d"]}, Regime: {r["regime"]}");

package main

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

func main() {
    fa := flashalpha.NewClient("YOUR_API_KEY")
    rows, _ := fa.Screener(flashalpha.ScreenerQuery{
        Sort:   []flashalpha.Sort{{Field: "iv_rank_30d", Direction: "desc"}},
        Select: []string{"symbol", "iv_rank_30d", "regime"},
        Limit:  5,
    })
    for _, r := range rows {
        fmt.Printf("%s: IV Rank %v, Regime: %v\n", r["symbol"], r["iv_rank_30d"], r["regime"])
    }
}

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

FlashAlphaClient fa = new FlashAlphaClient("YOUR_API_KEY");
for (var el : fa.screener(new ScreenerQuery()
        .sortDesc("iv_rank_30d")
        .select("symbol", "iv_rank_30d", "regime")
        .limit(5))) {
    JsonObject r = el.getAsJsonObject();
    System.out.printf("%s: IV Rank %d, Regime: %s%n",
        r.get("symbol").getAsString(), r.get("iv_rank_30d").getAsInt(),
        r.get("regime").getAsString());
}

curl -X POST -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  "https://lab.flashalpha.com/v1/screener" \
  -d '{"sort":[{"field":"iv_rank_30d","direction":"desc"}],
       "select":["symbol","iv_rank_30d","regime"],"limit":5}'

Use Case 1: IV Rank Scanner - Find High IV Stocks

The most common screener: find stocks where implied volatility is elevated relative to their own history. High IV rank means options are expensive, which favors premium-selling strategies (short straddles, iron condors, credit spreads).

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Scan a watchlist (or use a preset universe like {"type": "preset", "value": "sp500"})
watchlist = ["AAPL", "TSLA", "NVDA", "AMZN", "META", "GOOGL", "MSFT",
             "AMD", "NFLX", "SPY", "QQQ", "IWM", "GLD", "TLT", "XLE"]

# One screener call ranks the whole watchlist server-side on iv_rank_30d
results = fa.screener(
    universe={"symbols": watchlist},
    sort=[("iv_rank_30d", "desc")],
    select=["symbol", "iv_rank_30d", "atm_iv", "price"],
    limit=len(watchlist),
)

print(f"{'Ticker':<8} {'IV Rank':>8} {'ATM IV':>8} {'Price':>10}")
print("-" * 40)
for r in results:
    print(f"{r['symbol']:<8} {r['iv_rank_30d']:>8} "
          f"{r['atm_iv']:>7.1f}% {r['price']:>10.2f}")

Output:

Ticker   IV Rank   ATM IV      Price
------------------------------------
TSLA          82    54.2%     245.30
NFLX          76    38.1%     712.50
AMD           71    42.8%     158.20
XLE           68    28.5%      89.40
NVDA          65    46.3%     890.10
...

To filter to only high-IV candidates, push the threshold into the query so the API returns just the matches:

# Filter server-side: iv_rank_30d >= 70
high_iv = fa.screener(
    universe={"symbols": watchlist},
    filters={"op": "and", "conditions": [
        {"field": "iv_rank_30d", "operator": "gte", "value": 70},
    ]},
    sort=[("iv_rank_30d", "desc")],
    select=["symbol", "iv_rank_30d", "atm_iv"],
    limit=len(watchlist),
)
print(f"\n{len(high_iv)} stocks with elevated IV:")

Use Case 2: GEX Regime Filter - Find Negative Gamma Stocks

Negative gamma regime means dealers are short gamma and will amplify directional moves by hedging in the same direction as the market. These are the tickers where big moves are more likely. Useful for directional traders looking for breakout candidates, or for premium sellers who want to avoid these names.

# Filter the universe to negative-gamma names in one call
negative_gamma = fa.screener(
    universe={"symbols": watchlist},
    filters={"op": "and", "conditions": [
        {"field": "regime", "operator": "eq", "value": "negative_gamma"},
    ]},
    sort=[("iv_rank_30d", "desc")],
    select=["symbol", "net_gex", "gamma_flip", "price", "iv_rank_30d"],
    limit=len(watchlist),
)

print(f"\nStocks in negative gamma regime ({len(negative_gamma)}):")
for r in negative_gamma:
    distance = ((r["price"] - r["gamma_flip"]) / r["price"]) * 100
    print(f"  {r['symbol']}: GEX={r['net_gex']:,.0f}, "
          f"flip={r['gamma_flip']:.2f} ({distance:+.1f}% from price), "
          f"IV rank={r['iv_rank_30d']}")

For a full exposure breakdown on a flagged name, drill into the dedicated exposure endpoint. Note the dealer hedging block is returned as hedging_estimate:

# Growth+ plan: get full exposure breakdown
exposure = fa.exposure_summary("TSLA")
print(f"Net GEX: {exposure['exposures']['net_gex']:,.0f}")
print(f"Net DEX: {exposure['exposures']['net_dex']:,.0f}")
print(f"Net VEX: {exposure['exposures']['net_vex']:,.0f}")
print(f"Net CHEX: {exposure['exposures']['net_chex']:,.0f}")
print(f"Regime: {exposure['regime']}")
print(f"Dealer hedging estimate: {exposure['hedging_estimate']}")

Use Case 3: VRP Scanner - Find Richest Premium-Selling Opportunities

VRP (volatility risk premium) measures the spread between implied and realized volatility. A high VRP z-score means the premium is unusually rich relative to history. Combined with a favorable gamma regime, this identifies optimal premium-selling entries.

# Alpha plan: VRP z-score scanning
vrp_results = []
for ticker in watchlist:
    try:
        v = fa.vrp(ticker)
        vrp_results.append({
            "ticker": ticker,
            "z_score": v.get("z_score"),
            "percentile": v.get("percentile"),
            "vrp_20d": v.get("vrp_20d"),
        })
    except Exception:
        continue
    time.sleep(0.5)

# Sort by z-score descending
vrp_results.sort(key=lambda x: x["z_score"] or 0, reverse=True)

print(f"{'Ticker':<8} {'Z-Score':>8} {'Pctl':>6} {'VRP 20d':>8}")
print("-" * 35)
for r in vrp_results:
    print(f"{r['ticker']:<8} {r['z_score']:>8.2f} {r['percentile']:>5}% "
          f"{r['vrp_20d']:>7.1f}%")

With the Free tier, you can approximate VRP using the per-symbol summary endpoint. Note that the volatility fields are nested under volatility (atm_iv, hv_20, vrp):

# Free tier approximation using the summary endpoint
s = fa.stock_summary("SPY")
vol = s["volatility"]
approx_vrp = vol["atm_iv"] - vol["hv_20"]   # or read vol["vrp"] directly
print(f"Approximate VRP: {approx_vrp:.1f}%")

Use Case 4: Unusual Exposure Shifts

Detect day-over-day changes in open interest, GEX flips, and unusual option flow. This requires polling the summary endpoint on a schedule and comparing current values to previous readings.

import json
from pathlib import Path

CACHE_FILE = Path("screener_cache.json")

def load_previous():
    if CACHE_FILE.exists():
        return json.loads(CACHE_FILE.read_text())
    return {}

def save_current(data):
    CACHE_FILE.write_text(json.dumps(data, indent=2))

previous = load_previous()
current = {}
alerts = []

for ticker in watchlist:
    try:
        s = fa.stock_summary(ticker)
        exp = s.get("exposure") or {}
        vol = s.get("volatility") or {}
        current[ticker] = {
            "net_gex": exp.get("net_gex"),
            "regime": exp.get("regime"),
            "atm_iv": vol.get("atm_iv"),
            "max_pain": exp.get("max_pain"),
        }

        if ticker in previous:
            prev = previous[ticker]
            # Detect regime flip
            if prev["regime"] != exp.get("regime"):
                alerts.append(
                    f"REGIME FLIP: {ticker} changed from "
                    f"{prev['regime']} to {exp.get('regime')}"
                )
            # Detect ATM IV spike (>5 vol points in one day)
            if vol.get("atm_iv") and prev.get("atm_iv"):
                iv_delta = vol["atm_iv"] - prev["atm_iv"]
                if abs(iv_delta) > 5:
                    alerts.append(
                        f"IV SPIKE: {ticker} ATM IV moved {iv_delta:+.1f} "
                        f"({prev['atm_iv']:.1f} -> {vol['atm_iv']:.1f})"
                    )
    except Exception:
        continue
    time.sleep(0.5)

save_current(current)

if alerts:
    print(f"\n{len(alerts)} alerts detected:")
    for a in alerts:
        print(f"  * {a}")
else:
    print("No unusual activity detected.")

For full chain-level analysis, use the option quote endpoint to drill down into specific tickers flagged by the screener:

# Growth+ plan: drill into flagged ticker's chain
chain = fa.option_quote("TSLA")  # full chain
# Or filter by expiry/strike/type:
# chain = fa.option_quote("TSLA", expiry="2026-04-04", type="call")

# Find contracts with unusual volume relative to OI
for contract in chain:
    if contract["open_interest"] > 0:
        vol_oi_ratio = contract["volume"] / contract["open_interest"]
        if vol_oi_ratio > 3.0:
            print(f"  {contract['symbol']} "
                  f"Vol={contract['volume']} OI={contract['open_interest']} "
                  f"Ratio={vol_oi_ratio:.1f}x IV={contract['iv']:.1f}%")

Use Case 5: Multi-Factor Screener - Composite Scoring

The most powerful screener combines multiple dimensions into a composite score. Here's an example that scores tickers on IV rank, VRP approximation, and GEX regime, then ranks them for premium-selling opportunities:

RICH_VRP = {"very_high_premium", "healthy_premium"}

def score_row(row):
    """Score a screener row 0-100 for premium-selling suitability."""
    score = 0

    # IV rank component (0-35 points)
    iv_rank = row.get("iv_rank_30d", 0) or 0
    score += min(35, iv_rank * 0.35)

    # VRP component (0-30 points): ATM IV minus 20-day realized vol
    atm_iv = row.get("atm_iv", 0) or 0
    rv_20d = row.get("rv_20d", 0) or 0
    vrp = atm_iv - rv_20d
    if vrp > 0:
        score += min(30, vrp * 2)

    # GEX regime component (0-20 points)
    regime = row.get("regime", "")
    if regime == "positive_gamma":
        score += 20  # favorable: pinning, mean reversion
    elif regime == "negative_gamma":
        score += 0   # dangerous for premium sellers
    else:
        score += 10

    # VRP regime bonus (0-15 points)
    if row.get("vrp_assessment") in RICH_VRP:
        score += 15

    return round(score, 1)


# One screener call returns the flat rows; score them client-side
rows = fa.screener(
    universe={"symbols": watchlist},
    select=["symbol", "iv_rank_30d", "atm_iv", "rv_20d",
            "regime", "vrp_assessment", "price"],
    limit=len(watchlist),
)

scored = [{**r, "score": score_row(r)} for r in rows]
scored.sort(key=lambda x: x["score"], reverse=True)

print(f"{'Rank':<6} {'Ticker':<8} {'Score':>6} {'IV Rank':>8} "
      f"{'ATM IV':>8} {'Regime':<18}")
print("-" * 65)
for i, r in enumerate(scored[:10], 1):
    print(f"{i:<6} {r['symbol']:<8} {r['score']:>6.1f} {r['iv_rank_30d']:>8} "
          f"{r['atm_iv']:>7.1f}% {r['regime']:<18}")

Adjust the weights based on your strategy. Directional traders might weight GEX regime higher and IV rank lower. Premium sellers want high IV rank + positive gamma + rich VRP. Volatility arbitrage traders care most about VRP z-score and skew.

Building Alerts: Polling Pattern with Rate Limits

A screener that runs on a schedule and sends alerts when conditions are met. Key consideration: respect rate limits. The Free tier allows 5 requests/day. Growth plans support higher throughput.

import time
import smtplib
from email.message import EmailMessage

def run_screener_cycle(fa, watchlist, thresholds):
    """Run one screening cycle (single screener call) and return alerts."""
    rows = fa.screener(
        universe={"symbols": watchlist},
        select=["symbol", "iv_rank_30d", "regime", "net_gex"],
        limit=len(watchlist),
    )
    alerts = []
    for r in rows:
        # Check thresholds
        if (r.get("iv_rank_30d") or 0) > thresholds.get("iv_rank_min", 70):
            alerts.append({
                "type": "HIGH_IV",
                "ticker": r["symbol"],
                "iv_rank": r["iv_rank_30d"],
            })
        if r.get("regime") == "negative_gamma":
            alerts.append({
                "type": "NEG_GAMMA",
                "ticker": r["symbol"],
                "net_gex": r.get("net_gex"),
            })
    return alerts

def send_alert_email(alerts, recipient):
    """Send alert summary via email."""
    msg = EmailMessage()
    msg["Subject"] = f"Options Screener: {len(alerts)} alerts"
    msg["From"] = "[email protected]"
    msg["To"] = recipient
    body = "\n".join(
        f"[{a['type']}] {a['ticker']}: {a}" for a in alerts
    )
    msg.set_content(body)
    # Configure your SMTP server here
    # with smtplib.SMTP("smtp.example.com") as server:
    #     server.send_message(msg)

# Run every 30 minutes during market hours
thresholds = {"iv_rank_min": 70}
while True:
    alerts = run_screener_cycle(fa, watchlist, thresholds)
    if alerts:
        send_alert_email(alerts, "[email protected]")
        print(f"Sent {len(alerts)} alerts")
    time.sleep(1800)  # 30 minutes

AI Agents: Let Claude Scan for You

FlashAlpha provides an MCP (Model Context Protocol) server that lets AI assistants query options data directly. Configure your AI agent with the MCP server and it can run screening logic, interpret results, and surface opportunities without you writing screening code at all.

MCP server URL: https://lab.flashalpha.com/mcp

Example prompt to Claude with MCP configured:

"Scan SPY, TSLA, NVDA, AAPL, and AMD. Which ones have IV rank above 70
and are in a negative gamma regime? For those, what's the VRP z-score
and which premium-selling strategy scores highest?"

The agent runs a screener query to rank the names on iv_rank_30d and regime, drills into VRP for the matches, and returns a ranked list with trade structure recommendations - all grounded in live data, not hallucinated numbers.

This works with Claude (Anthropic), Cursor, Windsurf, and any MCP-compatible agent. Configure it once and your AI assistant becomes an options screener.

Why Not Build It Yourself?

You could build all of this from raw OPRA data. Here's what that looks like:

Realistically, this is 6-12 months of engineering for a small team and significant ongoing infrastructure costs. The API approach lets you focus on the screening logic and trading decisions rather than the data pipeline.

Pricing

The cross-sectional POST /v1/screener scan requires the Growth plan (~20 symbols per query; ~250 on Alpha). The Free tier is for drilling into individual names with the per-symbol summary endpoint.

Frequently Asked Questions

Related Reading

• IV Rank Scanner: Finding the Highest Implied Volatility Stocks
• Build a Volatility Scanner in Python with a Free API
• Options Chain API: Real-Time Greeks and Open Interest
• Implied Volatility API: Real-Time IV for Every Strike and Expiration
• GEX Dashboard API: Build a Gamma Exposure Monitor
• VRP Dashboard API: Build a Volatility Risk Premium Monitor
• Interactive API Playground

An options screener built on the FlashAlpha API gives you IV rank scanning, GEX regime filtering, VRP scoring, unusual activity detection, and multi-factor composite scoring - all without sourcing raw chains, computing implied volatility, or building exposure models. POST /v1/screener is the cross-sectional workhorse: one structured query ranks the universe on iv_rank_30d and returns the rows you need, while /v1/stock/{symbol}/summary handles per-symbol drill-down with its nested exposure.* and volatility.* blocks. Install the SDK, send the query, score the rows, and you have a production screener in under 100 lines of code. The API handles the quant infrastructure; your code handles the screening logic.