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: the /v1/stock/{symbol}/summary endpoint is your screener workhorse. A single call returns price, ATM IV, historical vol, VRP, skew, term structure, and full exposure data (GEX/DEX/VEX/CHEX, gamma flip, walls, max pain, regime, macro context). One call per ticker gives you everything needed to score and rank it. For a 50-ticker watchlist, that's 50 API calls — not 50 chain pulls and 50 IV computations.

Quick Start: Install and First Scan

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
summary = fa.stock_summary("AAPL")
print(f"IV Rank: {summary['iv_rank']}, Regime: {summary['regime']}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha("YOUR_API_KEY");
const summary = await fa.stockSummary("AAPL");
console.log(`IV Rank: ${summary.iv_rank}, Regime: ${summary.regime}`);

using FlashAlpha;

var fa = new FlashAlphaClient("YOUR_API_KEY");
var summary = await fa.StockSummaryAsync("AAPL");
Console.WriteLine($"IV Rank: {summary.IvRank}, Regime: {summary.Regime}");

package main

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

func main() {
    fa := flashalpha.NewClient("YOUR_API_KEY")
    summary, _ := fa.StockSummary("AAPL")
    fmt.Printf("IV Rank: %d, Regime: %s\n", summary.IvRank, summary.Regime)
}

import com.flashalpha.FlashAlphaClient;
import com.flashalpha.model.StockSummary;

FlashAlphaClient fa = new FlashAlphaClient("YOUR_API_KEY");
StockSummary summary = fa.stockSummary("AAPL");
System.out.printf("IV Rank: %d, Regime: %s%n", summary.getIvRank(), summary.getRegime());

curl -H "X-Api-Key: YOUR_API_KEY" \
  "https://lab.flashalpha.com/v1/stock/AAPL/summary"

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).

import time
from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Get all available tickers
tickers = fa.tickers()

# Scan a watchlist (or loop through all tickers on a Growth+ plan)
watchlist = ["AAPL", "TSLA", "NVDA", "AMZN", "META", "GOOGL", "MSFT",
             "AMD", "NFLX", "SPY", "QQQ", "IWM", "GLD", "TLT", "XLE"]

results = []
for ticker in watchlist:
    try:
        s = fa.stock_summary(ticker)
        results.append({
            "ticker": ticker,
            "iv_rank": s.get("iv_rank"),
            "iv_percentile": s.get("iv_percentile"),
            "atm_iv": s.get("atm_iv"),
            "price": s.get("price"),
        })
    except Exception as e:
        print(f"Skipping {ticker}: {e}")
    time.sleep(0.5)  # respect rate limits

# Sort by IV rank descending
results.sort(key=lambda x: x["iv_rank"] or 0, reverse=True)

print(f"{'Ticker':<8} {'IV Rank':>8} {'IV Pctl':>8} {'ATM IV':>8} {'Price':>10}")
print("-" * 50)
for r in results:
    print(f"{r['ticker']:<8} {r['iv_rank']:>8} {r['iv_percentile']:>8} "
          f"{r['atm_iv']:>7.1f}% {r['price']:>10.2f}")

Output:

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

To filter to only high-IV candidates, add a threshold:

# Filter: IV rank > 70 AND IV percentile > 75
high_iv = [r for r in results if r["iv_rank"] > 70 and r["iv_percentile"] > 75]
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.

negative_gamma = []
for ticker in watchlist:
    try:
        s = fa.stock_summary(ticker)
        if s.get("regime") == "negative_gamma":
            negative_gamma.append({
                "ticker": ticker,
                "net_gex": s.get("net_gex"),
                "gamma_flip": s.get("gamma_flip"),
                "price": s.get("price"),
                "iv_rank": s.get("iv_rank"),
            })
    except Exception:
        continue
    time.sleep(0.5)

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['ticker']}: GEX={r['net_gex']:,.0f}, "
          f"flip={r['gamma_flip']:.2f} ({distance:+.1f}% from price), "
          f"IV rank={r['iv_rank']}")

For more detailed exposure data, use the dedicated exposure endpoint:

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

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 summary endpoint:

# Free tier approximation using summary endpoint
s = fa.stock_summary("SPY")
approx_vrp = s["atm_iv"] - s["historical_vol"]
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)
        current[ticker] = {
            "net_gex": s.get("net_gex"),
            "regime": s.get("regime"),
            "iv_rank": s.get("iv_rank"),
            "max_pain": s.get("max_pain"),
        }

        if ticker in previous:
            prev = previous[ticker]
            # Detect regime flip
            if prev["regime"] != s.get("regime"):
                alerts.append(
                    f"REGIME FLIP: {ticker} changed from "
                    f"{prev['regime']} to {s.get('regime')}"
                )
            # Detect IV rank spike (>15 points in one day)
            if s.get("iv_rank") and prev.get("iv_rank"):
                iv_delta = s["iv_rank"] - prev["iv_rank"]
                if abs(iv_delta) > 15:
                    alerts.append(
                        f"IV SPIKE: {ticker} IV rank moved {iv_delta:+d} "
                        f"({prev['iv_rank']} -> {s['iv_rank']})"
                    )
    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:

def score_ticker(summary):
    """Score a ticker 0-100 for premium-selling suitability."""
    score = 0

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

    # VRP approximation component (0-30 points)
    atm_iv = summary.get("atm_iv", 0) or 0
    hist_vol = summary.get("historical_vol", 0) or 0
    vrp = atm_iv - hist_vol
    if vrp > 0:
        score += min(30, vrp * 2)

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

    # Skew component (0-15 points)
    skew = summary.get("skew", 0) or 0
    if skew > 1.1:  # put skew is steep, puts are expensive to sell
        score += min(15, (skew - 1.0) * 50)

    return round(score, 1)


# Run the screener
scored = []
for ticker in watchlist:
    try:
        s = fa.stock_summary(ticker)
        composite = score_ticker(s)
        scored.append({
            "ticker": ticker,
            "score": composite,
            "iv_rank": s.get("iv_rank"),
            "regime": s.get("regime"),
            "atm_iv": s.get("atm_iv"),
            "price": s.get("price"),
        })
    except Exception:
        continue
    time.sleep(0.5)

# Rank by composite score
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['ticker']:<8} {r['score']:>6.1f} {r['iv_rank']:>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 and return alerts."""
    alerts = []
    for ticker in watchlist:
        try:
            s = fa.stock_summary(ticker)
            # Check thresholds
            if (s.get("iv_rank") or 0) > thresholds.get("iv_rank_min", 70):
                alerts.append({
                    "type": "HIGH_IV",
                    "ticker": ticker,
                    "iv_rank": s["iv_rank"],
                    "iv_percentile": s.get("iv_percentile"),
                })
            if s.get("regime") == "negative_gamma":
                alerts.append({
                    "type": "NEG_GAMMA",
                    "ticker": ticker,
                    "net_gex": s.get("net_gex"),
                })
        except Exception:
            continue
        time.sleep(0.5)  # 500ms between requests
    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 calls the summary endpoint for each ticker, filters based on your criteria, 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

For a screener that scans a 20-ticker watchlist using the summary endpoint, the Free tier works. For scanning hundreds of tickers with exposure and VRP data, Growth or Alpha is the right fit.

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