Options Greeks API: Real-Time Delta, Gamma, Theta, Vega for Any Ticker

Why Use an API for Greeks Instead of Computing Them Yourself

The Black-Scholes formula fits on a napkin. Implementing it correctly for production use does not. Here is what you actually have to solve once you move past the textbook:

• Dividend handling - continuous yield? discrete dividends? ex-date adjustments?
• American vs European exercise - early exercise premium changes delta and gamma near expiry
• Risk-free rate selection - SOFR? Treasury curve? Which tenor matches your DTE?
• IV calibration across the surface - a single implied volatility number hides an entire skew structure
• Edge cases at expiry - gamma explodes, theta accelerates, numerical stability breaks down
• Deep ITM / deep OTM behavior - floating-point precision issues in cumulative normal distribution tails

Two Ways to Get Greeks

FlashAlpha provides two distinct paths to options greeks depending on your use case and plan tier.

Option 1: The Greeks Calculator (Free Tier)

The /v1/pricing/greeks endpoint is a pure calculator. You provide the inputs - spot price, strike, days to expiry, implied volatility, and option type - and the API returns all first-order and second-order greeks. No market data subscription required.

from flashalpha import FlashAlpha
fa = FlashAlpha("your_key")

result = fa.greeks(spot=580, strike=580, dte=30, sigma=0.18, type="call")

Response:

{
    "first_order": {
        "delta": 0.52,
        "gamma": 0.018,
        "theta": -0.15,
        "vega": 0.28,
        "rho": 0.045
    },
    "second_order": {
        "vanna": 0.012,
        "charm": -0.003,
        "vomma": 0.008,
        "speed": 0.0004
    }
}

Option 2: Live Option Quotes (Growth+ Tier)

The /optionquote/{ticker} endpoint returns greeks computed from live market implied volatility. No inputs needed beyond the contract specification - the API sources real-time IV and computes greeks from it.

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

# Returns: delta, gamma, theta, vega, implied_vol, bid, ask, mid, open_interest

This endpoint requires the Growth plan ($299/mo) and is ideal when you need market-calibrated greeks without managing your own IV pipeline. For a deeper look at what option quotes include, see Greeks are included in every option quote.

Quick Start - Compute Greeks for Any Option

Install the Python SDK and compute greeks in five lines:

pip install flashalpha

(GitHub · PyPI)

from flashalpha import FlashAlpha

fa = FlashAlpha("your_key")
greeks = fa.greeks(spot=580, strike=580, dte=30, sigma=0.18, type="call")

print(f"Delta: {greeks['first_order']['delta']}")
print(f"Gamma: {greeks['first_order']['gamma']}")
print(f"Theta: {greeks['first_order']['theta']}")
print(f"Vega:  {greeks['first_order']['vega']}")
print(f"Vanna: {greeks['second_order']['vanna']}")

Output:

Delta: 0.52
Gamma: 0.018
Theta: -0.15
Vega:  0.28
Vanna: 0.012

The greeks endpoint accepts any combination of spot, strike, DTE, and volatility. If you do not have the implied volatility, you can extract it from a market price using the IV endpoint:

iv_result = fa.iv(spot=580, strike=580, dte=30, price=12.69, type="call")
# {"implied_volatility": 0.182, "implied_volatility_pct": "18.2%"}

Working Example: Portfolio Delta Calculator

A common use case: you hold multiple option positions and need to know your aggregate risk. This script pulls greeks for each leg and computes net portfolio delta, gamma, and theta.

from flashalpha import FlashAlpha

fa = FlashAlpha("your_key")

positions = [
    {"ticker": "SPY", "strike": 575, "dte": 30, "sigma": 0.19, "type": "call",  "qty": 10},
    {"ticker": "SPY", "strike": 585, "dte": 30, "sigma": 0.17, "type": "call",  "qty": -10},
    {"ticker": "SPY", "strike": 570, "dte": 30, "sigma": 0.20, "type": "put",   "qty": 5},
    {"ticker": "SPY", "strike": 590, "dte": 14, "sigma": 0.16, "type": "call",  "qty": -3},
    {"ticker": "SPY", "strike": 560, "dte": 45, "sigma": 0.22, "type": "put",   "qty": 8},
]

net_delta = 0
net_gamma = 0
net_theta = 0

for pos in positions:
    g = fa.greeks(
        spot=580,
        strike=pos["strike"],
        dte=pos["dte"],
        sigma=pos["sigma"],
        type=pos["type"]
    )
    contracts = pos["qty"] * 100  # each contract = 100 shares
    net_delta += g["first_order"]["delta"] * contracts
    net_gamma += g["first_order"]["gamma"] * contracts
    net_theta += g["first_order"]["theta"] * contracts

print(f"Net delta: {net_delta:+.1f}")
print(f"Net gamma: {net_gamma:+.1f}")
print(f"Net theta: ${net_theta:+.2f}/day")

Output:

Net delta: +45.2
Net gamma: +3.8
Net theta: -$127.10/day

From here you can extend the script to rebalance: if net delta exceeds a threshold, compute the hedge ratio and submit an order. Aggregate gamma across all strikes gives you gamma exposure (GEX), a key metric for understanding dealer positioning. Full source code for this and other examples on GitHub.

Working Example: Greek Surface - How Delta Changes Across Strikes

Delta is not constant. It varies from near 1.0 for deep in-the-money calls to near 0.0 for deep out-of-the-money calls. This script maps the delta curve across a range of strikes:

from flashalpha import FlashAlpha

fa = FlashAlpha("your_key")

spot = 580
strikes = range(550, 615, 5)

print(f"{'Strike':>8} {'Delta':>8} {'Gamma':>8} {'Moneyness':>12}")
print("-" * 40)

for k in strikes:
    g = fa.greeks(spot=spot, strike=k, dte=30, sigma=0.18, type="call")
    moneyness = "ITM" if k < spot else ("ATM" if k == spot else "OTM")
    print(f"{k:>8} {g['first_order']['delta']:>8.3f} {g['first_order']['gamma']:>8.4f} {moneyness:>12}")

Output:

  Strike    Delta    Gamma    Moneyness
----------------------------------------
     550    0.941   0.0042          ITM
     555    0.912   0.0061          ITM
     560    0.871   0.0085          ITM
     565    0.815   0.0112          ITM
     570    0.742   0.0141          ITM
     575    0.652   0.0165          ITM
     580    0.520   0.0180          ATM
     585    0.412   0.0172          OTM
     590    0.308   0.0155          OTM
     595    0.218   0.0129          OTM
     600    0.146   0.0101          OTM
     605    0.092   0.0074          OTM
     610    0.055   0.0051          OTM

For aggregated gamma across all strikes and open interest, see the GEX tool or call fa.gex("SPY") programmatically.

The BSM Greeks - Closed-Form Definitions

Under Black-Scholes-Merton with continuous dividend yield \(q\), all first-order Greeks have closed-form solutions. Let \(S\) = spot, \(K\) = strike, \(T\) = time to expiry, \(\sigma\) = implied vol, \(r\) = risk-free rate, and \(N(\cdot)\) = standard normal CDF.

Where \(N'(x) = \frac{1}{\sqrt{2\pi}} e^{-x^2/2}\) is the standard normal PDF. Second-order Greeks (vanna, charm, vomma, speed) are partial derivatives of these first-order sensitivities - all returned by the API in a single call.

Accuracy & Methodology

The greeks endpoint uses Black-Scholes-Merton with continuous dividend yield adjustment. The model accounts for:

• First-Order Greeks - Delta, Gamma, Theta, Vega, Rho
• Second-Order Greeks - Vanna, Charm, Vomma, Speed
• IV Source - User-provided or extracted via fa.iv()
• Numerical Stability - Validated at expiry edges, deep ITM/OTM

If you do not have implied volatility for your contract, use fa.iv() to back it out from a market price, then pass the result into fa.greeks(). For an overview of all available data endpoints, see the developer's guide to real-time options data.

Get Started

The greeks calculator endpoint is available on every plan, including Free (5 requests/day). Sign up, grab an API key, and start computing greeks in under a minute.

View Pricing & Sign Up Try It in the Playground GitHub

Frequently Asked Questions