Skip to content
SharkQuant
← All articles

How to Calculate Gamma Exposure: SPY Walkthrough

10 min read

Key takeaways

  • Gamma exposure is per-contract gamma multiplied by open interest, the 100-share contract multiplier, and spot, signed positive for calls and negative for puts, then summed by strike.
  • The gamma flip is the spot level where net dealer gamma crosses zero; find it by re-running your aggregation across a grid of shifted spot prices.
  • Call and put walls are the strikes with the largest positive and negative GEX, marking where dealer hedging flows concentrate, not guaranteed support or resistance.
  • Per-strike implied volatility matters because gamma scales with 1/IV, so a single ATM IV across the chain will skew your dollar gamma and shift your walls.
  • Intraday GEX is really yesterday's open interest under today's prices and vol, since exchange open interest only updates overnight, which is the same assumption paid dashboards make.

You can verify any vendor's gamma exposure numbers in a spreadsheet: pull the option chain, compute per-contract gamma, multiply by open interest, contract size, and spot squared, weight calls and puts by dealer direction, then sum by strike. This walkthrough carries real SPY numbers through every step so you can audit net GEX, the gamma flip, and the walls.

What is gamma exposure in options and why does dealer hedging depend on it?

Gamma exposure (GEX) estimates the net gamma dealers hold across an options chain, measured in dollars of delta they must hedge per 1-point move in the underlying. It comes from per-contract gamma multiplied by open interest and contract multiplier, summed by strike. You can pull the raw chains and open interest yourself from Cboe's free published option chain data. The hedging mechanism is mechanical, not predictive: dealers short calls (positive gamma to them means they sell into rallies and buy dips), while short-put-heavy positioning flips that behavior. Where net gamma crosses zero, the "gamma flip," hedging flow changes direction, which is why that level and the call/put walls matter intraday. We publish our own read of these levels at SharkQuant GEX, and later sections show how to rebuild the number from scratch so you can audit any dashboard against it.

What inputs do you need for a gamma exposure calculation?

Six inputs, all strike-level: open interest, spot price, implied volatility, days to expiry, the contract multiplier (100 for SPY and SPX), and the option's type and strike itself. With those columns in a spreadsheet you can reproduce any GEX number a vendor shows you. The full formula walkthrough lives in our gamma exposure explainer.

Where to get free options chain data

Your broker's API is the fastest free source: thinkorswim, IBKR, and Schwab all expose full chains with open interest and IV. CBOE publishes delayed delayed-quote chains for SPX and SPY, and yfinance returns delayed chain snapshots for tickers like SPY. Delayed is fine for building the calc; it is not fine for trading 0DTE off it, since a stale open-interest snapshot shifts your flip level.

Why per-strike IV matters more than a single ATM IV

Gamma scales with 1/IV, so a 30-delta put at IV 25 and a far-OTM put at IV 40 contribute very different dollar gamma even at the same open interest. Using one ATM IV across the chain systematically overweights high-IV wings, which is one reason vendor call and put walls land on different strikes. Pull IV per strike, per expiry, or your audit will disagree with every dashboard for reasons you cannot see.

How do you compute per-strike gamma exposure from open interest?

The Black-Scholes gamma formula in plain terms

Gamma is the rate of change of an option's delta with respect to the underlying price. Under Black-Scholes, for a call or put (gamma is identical for both):

Γ = φ(d₁) / (S · σ · √T)

where φ is the standard normal density, S is spot, σ is implied volatility, and T is time to expiry in years. d₁ = [ln(S/K) + (σ²/2)T] / (σ√T). Every vendor GEX chart, paid or free, starts here; the disagreements show up later in the assumptions, not in this line of math.

Converting gamma to dollar gamma

Per-share gamma tells you nothing about position size, so multiply through: dollar gamma = Γ × open interest × 100 × S. The 100 is the contract multiplier. The standard dealer convention treats calls as positive (dealers are short calls, so hedging them adds gamma-driven buying above the strike) and puts as negative. Sum the signed values across strikes and you get net dealer gamma; the flip level, where that sum crosses zero, is covered in reading the gamma flip.

Worked example: one SPY strike, end to end

Take SPY at 600, two 0DTE strikes, IV 15%, T = 1/252. Then σ√T ≈ 0.00945, d₁ ≈ 0, φ(d₁) ≈ 0.399, so Γ ≈ 0.399 / (600 × 0.00945) ≈ 0.0704 per share.

StrikeTypeOIΓ/shareDollar GEX (signed)
600Call5,0000.0704+$21.1M
595Put8,0000.0680*−$32.6M

*Gamma rises slightly as the put moves out of the money at the same expiry; the exact value comes from the same formula with d₁ recalculated.

Net for these two strikes: −$11.5M. Scale that across the full chain and you have a net GEX profile. Note how sensitive the output is: with 0DTE contracts now a large share of S&P 500 options volume per CBOE options volume statistics, which break out 0DTE activity, T changes fast intraday, and a stale T or IV input will move your dollar gamma materially even with correct open interest.

How do you aggregate strikes into a net dealer gamma profile?

Once each strike has its own GEX value, aggregation is arithmetic: sum every strike's signed gamma exposure within each expiry, then sum across expiries. Call gamma (dealer long calls, conventionally positive GEX) and put gamma (dealer short puts, negative GEX) net against each other. The result is a single number per expiry, and one number per underlying, that updates as open interest and spot move.

Finding the gamma flip from your own numbers

The gamma flip is the spot level where net dealer gamma crosses zero. Compute net GEX at a grid of spot prices, not just the current one: re-run your per-strike aggregation with spot shifted in 0.25% steps up and down, holding open interest fixed. Plot net GEX against each hypothetical spot, and the zero-crossing is your flip. Below it, dealers are net short gamma and hedge by buying dips and selling rips; above it, they hedge against the move. This is the same interpolation a dashboard like SpotGamma or DSGEX performs, and doing it yourself shows you how sensitive the flip level is to your DTE filter and OI snapshot timing.

Call walls and put walls as OI concentration, not support

A call wall is simply the strike with the largest positive GEX in your aggregate, usually a heavy OI concentration, and a put wall is the largest negative one. They mark where dealer hedging flows are largest, not price floors or ceilings. A wall can hold a move for hours and then get rolled or traded through the next morning when positions re-strike. Treat walls as friction levels with an expiry date, and pair every read with what would invalidate it: the wall strike rolling, OI shifting, or spot closing through it with volume.

How 0DTE open interest distorts the profile intraday

Here is the structural problem with same-day aggregation: 0DTE volume is enormous but open interest is a poor proxy for it intraday. Zero-DTE contracts often print heavily before OI catches up, so a profile built from the morning OI snapshot misses the gamma that actually matters by midday. Recompute your aggregate using intraday volume-weighted estimates for the front expiry, and expect the flip and walls to migrate as dealers re-hedge into the close. If your vendor chart looks stale, check whether it refreshes OI at all during the session. Every aggregate you build carries assumptions about hedging behavior and data lag, and none of it is a prediction; see our risk disclosure.

When do vendor GEX dashboards disagree, and which assumptions cause it?

Two dashboards can show different gamma flip points on the same tape, and both can be internally correct. The divergence comes from four assumption forks baked into the calculation, not from bad data.

First, weighting: gamma exposure computed from open interest behaves differently than volume-weighted GEX, especially on 0DTE names where today's volume dwarfs static OI. Second, spot versus forward: some vendors hedge to the current spot, others to a forward price adjusted for rates and dividends, which shifts the flip a few points on SPX. Third, IV source: per-strike implied volatility from the vendor's own chain versus a standardized surface changes how gamma is weighted near the wings. Fourth, expiry inclusion: whether same-day expiries are counted, and whether they use OI snapshots from the prior session, is the biggest 0DTE fork. thinkScript, for example, exposes open interest as a quote field, so any DIY GEX you build there inherits OI-based assumptions by default (thinkScript documentation).

When SpotGamma, Unusual Whales, or DSGEX disagree, check these four forks before assuming one is wrong. A practical audit: match each vendor's assumptions in your own sheet, then isolate one fork at a time. We break down the 0DTE expiry fork specifically in the 0DTE gamma landscape.

How can you turn the calculation into a gamma exposure indicator in thinkorswim or a spreadsheet?

thinkorswim: what thinkScript can and cannot pull

thinkScript can compute gamma per strike using a Black-Scholes model, but it cannot read open interest for arbitrary strikes into a custom study in a way that lets you weight it and aggregate to net GEX. You can approximate per-strike gamma, but the dealer-positioning layer, the part that produces the gamma flip and the call and put walls, has to live outside thinkorswim. The gamma formula itself is standard: gamma equals N'(d₁) divided by S times σ times √t.

A spreadsheet or Python pipeline that refreshes intraday

Start with the data pull, not the math. A Python script using yfinance or your broker's API grabs the full chain in a few lines: strike, type, open interest, IV, and last price. Compute d₁ and gamma per contract with the formula above, multiply by open interest and 100, sign calls positive and puts negative, and write one row per strike. Aggregate by expiry, then across expiries, and store each run with a timestamp so you can see how the profile drifts through the session. Schedule the pull every 15 minutes during regular hours and log the spot price alongside each snapshot so you can reconstruct the flip level later; the whole pipeline is a few hundred lines, and the discipline of writing it yourself is the point, because every assumption you would otherwise inherit from a vendor becomes a line of code you can read, change, and defend when your numbers diverge from a dashboard.

Google Sheets with a scheduled Apps Script call to a chain data endpoint works for a 15-minute cadence; Python with a scheduler gets you faster refreshes. The binding constraint is OI latency: exchange OI updates overnight, so intraday "GEX" is really yesterday's OI under today's prices and vol. That is the same assumption your paid dashboard makes, which is why cross-checking against a vendor read is an audit, not a validation.

How does your homemade GEX compare to free gamma exposure charts from vendors?

Your spreadsheet wins on auditability: you know the expiry filter, the gamma-per-contract convention, and whether calls are signed negative. Vendor dashboards win on latency and coverage. Free gamma exposure charts typically refresh on a delay and lock you into one aggregation method, so you cannot test whether a 0DTE-inclusive net GEX changes the flip level versus open-interest-only math.

Paid platforms like SpotGamma and Unusual Whales add intraday recalcs, flow filters, and wall tracking that a manual build cannot match on speed. If your GEX is 15 minutes stale, it is worthless for intraday decisions, and a spreadsheet updated hourly sits on the wrong side of that line.

SharkQuant sits in the middle honestly: its Core tier at $29.99/mo pairs dealer positioning and options flow with an invalidation condition on every read, which a spreadsheet lacks, but it still will not let you rewrite the gamma formula itself the way your own build does. If formula transparency is the priority, keep the spreadsheet and use a paid dashboard for latency.

FAQ

Is gamma exposure calculation accurate if I use volume instead of open interest?

It is a different number, not a wrong one. Volume-weighted GEX captures same-day positioning that static open interest misses, which matters most on 0DTE names where today's prints dwarf accumulated OI. The catch is noise: volume includes trades that close within minutes, so the aggregate shifts faster and the flip level migrates more than an OI-based build.

How often does dealer gamma exposure change during the trading day?

Continuously, because spot, IV, and time to expiry all move while dealers re-hedge. The open-interest input only updates overnight, so an intraday aggregate is really yesterday's OI under today's prices and vol. On 0DTE names, T decays fast enough that dollar gamma moves materially even with unchanged OI, so recompute on a 15-minute cadence at minimum.

Can I get a free gamma exposure chart without paying for SpotGamma?

Yes. Cboe publishes free delayed option chains and open interest, which is enough to build your own per-strike calculation in a spreadsheet or Python script. Free vendor charts exist but typically refresh on a delay and lock you into one aggregation method, so you cannot test whether including 0DTE expiries changes the flip level.

Does gamma exposure work on individual stocks or only SPX and SPY?

The math is identical for any ticker with listed options: per-strike gamma times open interest times the 100-share multiplier, signed by type and summed. The catch is depth. Single names have thinner chains, fewer strikes with real OI, and less consistent dealer hedging, so walls and flip levels are noisier and less reliable than on SPX or SPY.