Options Chain API: Real-Time Bid/Ask, IV, Greeks, and Open Interest

If you're building anything that touches listed options — a screener, a scanner, a dashboard, a trading bot — you need programmatic access to options chain data. Not a CSV download from yesterday. Not a web scraper that breaks every time the source changes their DOM. You need a clean API that returns bid, ask, implied volatility, greeks, and open interest in a single call.

Why You Need an Options Chain API

Manual approaches to options data don't scale. Scraping broker sites violates terms of service and breaks on every UI update. Free data feeds give you last price at best — no greeks, no IV, no open interest. If you want to build anything beyond a toy project, you need computed greeks delivered alongside the quote, not raw prices that force you to roll your own Black-Scholes implementation and source a separate interest rate feed.

What FlashAlpha Returns

The FlashAlpha Options API returns full option quotes with computed greeks for any US-listed equity or ETF — over 4,000 symbols. Each option quote includes:

• Pricing — Bid, Ask, Mid, Last, Volume
• Volatility — Implied Volatility (IV)
• Greeks — Delta, Gamma, Theta, Vega
• Positioning — Open Interest, Volume

Chain metadata — the list of available expirations and strikes for a given ticker — is available through the /v1/options/{ticker} endpoint. Quotes are real-time during market hours and refresh on each request. Coverage spans all optionable US equities and ETFs.

Quick Start — Get an Option Quote in 3 Lines

Install the Python client and pull your first quote:

pip install flashalpha

(GitHub · PyPI)

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")
quote = fa.option_quote("SPY", expiry="2026-03-21", strike=580, type="C")
print(quote)

Response:

{
  "bid": 11.20,
  "ask": 11.45,
  "mid": 11.325,
  "delta": 0.52,
  "gamma": 0.018,
  "theta": -0.15,
  "vega": 0.28,
  "implied_vol": 0.182,
  "open_interest": 45230,
  "volume": 12840
}

The underlying REST endpoint is GET /optionquote/{ticker}?expiry=&strike=&type= at https://lab.flashalpha.com, authenticated via an X-Api-Key header. The Python client wraps this for convenience.

List Available Expirations and Strikes

Before querying individual quotes, you typically need to know what expirations and strikes exist for a symbol. The chain metadata endpoint handles this:

chain = fa.options("SPY")
print(chain)

Response:

{
  "symbol": "SPY",
  "expirations": [
    "2026-03-16",
    "2026-03-18",
    "2026-03-21",
    "2026-03-28",
    "2026-04-04",
    "2026-04-17",
    "2026-05-15",
    "2026-06-19",
    "2026-09-18",
    "2026-12-18"
  ],
  "strikes": [500, 510, 520, 530, 540, 550, 555, 560, 565, 570, 575, 580, 585, 590, 595, 600, 610, 620, 630, 640, 650]
}

This endpoint maps to GET /v1/options/{ticker}. Use it to discover what's available before iterating through specific contracts.

Working Example: Find Highest IV Options

A common use case: scan across expirations to find where implied volatility is elevated. This script pulls ATM call quotes for each expiration and ranks them by IV:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Get current stock price for ATM reference
stock = fa.stock_quote("SPY")
atm_strike = round(stock["mid"] / 5) * 5  # round to nearest 5

# Get available expirations
chain = fa.options("SPY")

results = []
for exp in chain["expirations"][:8]:  # first 8 expirations
    try:
        q = fa.option_quote("SPY", expiry=exp, strike=atm_strike, type="C")
        results.append({
            "expiry": exp,
            "iv": q["implied_vol"],
            "bid": q["bid"],
            "ask": q["ask"],
            "oi": q["open_interest"]
        })
    except Exception:
        continue

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

print(f"ATM Strike: {atm_strike}")
print(f"{'Expiry':<14} {'IV':>8} {'Bid':>8} {'Ask':>8} {'OI':>10}")
print("-" * 52)
for r in results:
    print(f"{r['expiry']:<14} {r['iv']:>7.1%} {r['bid']:>8.2f} {r['ask']:>8.2f} {r['oi']:>10,}")

Output:

ATM Strike: 580
Expiry             IV      Bid      Ask         OI
----------------------------------------------------
2026-03-16       22.4%     3.10     3.25      8,420
2026-03-18       20.1%     4.85     5.00     12,390
2026-03-21       18.2%    11.20    11.45     45,230
2026-04-04       17.8%    15.60    15.90     22,100
2026-03-28       17.5%    13.40    13.65     31,850
2026-04-17       16.9%    18.30    18.55     18,740
2026-05-15       16.2%    24.10    24.40      9,560
2026-06-19       15.8%    30.50    30.85      6,230

Near-term expirations typically show higher IV — especially around events. This is the term structure of volatility, and you can spot dislocations by scanning programmatically. Each option_quote call counts as one API call against your daily limit. Full source code and more examples on GitHub.

Working Example: Build a Multi-Ticker Options Scanner

Scan multiple tickers for options within a specific delta range — useful for finding high-probability credit spread candidates or hedging opportunities:

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

tickers = ["SPY", "QQQ", "AAPL", "MSFT", "NVDA", "TSLA", "AMZN", "META"]
target_delta_min = 0.25
target_delta_max = 0.35
expiry = "2026-04-17"

print(f"Scanning for puts with delta {target_delta_min}-{target_delta_max}")
print(f"{'Ticker':<8} {'Strike':>8} {'Delta':>8} {'IV':>8} {'Bid':>8} {'OI':>10}")
print("-" * 56)

for ticker in tickers:
    try:
        stock = fa.stock_quote(ticker)
        spot = stock["mid"]
        chain = fa.options(ticker)

        if expiry not in chain.get("expirations", []):
            continue

        # Check OTM puts at a few strikes below spot
        for pct in [0.90, 0.92, 0.95]:
            strike = round(spot * pct)
            try:
                q = fa.option_quote(ticker, expiry=expiry, strike=strike, type="P")
                d = abs(q["delta"])
                if target_delta_min <= d <= target_delta_max:
                    print(f"{ticker:<8} {strike:>8} {q['delta']:>8.3f} "
                          f"{q['implied_vol']:>7.1%} {q['bid']:>8.2f} "
                          f"{q['open_interest']:>10,}")
            except Exception:
                continue
    except Exception:
        continue

Once you have the data, the applications multiply. Feed it into a gamma exposure model, backtest a strategy, or pipe it into a live dashboard. If you need full greek computations beyond what the quote returns, the dedicated Greeks endpoint lets you run Black-Scholes-Merton calculations with custom inputs.

Rate Limits and Pricing

Fifty free calls per day is enough to build and test a scanner. Scale up when you need broader coverage or higher frequency. Start with 50 free calls/day and upgrade when your use case demands it.

Chain data pairs naturally with exposure analysis. Once you have open interest and greeks per strike, you can compute gamma exposure (GEX) to identify dealer hedging levels — or use the built-in fa.gex() endpoint to skip the math entirely.

Get Your API Key

Frequently Asked Questions