Portfolio & Sector Gamma Exposure: Aggregate GEX Across a Basket with One API Call

If you are searching for a portfolio gamma exposure API, a sector GEX aggregator, a multi-symbol dealer positioning endpoint, a basket gamma scanner, or a way to compute net GEX across a watchlist, this is the reference. The FlashAlpha /v1/exposure/basket endpoint takes a comma-separated list of up to 50 symbols (with optional weights) and returns one weighted net GEX / DEX / VEX / CHEX read for the whole basket, each constituent's per-greek contribution and gamma regime, and any symbols that lacked data reported back so you know exactly what fed the aggregate. It is on the Growth plan, and the entire basket costs a single rate-limit debit regardless of how many symbols you pass.

Read this first. The basket is a weighted roll-up of the same settled-OI exposure model behind the single-symbol GEX endpoint, it inherits that model's assumptions (dealer-short-calls / dealer-long-puts sign convention, settled open interest, no intraday flow adjustment). The JSON samples below are illustrative shapes with placeholder numbers, not live market data. One caveat to internalise up front: the endpoint does not pre-validate index/ETF tier gating per constituent, so confirm your entitlement covers every symbol you pass before trusting each row.

Why a Basket Endpoint Exists

Single-ticker GEX is solved. SpotGamma, Unusual Whales, GEXRadar, and FlashAlpha's own GEX endpoint all give you dealer gamma for SPY, or NVDA, or TSLA, one name at a time. What none of them give you directly is the aggregate. And the aggregate is where a lot of the real signal lives:

• Sector regimes. "Is semis short gamma into this print?" is a basket question. The answer is the sum of NVDA, AMD, AVGO, MU, SMCI dealer gamma, not any one of them.
• Book-level hedging. If you run a multi-name options book, your real dealer-flow exposure is the weighted sum across your holdings, not a single line item.
• Dispersion framing. Index-vs-constituents trades hinge on the gap between aggregate basket exposure and the index's own exposure. You need both sides.

Building that aggregate by hand means calling a single-symbol GEX endpoint 50 times, normalising weights, summing four greeks, and computing each name's contribution share, per refresh, for every basket. The basket endpoint does it server-side in one call, for one quota debit.

Quick Start: Aggregate a Basket

Pass symbols as a comma-separated list (max 50). Optionally pass weights of the same length, they are renormalised to sum to 1, so 0.4,0.3,0.3 and 4,3,3 are equivalent. Omit weights for equal weight.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

# Mega-cap tech basket, custom weights (pass a list or a comma string)
data = fa.exposure_basket(
    ["AAPL", "MSFT", "NVDA", "AMZN", "META", "GOOGL"],
    weights=[0.28, 0.22, 0.20, 0.12, 0.10, 0.08],
)

agg = data["aggregate"]
print(f"Basket net GEX: {agg['net_gex']:,}  net DEX: {agg['net_dex']:,}")
print(f"Constituents counted: {data['constituent_count']}  missing: {data['missing_symbols']}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_API_KEY');

const data = await fa.exposureBasket({
    symbols: 'AAPL,MSFT,NVDA,AMZN,META,GOOGL',
    weights: '0.28,0.22,0.20,0.12,0.10,0.08',
});

const agg = data.aggregate;
console.log(`Basket net GEX: ${agg.net_gex.toLocaleString()}  net DEX: ${agg.net_dex.toLocaleString()}`);
console.log(`Missing: ${data.missing_symbols.join(', ') || 'none'}`);

using FlashAlpha;

var client = new FlashAlphaClient("YOUR_API_KEY");

// Weights are optional; returns a JsonElement
var data = await client.ExposureBasketAsync(
    new[] { "AAPL", "MSFT", "NVDA", "AMZN", "META", "GOOGL" },
    new[] { 0.28, 0.22, 0.20, 0.12, 0.10, 0.08 });

var agg = data.GetProperty("aggregate");
Console.WriteLine($"Basket net GEX: {agg.GetProperty("net_gex").GetInt64():N0}");

package main

import (
    "context"
    "fmt"

    flashalpha "github.com/FlashAlpha-lab/flashalpha-go"
)

func main() {
    fa := flashalpha.NewClient("YOUR_API_KEY")

    data, err := fa.ExposureBasket(context.Background(),
        "AAPL,MSFT,NVDA,AMZN,META,GOOGL",
        flashalpha.WithBasketWeights("0.28,0.22,0.20,0.12,0.10,0.08"))
    if err != nil {
        panic(err)
    }

    agg := data["aggregate"].(map[string]interface{})
    fmt.Printf("Basket net GEX: %v\n", agg["net_gex"])
}

# Equal-weight basket (omit weights)
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/basket?symbols=NVDA,AMD,AVGO,MU,SMCI"

# Custom-weight basket (renormalised to sum to 1)
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/basket?symbols=AAPL,MSFT,NVDA&weights=0.4,0.3,0.3"

Response Shape

The JSON below is an illustrative shape only, placeholder numbers, snake_case fields. The aggregate carries the four weighted net greeks; each constituent reports its renormalised weight, underlying price, per-greek values, a contribution percentage, and a gamma-regime tag. Symbols requested but missing from the data store come back in missing_symbols.

{
  "as_of": "2026-06-13T15:30:00Z",
  "constituent_count": 3,
  "missing_symbols": [],
  "aggregate": {
    "net_gex": 1640000000,
    "net_dex": -210000000,
    "net_vex":  580000000,
    "net_chex": 420000000
  },
  "constituents": [
    { "symbol": "AAPL", "weight": 0.40, "underlying_price": 210.45, "net_gex":  920000000, "net_dex": -120000000, "net_vex": 340000000, "net_chex": 260000000, "contribution_pct": 42.13, "regime": "positive_gamma" },
    { "symbol": "MSFT", "weight": 0.30, "underlying_price": 432.80, "net_gex":  410000000, "net_dex":  -60000000, "net_vex": 140000000, "net_chex":  90000000, "contribution_pct": 18.77, "regime": "positive_gamma" },
    { "symbol": "NVDA", "weight": 0.30, "underlying_price": 121.10, "net_gex":  310000000, "net_dex":  -30000000, "net_vex": 100000000, "net_chex":  70000000, "contribution_pct": 39.10, "regime": "positive_gamma" }
  ]
}

Key Fields

One subtlety worth internalising: because weights renormalise after drops, a basket where three of five symbols are missing still returns a clean aggregate that looks complete. Always read missing_symbols and constituent_count before you trust the number.

How To: Scan a Sector for a Short-Gamma Regime

The single highest-value pattern: run a fixed sector basket on a schedule and alert when the aggregate flips into negative gamma. Negative basket gamma means dealers across the sector are positioned to amplify moves, the sector is primed to trend rather than mean-revert. This is a regime read you cannot get from any single ticker.

from flashalpha import FlashAlpha

fa = FlashAlpha("YOUR_API_KEY")

SECTORS = {
    "semis":     "NVDA,AMD,AVGO,MU,SMCI,TSM,QCOM,ASML",
    "megacap":   "AAPL,MSFT,NVDA,AMZN,META,GOOGL,TSLA",
    "banks":     "JPM,BAC,WFC,C,GS,MS",
}

for name, syms in SECTORS.items():
    d = fa.exposure_basket(syms)
    agg = d["aggregate"]
    regime = "NEGATIVE - trending/amplifying" if agg["net_gex"] < 0 else "positive - dampened"
    missing = d["missing_symbols"]
    print(f"{name:8s}  net GEX {agg['net_gex']:>16,}  {regime}"
          + (f"  (missing: {missing})" if missing else ""))
    # Rank the names driving the basket
    top = sorted(d["constituents"], key=lambda c: c["contribution_pct"], reverse=True)[:3]
    for c in top:
        print(f"           {c['symbol']:6s} {c['contribution_pct']:5.1f}%  {c['regime']}")

import { FlashAlpha } from 'flashalpha';

const fa = new FlashAlpha('YOUR_API_KEY');

const SECTORS = {
    semis:   'NVDA,AMD,AVGO,MU,SMCI,TSM,QCOM,ASML',
    megacap: 'AAPL,MSFT,NVDA,AMZN,META,GOOGL,TSLA',
    banks:   'JPM,BAC,WFC,C,GS,MS',
};

for (const [name, syms] of Object.entries(SECTORS)) {
    const d = await fa.exposureBasket({ symbols: syms });
    const g = d.aggregate.net_gex;
    const regime = g < 0 ? 'NEGATIVE - trending' : 'positive - dampened';
    console.log(`${name}  net GEX ${g.toLocaleString()}  ${regime}`
        + (d.missing_symbols.length ? `  missing: ${d.missing_symbols}` : ''));
}

# Semis basket - is the sector short gamma?
curl -H "X-Api-Key: YOUR_KEY" \
  "https://lab.flashalpha.com/v1/exposure/basket?symbols=NVDA,AMD,AVGO,MU,SMCI,TSM,QCOM,ASML"

# Read aggregate.net_gex - negative means dealers across the sector amplify moves

The pattern generalises: define your baskets once, poll them on whatever cadence your strategy needs, and watch two things, the sign of aggregate.net_gex (the regime) and the top contribution_pct names (what is driving it). A sector that flips negative on the back of one dominant name is a different setup from one that is broadly short gamma across all constituents.

How To: Weight It to Your Real Book

Equal weight answers "what is the sector doing." Your actual portfolio answers "what is my dealer-flow exposure." Pass weights matching your position sizing and the aggregate reflects your book, not a generic proxy. Weights are renormalised to sum to 1, so you can pass dollar notionals, share counts, or percentages, whatever you already track.

# Weights as portfolio dollar exposure (renormalised server-side)
positions = {
    "AAPL": 240_000,
    "MSFT": 180_000,
    "NVDA": 320_000,
    "AMD":   95_000,
}
d = fa.exposure_basket(list(positions), weights=list(positions.values()))

print(f"Book-weighted net GEX: {d['aggregate']['net_gex']:,}")
print(f"Book-weighted net DEX: {d['aggregate']['net_dex']:,}  "
      "(directional dealer hedging load behind your names)")

Now aggregate.net_dex tells you the net directional dealer-hedging load sitting behind your specific holdings, and contribution_pct tells you which position is responsible for most of it, often a useful, non-obvious risk concentration read that has nothing to do with your dollar exposure ranking.

How To: Frame a Dispersion Trade

Dispersion trades live on the gap between an index and its constituents. The basket endpoint gives you the constituent side of that comparison in one call; pair it with the index's own exposure to see where single names diverge from the benchmark:

1. Pull the constituent basket: /v1/exposure/basket?symbols=... for the index members (weighted to the index if you want a like-for-like read).
2. Pull the index itself: the single-symbol GEX endpoint for SPX / NDX / SPY / QQQ.
3. Compare regimes. When the constituent basket is broadly negative gamma while the index sits positive (or vice versa), single-name dealer hedging is pulling against the index, the structural setup dispersion is built to harvest.
4. Read constituents[].regime to see which names carry the divergence, and pair with the dispersion endpoint for the implied-vol side of the same trade.

Why Not Build It Yourself?

You can. Here is what an in-house basket aggregator requires, and why the single-call version is worth it:

• N single-symbol calls per refresh. A 50-name basket is 50 GEX requests against your rate limit every time you refresh. The basket endpoint is one debit.
• Weight renormalisation and drop handling. Symbols go missing (illiquid, warming, invalid). You have to renormalise surviving weights so the aggregate stays valid, and surface what was dropped, or you ship a silently wrong number.
• Consistent contribution math. Naive |net_gex| ranking lets a tiny-weight, huge-GEX name dominate your display while contributing almost nothing to the actual aggregate. The endpoint uses weighted GEX share so the ranking matches real influence.
• Four greeks, not one. GEX, DEX, VEX and CHEX each aggregated the same way, in the same response.

API Access and Pricing

The exposure basket endpoint is on the Growth plan and higher. The entire basket, up to 50 symbols, costs a single rate-limit debit, which makes it materially cheaper than fanning out single-symbol GEX calls on metered tiers.

Explore the shape in the browser first via the basket endpoint docs (it has a live "Try It" widget), or the interactive API playground. SDKs are available in Python, JavaScript, C#, Go, and Java.

Frequently Asked Questions

Related Reading

• The Complete Flow & Dealer-Positioning API Map, every flow and exposure endpoint in one index
• Dealer Positioning & GEX: A Quantitative Approach to Options Flow
• What Is Gamma Exposure (GEX), Explained
• Why GEX Isn't Enough: Vanna and Charm Exposure
• Exposure Basket API Reference
• Interactive API Playground