DEV Community: tomasz dobrowolski

50 Options Strategies, 6 Years, Real Bid-Ask Prices: Only 10 Had a Positive Mean

tomasz dobrowolski — Thu, 17 Sep 2026 05:36:32 +0000

TL;DR: 50 options strategy profiles, priced from a minute-level options archive at end-of-day quotes, SPY/QQQ/IWM, 2020 to 2025. Identical rules: enter at the close after the first trading day of the month, exit ten sessions later, ~35 DTE, buy at ask, sell at bid, $0.65/contract/side. 10 of 42 monthly profiles had a positive mean after costs. The top five all own equity upside in a market that went up. Every number has a downloadable trade ledger.

Reading the numbers

Mean after costs is average P&L per trade against the value of 100 shares of the ETF. On a $500 ETF that is $50,000, so +31.2 bps ≈ $156 a trade. No risk adjustment: a credit spread and a long call can sit adjacent with very different risk. Mean far from median means a few trades are moving the average.

Monthly ETF table, the positive half

#	Strategy	Family	Trades	Mean (bps)	Median	Win rate	Worst
1	Covered call	Stock overlay	186	+76.3	+171.3	69.9%	-1184.4
2	Protective put	Stock overlay	188	+70.2	+117.8	61.7%	-936.4
3	Collar	Stock overlay	184	+43.1	+106.0	63.6%	-759.0
4	Bullish risk reversal	Ratio/RR	208	+41.5	+66.2	61.5%	-719.2
5	Long call	Directional	212	+36.3	+33.1	53.8%	-457.4
6	Vol-carry filtered put spread	Signal filter	73	+16.5	+28.6	72.6%	-224.2
7	Bull call debit spread	Directional	185	+12.2	+33.5	59.5%	-280.1
8	Call diagonal	Calendar/diagonal	176	+10.3	+39.5	63.1%	-364.2
9	Cash-secured put	Stock overlay	212	+9.0	+50.3	74.1%	-2007.2
10	Put ratio spread	Ratio/RR	194	+2.8	-2.1	46.9%	-141.4

Ranks 11 to 42 are all negative, ending at -61.1 bps (bearish risk reversal and poor man's covered call) and -74.8 (term-structure conditioned calendar, 4 trades).

Symmetric butterflies and single-right condors won fewer than one trade in six. The put condor won 5.0%, lowest in the study. Mostly a structure/holding-period mismatch: a debit butterfly earns its value in the final days before expiry, and a ten-session exit on a 35-day option leaves that behind while paying three or four legs of spread.

The stricter comparison: six structures, same 133 months

#	Strategy	After costs	At midpoint	Win rate
1	Long call	+31.2	+37.9	55.6%
2	Bull call debit spread	+10.4	+19.8	58.6%
3	Bull put credit spread	+8.6	+13.7	72.9%
4	Iron condor	-9.7	-0.2	53.4%
5	Call calendar	-17.2	-1.3	33.1%
6	Long straddle	-17.6	-2.9	42.1%

Win rate is not P&L. 72.9% wins put the credit spread third. Loss size matters as much as loss frequency.

Costs reorder the table. Call calendar: -1.3 at midpoint, -17.2 after spread. Iron condor: flat to -9.7. If a strategy only works at midpoint, it does not work.

First place is not an edge. The ETFs rose an average of +93.6 bps over the same windows. Five of six have a 95% interval for the mean that includes zero; the long call's is roughly -18.5 to +79.5.

The spread is the story

Every mirror pair in the dataset has exactly opposite midpoint results and both sides lose after costs:

iron condor / reverse iron condor
iron butterfly / reverse iron butterfly
call ratio spread / call backspread
put ratio spread / put backspread

Direction of the trade did not decide these outcomes. Crossing the bid-ask four times did.

The worst offender: poor man's covered call, +53.3 bps at midpoint, -61.1 after costs. Largest cost drag in the dataset. Long-dated deep-ITM calls have wide spreads and this sample crosses them twice in ten sessions. A real PMCC holds the long call for months and rolls only the short, which is not what was tested.

Signal filters: one of four did anything

Filter	Condition	Trades	Mean	vs unfiltered
Vol-carry put spread	ATM IV ≥ 1.2 × 20d RV	73	+16.5	-0.9 → +16.5, skipped the worst month
Vol-carry iron condor	Same condition	67	-14.1	-10.5 → -14.1, worse
Skew-conditioned vertical	25d put IV − 25d call IV ≥ 0.03	170	-2.0	fired almost always, same worst trade
Tail-pricing put spread	10d put IV − ATM put IV ≥ 0.05	162	-1.7	fired almost always, same worst trade
Term-structure calendar	Back 50d call IV − front ≥ 0.02	4	-74.8	condition almost never held

The lesson in the bottom three rows: a filter that fires on nearly every window is not a filter. Build the control sample (the windows where it did not fire) before believing the conditional mean.

Earnings: 12 events, useful as worked examples only

Four 2025 announcements each for AAPL, MSFT and AMZN. In one session before, out one session after.

Strategy	Trades	Mean	Win rate
Earnings short strangle	11	+96.4	90.9%
Post-earnings vol crush	12	+67.1	66.7%
Earnings iron condor	11	+41.2	81.8%
Pre-earnings vol buildup	12	-31.5	33.3%
Earnings diagonal	12	-44.3	33.3%
Earnings calendar	6	-44.4	0.0%
Earnings long straddle	12	-122.5	25.0%

Six to twelve trades each on three of the most liquid stocks in one year. This shows how the accounting works, not that it keeps working. No margin model, and a short strangle without one measures a position nobody could hold.

The wheel

$100,000 starting cash per account, one contract at a time, held to expiry, assignment on anything finishing ITM, no interest on idle cash, no early assignment. 106 completed cycles.

SPY 22.4%, QQQ 21.9%, IWM 4.8% total return over six years. Mostly cash the whole time. Compare with holding the ETF and with holding cash at a real rate before concluding anything.

Method

Schedule: select from first observed trading day's EOD chain each month, enter next close, exit 10 sessions later. No stops, targets, rolls or hedges.
Expirations: front 35 calendar days (30–45); back leg 65 (55–80).
Strikes: delta 50/25/10 means nearest archived absolute delta, rejected beyond 0.10 away. ATM is nearest strike to spot on signal day.
Quote gates: positive uncrossed bid/ask on signal, entry and exit days; signal-day spread ≤ max($0.10, 30% of mid); displayed size covering the trade. Missing later quote excludes and records the trade rather than substituting.
Dividends: ex-div windows excluded for stock overlays and any short call. Early assignment not modelled.
Costs: one contract per leg, buy at ask, sell at bid, $0.65/contract/side. Stock legs cross the underlying spread, no commission.
RV: sample SD of 20 unadjusted log returns, annualised by √252. IV stored as decimal, so 0.03 is three vol points.
Uncertainty: 1,000 bootstrap resamples of complete calendar months, three ETFs within a month kept together.

216 scheduled ETF-month windows, 133 survived for all six headline structures (SPY 54, QQQ 39, IWM 40). Requiring valid entry and exit quotes can bias the surviving sample. Expanded release: 7,265 option-trade simulations, 106 wheel cycles, 42 monthly profiles, 7 earnings profiles.

Not modelled: early assignment, financing, margin, collateral yield, taxes, market impact, daily account path. Retrospective study designed in 2026 with no untouched holdout. End-of-day quotes are aggregated views without a contributing timestamp.

Reproduce it

Download packs include raw query responses, selected legs, quote lineage, trade results, exclusions, calculation code and offline reproduction instructions, with file hashes.

Article and all 50 profiles: https://flashalpha.com/articles/options-strategies-ranked-light-backtest-spy-qqq-iwm
Historical API docs: https://flashalpha.com/docs/historical-api
Historical playground: https://flashalpha.com/docs/historical-playground

The archive behind this runs at one-minute resolution back to January 2017, so the obvious next tests are intraday entries and exits, per-leg spread filters at entry, and holding to expiry instead of a fixed ten sessions.

Every API Response Should Prove Its Own Freshness. Here Is How We Do It for Options Data

tomasz dobrowolski — Tue, 15 Sep 2026 12:58:02 +0000

TL;DR: Options data fails silently. A stale chain, misattributed OI, a one-sided quote solved into a fake IV, a replay that returns the nearest row: none throw an error, all produce a confident number. FlashAlpha's answer is to verify against independent sources several times a day, refuse with a named reason when a check fails, and stamp every response with data_as_of so freshness is a field you read rather than a claim you accept. Keyless verification at the bottom.

Three properties, six layers

Trustworthy data is checked against something independent, fails closed with a machine-readable reason, and carries its own provenance in the response. Six layers deliver that.

1. Ingest with per-feed liveness

Exchange-grade feeds, instrument mapping resolved before storage so a contract's identity survives symbol reuse and rolls. Every physical feed (equity options, index options, futures, futures options, spot) is tracked on its own row with throughput and session health evaluated every minute. Settled OI confirmed before every open, written idempotently so re-runs cannot double-count. Universe of 6,000+ option roots refreshed as roots list and delist.

2. Cross-source reconciliation, several times a day

Check	Compared	Independent reference
Chain reconciliation	Every contract's coverage, OI and price, scored per symbol	Second market-data source
Index spot re-derivation	Spot implied by the chain via put-call parity, per expiry, outlier-trimmed	The chain itself (arbitrage identity)
Futures-to-cash parity	ES, NQ, RTY vs SPX, NDX, RUT cash	Cost-of-carry basis band
Session volume, two layers	Live tape vs vendor totals; per-contract accumulator vs its own tape	Vendor totals, conservation identity
Served-layer conservation	OI actually served by exposure endpoints, summed per strike	Truth source, per strike
Earnings dates	Rotating sample of upcoming reports	Second calendar provider

Recent full sweep: 54,705 contracts across 41 symbols at 99.6% OI agreement on comparable contracts.

The served-layer row is the one most vendors skip. Reconciling what the feed delivered is table stakes. We also reconcile what the API serves: the per-strike OI behind the GEX profile in your response is compared with the reference per strike.

A reconciliation whose reference returns nothing comparable is itself a failure. The check cannot quietly stop checking.

3. Serving guards that fail closed

Verification is theatre if degraded data is served anyway. Every refusal is machine-readable.

409 stale_data instead of a frozen price on the realised-vol and forecast endpoints:

HTTP/1.1 409 Conflict
{
  "error": "stale_data",
  "message": "The historical price archive's most recent bar is 2026-07-28 (5 trading days old). Data is stale; refusing to serve a frozen price or fit models on it. Re-hydrate the symbol's history.",
  "stale_since": "2026-07-28",
  "stale_trading_days": 5
}

Ghost quotes excluded. One-sided or crossed quotes are dropped from IV solving, Greeks and exposure aggregates rather than solved into a fictitious surface.

Gamma flip certified before publication. gamma_flip_status is available or names the failed check. No regime label is ever derived from an uncertified level.

Isolated computation per request. Each request computes on its own snapshot of the store, so numbers in one response are internally consistent and data_as_of describes exactly the feed deliveries used.

Coverage and availability gates. Strategy scorers return insufficient_data on thin history. Settled expiries never contaminate live profiles. A fleet-wide control can withdraw serving for a class or symbol in seconds with the standard no_data envelope.

4. Thirty pipelines, one health registry

Every pipeline (feed sessions, ingest, nightly writers, reconciliation monitors, alert delivery, serving loops, across every host) reports status, last-run, staleness and consecutive-failure count into one registry. Dedicated monitors on top: feed liveness every minute, served spot checked for movement every five minutes in session, OI publication confirmed before open, external processors tracked by heartbeat.

Alerts are edge-triggered and trading-calendar aware. A digest reaches humans twice per trading day whether or not anything is wrong. Silence is never assumed to mean health.

5. Point-in-time archive with archive_as_of

Stored inputs are never restated. Corrections go in the changelog, never silently under a backtest. A look-ahead guard in the replay engine and a freshness guard on the archive enforce this by construction. Every historical response carries archive_as_of in the same nine-feed shape as the live stamp. Same engine serves live and replay; parity pinned by test and sampled continuously against production.

6. data_as_of on every response

Two fields, added in one place so no endpoint can omit them: endpoint_version (the deployed build) and data_as_of (delivery timestamp of each upstream feed the responding node uses, plus node name).

{
  "symbol": "SPY",
  "underlying_price": 764.23,
  "as_of": "2026-08-24T18:49:00.697Z",
  "endpoint_version": "2026.08.25",
  "data_as_of": {
    "node": "fa2",
    "equity_feed":          "2026-08-24T18:49:00.512Z",
    "equity_options_feed":  "2026-08-24T18:48:58.204Z",
    "index_feed":           null,
    "index_options_feed":   null,
    "futures_feed":         null,
    "futures_options_feed": null,
    "flow_feed":            "2026-08-24T18:49:00.220Z",
    "oi_feed":              "2026-08-21T20:00:00.000Z",
    "macro_feed":           "2026-08-24T18:42:11.000Z"
  }
}

Feeds are stamped by physical pipe, not asset class, because spot and options arrive over different connections. Read each slot against its own cadence:

Key	Feed	Expected cadence
`equity_feed`	Equity/ETF spot	Seconds, market hours
`equity_options_feed`	Equity/ETF options	Seconds, market hours
`index_feed`	Index spot (SPX, NDX, RUT, VIX)	Seconds, market hours
`index_options_feed`	Index options	Seconds, market hours
`futures_feed`	Futures prices	Seconds, futures session
`futures_options_feed`	Futures options	Seconds, futures session
`flow_feed`	Classified trade tape	Seconds, market hours
`oi_feed`	Settled open interest	Daily, prior 16:00 ET close
`macro_feed`	VIX, VVIX, SKEW, MOVE, SPX, Fear and Greed	Minutes; reports its oldest field

The example is Monday midday and oi_feed shows Friday's close. Correct: Monday's settled OI does not exist until Monday settles. Slots a request did not read are null. macro_feed deliberately reports its oldest constituent so one lagging series cannot hide.

Top-level array responses carry the same object in X-Data-As-Of and X-Endpoint-Version headers. The Python SDK types it as DataAsOf.

Keyless provenance. /health, /livez and /readyz on lab.flashalpha.com return the same data_as_of object with no API key. Point your own monitoring at it.

Verified from outside

An external monitor probes every 30 seconds over the public customer path: a real analytics endpoint with a real key (well-formed but wrong counts as failure), the ingest with per-feed liveness, and the historical service. It reads data_as_of itself and fails any feed behind inside its own session. It also checks via put-call parity that the served book prices the served spot. Results drive flashalpha.com/status with per-component 90-day uptime, above 99.9% on every component at time of writing. The monitoring stack has 5,000+ automated tests.

Verify it in sixty seconds

# 1. Feed freshness, no key
curl -s https://lab.flashalpha.com/health

# 2. Public availability, per component, per day, 90-day window
curl -s https://lab.flashalpha.com/v1/status

# 3. Any data call: read data_as_of beside the numbers
curl -s -H "X-Api-Key: $FLASHALPHA_API_KEY" \
     https://lab.flashalpha.com/v1/exposure/gex/SPY

Gating in a pipeline, against the feeds your query actually depends on:

from datetime import datetime, timedelta, timezone
from flashalpha import FlashAlpha

fa = FlashAlpha(api_key="...")
gex = fa.gex("SPY")

feeds = gex["data_as_of"]
now = datetime.now(timezone.utc)

def age(key):
    stamp = feeds.get(key)
    if not isinstance(stamp, str):
        return None
    try:
        return now - datetime.fromisoformat(stamp.replace("Z", "+00:00"))
    except (ValueError, TypeError):
        return None

# A SPY GEX call depends on equity spot and equity options, both of which
# should be seconds old in session. Settled OI follows its own daily cadence.
in_session = [age("equity_feed"), age("equity_options_feed")]
fresh = all(a is not None and timedelta(0) <= a < timedelta(minutes=5) for a in in_session)

if fresh:
    print(f"GEX {gex['net_gex']:.3e} from node {feeds['node']}, build {gex['endpoint_version']}")
else:
    print("Feeds behind cadence - hold the signal until they catch up.")

Pair it with the status fields already on the analytics: gamma_flip_status before gamma_flip, data_quality_score on the 0DTE path, archive_as_of on every replay. Your pipeline is then gating on the same signals our monitors gate on.

FAQ

data_as_of vs as_of? data_as_of describes the inputs (when each feed last delivered). as_of describes the output (when the response was generated or the newest contract ticked).

Why is oi_feed dated to yesterday? Settled OI is published once per session, dated to the prior close. That is the newest settled OI that exists.

Historical too? Yes. archive_as_of in the same shape, same engine, same guards, archive never restated.

Due diligence access? Everything verifiable from outside is public. Tolerances, schedules, source pairings and SLA riders are shared under NDA via flashalpha.com/institutional.

Trading Gamma Flip Crosses Without Getting Faked Out: regime, unknown, and a Reference Detector in Python

tomasz dobrowolski — Mon, 14 Sep 2026 08:53:51 +0000

TL;DR: regime is spot versus the same snapshot's gamma_flip, and only when that level is certified. unknown means one of three things: no level, an unverified level, or spot sitting on the flip. Classify a cross by the regime after it, and only once the label has committed to a side with the level still where it was. Code at the bottom.

Three fields, read as a unit

`gamma_flip`	`gamma_flip_status`	`regime`	Meaning
number	`available`	`positive_gamma` / `negative_gamma`	Certified level, certified side. The only row you build a regime rule on.
number	`available`	`unknown`	Certified level, spot inside the certified window around it. You are at the flip.
number	`sensitive_root`, `uncertain_root_path`, `quality_budget`, `uncertain_gamma_variance`, `insufficient_local_coverage`, `insufficient_quote_quality`	`unknown`	Unverified level. Root exists but failed the named check. Context only, never a side.
null	`no_boundary`, `stored_sign_mismatch`, others	`unknown`	No supportable boundary. Nothing to trade against.

Reading gamma_flip alone is the easiest mistake to make.

How regime is computed

Within one response, spot and the flip come from the same snapshot: same chain, same underlying_price, same as_of. If the level is certified, spot at or above it is positive_gamma, below it is negative_gamma. No smoothing, no carry-forward, no inference from an unverified level.

Which chain depends on the endpoint:

Endpoint	Chain	Carries
`/v1/exposure/zero-dte/{symbol}`	Selected expiry only (today by default; `expiry=` for 1DTE/2DTE)	flip, status, regime, positional fields
`/v1/stock/{symbol}/summary` (`exposure` block)	Every live expiry	flip, status, regime
`/v1/exposure/levels/{symbol}`	Every live expiry	flip, status (no regime label)
`POST /v1/screener`	Every live expiry	`gamma_flip_status` as a filter, e.g. `eq available`
Same routes on `historical.flashalpha.com` with `?at=`	Same as live, point-in-time	Same as live

The 0DTE label and the whole-book label can legitimately disagree at the same instant. Pick the one that matches what you trade and stay on it. Taking the level from one endpoint and the regime from another compares two different books.

Certified means: at least 75% of OI on the path from spot to the level carries usable gamma, expiry-day quotes carry more time value than spread, and scaling any single strike's gamma by 0.75 or 1.25 leaves the zero-crossing within 0.1% of spot (0.25% on a bounded retry). Levels that fail are still shown with the failing check and regime unknown.

The three meanings of unknown

No level (gamma_flip null). Aggregate gamma keeps one sign across the search band, or the reconstruction disagrees with stored net-GEX sign. Stand down from any flip-based rule. net_gex still gives a coarse read of aggregate exposure sign.

Unverified level (status is a check name). Root exists but failed coverage, quote-quality or single-strike stress. Use it as a level to watch (median unverified root in the validation set is ~0.5% from spot). Do not compare it with spot yourself to manufacture a regime.

At the flip (status available, regime unknown). Certified level, spot inside the certified window, one strike's quote could put it either side. This is the transition zone where crosses happen. Wait. On the 0DTE endpoint, distance_to_flip_sigmas and spot_to_flip_pct show how deep in the zone you are.

Downstream fields follow the same rule: when regime is unknown, everything conditioned on regime returns null (GEX and vanna conditioned blocks, VRP regime label, short-put-spread, short-strangle, iron-condor and net harvest scores). Positional fields on the 0DTE endpoint (spot_vs_flip, spot_to_flip_pct, distance_to_flip_dollars, distance_to_flip_sigmas) stay populated for unverified levels because they describe where the root is, not which side dealers are on.

Pre-cross or post-cross regime?

Post-cross. The label describes the hedging environment you are entering, which governs how price behaves from here. Above the flip dealers are long gamma and dampen moves; below it they are short gamma and amplify them. A positive-to-negative cross is a breakout because the post-cross environment amplifies. The pre-cross regime tells you what you left.

A naive "label changed between two polls" rule fails for two reasons.

The level can cross spot. The flip is recomputed from the live book every snapshot. OI or gamma shifting at a nearby strike moves the level across a stationary price and the label flips with no breakout. Compare gamma_flip on both snapshots, require available on both, and treat a level move above ~0.25% of spot as a relocation. In validation replay, certified levels moved at most 0.32% of spot between consecutive minutes while spot moved under 0.1%.

unknown is the transition zone. Around the level the label reads unknown for one or more snapshots before committing. A cross is confirmed only when the post-cross label is a side and differs from the last committed side. For hysteresis, distance_to_flip_sigmas gives a band in units of remaining expected move. 0.3 sigma of follow-through is a reasonable starting point; tune to your holding period.

Reference cross detector

State machine against the 0DTE endpoint. Keeps last committed side, ignores unverified levels, treats unknown as waiting, rejects relocations, requires sigma follow-through.

import requests, time

API = "https://lab.flashalpha.com"
HEADERS = {"X-Api-Key": "YOUR_KEY"}

def snapshot(symbol):
    r = requests.get(f"{API}/v1/exposure/zero-dte/{symbol}", headers=HEADERS, timeout=10)
    r.raise_for_status()
    d = r.json()
    reg = d["regime"]
    return {
        "as_of": d["as_of"],
        "spot": d["underlying_price"],
        "flip": reg["gamma_flip"],
        "status": reg["gamma_flip_status"],
        "label": reg["label"],
        "sigmas": reg.get("distance_to_flip_sigmas"),
    }

class CrossDetector:
    MAX_LEVEL_MOVE = 0.0025   # rule of thumb: larger = the level moved, not spot
    MIN_FOLLOW_THROUGH = 0.3  # sigma beyond the level before we call it

    def __init__(self):
        self.last_side = None     # last committed regime
        self.last_flip = None     # flip at that commit
        self.last_flip_spot = None

    def update(self, s):
        # Only certified levels participate. Unverified: watch, never classify.
        if s["flip"] is None or s["status"] != "available":
            return "no_certified_level"

        if s["label"] == "unknown":
            return "at_flip_waiting"   # transition zone: spot inside the certified window

        side = s["label"]
        if self.last_side is None:
            self.last_side, self.last_flip, self.last_flip_spot = side, s["flip"], s["spot"]
            return "initialised"

        if side == self.last_side:
            self.last_flip, self.last_flip_spot = s["flip"], s["spot"]
            return "no_change"

        # The label committed to the other side. Did spot cross, or did the level move?
        if abs(s["flip"] - self.last_flip) / s["spot"] > self.MAX_LEVEL_MOVE:
            self.last_side, self.last_flip, self.last_flip_spot = side, s["flip"], s["spot"]
            return "level_relocated"

        if s["sigmas"] is not None and s["sigmas"] < self.MIN_FOLLOW_THROUGH:
            return "cross_pending_follow_through"

        self.last_side, self.last_flip, self.last_flip_spot = side, s["flip"], s["spot"]
        return "breakout_down" if side == "negative_gamma" else "breakout_up"

det = CrossDetector()
while True:
    s = snapshot("SPY")
    event = det.update(s)
    if event.startswith("breakout"):
        print(s["as_of"], event, "flip", round(s["flip"], 2), "spot", s["spot"])
    time.sleep(30)

What it never does: carry a stale level forward, compare spot with an unverified level, read unknown as a side. It classifies by the side it just committed to.

Backtesting

Point the same detector at historical.flashalpha.com with ?at=2026-09-10T14:30:00 (ET wall-clock, same clock as stored data) and step forward a minute at a time. Same calculation, same certification, same statuses. Expect the same unknown stretches and unverified levels you see live, especially in the last half hour of an expiry day. A backtest on an always-populated, always-certified level overstates signal availability.

Four anti-patterns

Carrying the last known flip forward when the current one is null.
Treating unknown as bearish.
Comparing spot with an unverified level to manufacture a regime.
Taking the level from one endpoint and the regime from another.

Why We Made Our Gamma Flip Nullable (And Two Thirds of Chains Now Return Null)

tomasz dobrowolski — Fri, 11 Sep 2026 13:58:43 +0000

TL;DR: FlashAlpha's gamma_flip is now nullable. It publishes only when the option book passes three checks (local coverage, expiry-day quote quality, single-strike sensitivity). When it fails, you get null plus a machine-readable gamma_flip_status. Roughly one chain in three publishes. Across 647,574 stress trials, zero published levels moved more than 0.1% of spot.

The problem

The gamma flip is a regime boundary. Above it dealers are net long gamma and dampen moves; below it they are net short and amplify them. Systematic desks gate strategies on which side spot sits.

Late in a 0DTE session, time value decays into the bid-ask spread. A contract quoted 0.40 by 0.50 at noon might be 0.05 by 0.15 at 15:45. The spread stayed a dime; time value collapsed below it. The gamma you back out of that midpoint is a property of whichever quote printed, not of the market. Feed it into a zero-gamma solver and you get a precise-looking number that jumps hundreds of points minute to minute.

We measured it. On a real SPX 0DTE session, an ungated level crossed spot five times in thirteen minutes on an underlying that moved 0.03%. Each crossing implied a full regime inversion. Nothing had changed.

Smoothing does not fix this. The quantity is bistable, not noisy. Averaging two attractors gives a number between them that describes neither. The honest fix is to detect when the book cannot support a level and decline to publish one.

How the flip is computed

We reprice every contract's gamma across candidate underlying prices and solve for where aggregate dealer gamma crosses zero. That yields a continuous price, not the nearest listed strike, and reconciles against the net_gex in the same response.

Finding a root is easy. Publishing it requires passing three gates.

The three gates

Gate	Check	Threshold
Local coverage	OI between spot and candidate level (multiplier-weighted) must carry a gamma the model can represent. Unpriced positions stay in the denominator.	≥ 75%
Quote quality (expiry day)	Same-day OI in that corridor must have two-sided quotes whose midpoint carries more time value than the full spread.	≥ 75%
Sensitivity certificate	Scale each strike's gamma by 0.75 and 1.25, one at a time. Bounded interval certificate verifies the perturbed book still crosses zero near the published level and no nearer crossing appears.	≤ 0.1% of spot

A feasible-peak scenario is included where positive stress would otherwise remove a represented leg from the inverse model, so a boundary cannot look easier to certify because an opposing leg vanished.

The certificate is deliberately limited: discrete scenarios only. It does not prove robustness to simultaneous multi-strike changes or every future condition. No temporal smoothing, no carrying yesterday's level forward.

Why the last hour is where levels vanish

Gate two is the one that bites into the close, and the mechanism is just time. Extrinsic value decays through the afternoon; the spread does not. Once spread exceeds remaining time value, the midpoint is market-maker spread, not a volatility view.

Stated plainly: the hour when 0DTE traders most want a gamma flip is the hour when the data least supports one. Any platform showing a confident level at 15:50 on expiry day is either using a different definition or not checking.

Also note: open interest does not guarantee a two-sided market. Under FlashAlpha's quote policy a one-sided market, or a contract inside its final minute, produces an OI-only snapshot with gamma and IV both zero. That is intended, not lost data, and those legs never reach the gamma-to-vol inversion.

Reason codes

`gamma_flip_status`	Meaning
`available`	Passed every check. Use it.
`insufficient_quote_quality`	Expiry-day quotes are spread-dominated. Most common into the close.
`sensitive_root`	A single strike could move the level beyond tolerance. Root exists but is not robust.
`insufficient_local_coverage`	Too much OI between spot and the level has no usable gamma.
`no_boundary`	Aggregate gamma keeps one sign across the search band. No nearby flip.
`stored_sign_mismatch`	Repriced book disagrees with stored net-GEX sign. Reconstruction not trustworthy.

Treat any unrecognised value as unavailable; the list can grow.

When the flip is withheld, regime reads unknown and everything conditioned on regime returns null: GEX and vanna conditioned blocks, VRP regime label, short-put-spread, short-strangle, iron-condor and net harvest scores. Standalone fields keep working: net_gex, IV, RV, VRP spread, calendar-spread score.

Validation

Thresholds were set on 4,575 frozen historical books across SPXW, SPY, QQQ, IWM, NVDA, TSLA and META at 0, 7 and 28 DTE, validated against an independent implementation, with two holdouts acquired after the rules were fixed.

Population	Captures	Published
Development	2,412	663
Holdout	1,083	251
Intraday holdout	1,080	699
Total	4,575	1,613

The model produced 3,486 numeric roots; 1,613 passed publication. 64.74% of the corpus withheld.

Stress sweep: 647,574 single-strike trials. 294,508 had numeric results on both sides; none moved beyond 0.1% of spot. Largest move 0.0999981%. 2,630 lost publications and 2,080 gained were tracked separately, not counted as zero movement. A separate certificate replay covered 319,405 variants including 22,267 feasible-peak scenarios, with no tolerance violations.

Live session open: sampled every 45 seconds for 25 minutes. SPY full chain, SPY 0DTE and SPX full chain published on all 34 samples, zero spot crossings, max consecutive move 0.24%. SPX 0DTE published 23 of 34; every published value held its side of spot.

Availability drops. Reliability of what is published does not.

Cost: on a 19,524-leg SPXW chain, local p99 latency was ~96 to 109 ms, 1.36 to 1.55x the pre-change baseline, excluding DB and production middleware. Not a deployed latency promise. Validation summary JSON is linked from the original article.

Handling it in code

gamma_flip is nullable. Branch on it. Python, JavaScript, .NET, Go and Java SDKs all expose gamma_flip_status.

from flashalpha import FlashAlpha

fa = FlashAlpha(api_key="...")
levels = fa.exposure_levels("SPY")

flip = levels.get("gamma_flip")
if flip is None:
    # Do not substitute a strike crossing or the last known value.
    # The reason tells you whether to retry later or stand down.
    reason = levels.get("gamma_flip_status")
    print(f"No supported flip right now ({reason}); regime is unknown.")
else:
    print(f"Gamma flip {flip:.2f}, regime {levels['regime']}")

Two anti-patterns:

Do not carry the last known flip forward. A stale boundary is exactly the error the gates prevent.
Do not treat unknown as bearish. It is absence of information, not a negative-gamma reading.

One exception: polarity=flow on the flow endpoints returns a crossing of the dealer-position-signed per-strike profile. Different quantity, different method, no certificate. Do not compare the two.

Backtesting

The same calculation and gates run in point-in-time historical replay. A strategy tested on historical levels sees the same gaps it will see live. A backtest on an always-populated level would overstate signal availability.

Verify it yourself

Every book in the validation set is a stored session on the historical API. Replay the same symbol and timestamp, perturb the per-strike surface, recompute.

Playground: https://flashalpha.com/docs/playground
Methodology: https://flashalpha.com/methodology
API key: https://flashalpha.com/pricing

GEXBot vs FlashAlpha: Beyond GEX to Quant Research

tomasz dobrowolski — Fri, 11 Sep 2026 13:55:10 +0000

Disclosure: FlashAlpha publishes this comparison. The recommendation rests on the documented workflows below, not on any claim of superior trading returns. Public pages and discovery endpoints were checked on 9 September 2026. Prices are USD on monthly billing, before discounts. Paid feeds were not benchmarked against each other.

TL;DR

If you need a streaming GEX feed and nothing else, GEXBot Quant at $350/month is cheaper. If you need to build and operate a research system (features, backtests, screening, position evaluation, production delivery), FlashAlpha supplies documented components for each stage. Comparing the price of one GEX request leaves most of the product out.

Endpoint breadth that works together

Research capability	FlashAlpha API examples	What you can build
Exposure and positioning	GEX, DEX, VEX, CHEX, levels, summaries	Spot, directional, vol and decay sensitivity in one feature set
Volatility and risk premium	Realised vol, skew, term structure, VRP, SVI parameters	Test how vol pricing interacts with positioning; inspect model params
Intraday flow	Effective-OI exposure, dealer-risk shift, simulator state, unusual-flow signals	Compare settled vs estimated intraday exposure
Screening and events	Filters, ranking, custom formulas, earnings calendar	Universe-wide candidate selection with event context
Position analysis	Multi-leg Greeks, expiry P&L and breakevens	Evaluate the structure before trading it
Historical replay	Timestamp-selected replay of live analytics back to January 2017	Historical feature datasets with the same response shapes as live

Tier gating: Basic includes DEX/VEX/CHEX, max pain and position analysis. Growth adds the broader live toolkit. Alpha adds historical replay and advanced research inputs.

The benefit is less analytics infrastructure to build and maintain. IV solving, exposure aggregation, surface fitting and historical retrieval are separate engineering tasks when you start from raw chains. Your team still owns hypothesis, validation and execution. A subscription does not supply a profitable strategy.

GEXBot also has APIs, research analytics and higher-order Greeks. The argument here is the combined workflow, not that GEXBot is chart-only.

Example workflow

Question: does volatility risk premium behave differently across dealer-positioning regimes?

Build historical features. Query historical GEX, VEX, CHEX and VRP for the same symbol and timestamp. Join with your outcome data.
Validate. Time-split, out-of-sample test, retain inputs and engine version. This part is yours.
Screen live candidates. Filter and rank the universe, then drill into exposure, flow and vol endpoints for the selected symbols.
Evaluate and monitor. Post proposed legs to the position-Greeks and P&L endpoints, then poll live metrics over REST or scope streaming.

GEXBot's GEX feeds can be an input to this system. Their price does not account for the rest of it.

Historical replay is the live API with a timestamp

This is the part developers care about. The Historical API is not a separate product with its own schema. More than 50 live routes are mirrored on the historical host with the same paths, fields and units, minute by minute back to January 2017. Add an at timestamp, keep your API key.

Live and historical share one analytics engine. Automated parity tests compare every Greek between the two paths so they cannot drift. A feature built against the live response works unchanged against the archive. Moving a backtest to production is a base URL swap, not a rewrite.

Replay runs today's engine over inputs as they were known at the requested minute. An engine improvement on live is the same improvement in your next backtest. Every response carries data_as_of, archive_as_of and endpoint_version, so a study can state exactly which inputs and engine produced it.

GEXBot Quant's documented history is a rolling 90-day download for eligible REST tickers. Its feed guide states the additional Quant tickers and explicit-expiry streams are not in REST history at all.

From notebook to production

SDKs: Python, JS, C#, Go, Java (github.com/FlashAlpha-lab)
Hosted Claude MCP connector (OAuth)
Commercial infrastructure:

Offering	From	What it buys
Professional	$2,500/mo	Dedicated node, reserved throughput
Streaming	$4,500/mo	Dedicated node, streaming compute, scoped data licence, 500 concurrent subscriptions
Enterprise	Custom	Reserved capacity, multi-region, custom metrics

These are scoped separately from Alpha, for internal research and trading only. No redistribution or embedding rights. Streaming is in commercial early access. FlashAlpha publishes methodology and security documentation; it does not claim SOC 2 or ISO 27001.

Which tier

Tier	Quota	Start here if	Move up when
Free, $0	5/day	Prototyping a single-expiry equity GEX call	You need ETFs/indexes or more exposure metrics
Basic, $79	250/day	Periodic index/ETF exposure, DEX/VEX/CHEX, max pain, position analysis	You need full-chain GEX, 0DTE, futures
Growth, $299	2,500/day	Live apps combining full-chain exposure, CME futures, flow, vol, screening	You need historical replay, SVI/VRP, full screener
Alpha, $1,499	No daily cap	Historical research plus advanced live analytics	You need dedicated capacity or streaming

Capacity maths: three requests every five minutes over a 390-minute session is 234 calls, inside Basic. One call every 15 seconds is 1,560; two is 3,120 and exceeds Growth. Aggregate endpoints reduce call counts. Alpha removes the daily cap, not concurrency limits.

Where GEXBot remains a good choice

Classic ($50) for supported GEX feeds, State ($150) for classified profiles, Orderflow ($250) for flow views, Quant ($350) for WebSockets plus recent history. Research at $100 standalone or $50 add-on gives broad on-demand analytics including vol and higher-order Greeks.

Classic's aggregation runs up to 90 days out; FlashAlpha Basic's GEX is single-expiry.

Other checks:

Coverage. Public GEXBot discovery on 9 September returned 60 regular plus 51 Quant identifiers, some WebSocket-only. FlashAlpha publishes 6,000+ equity/ETF coverage, not independently counted here.
Futures. GEXBot converts index/ETF levels to futures. FlashAlpha Growth calculates from native options-on-futures. Different underlying markets.
Streaming. GEXBot publishes 09:30 to 16:00 ET with a default 150 hub/group limit. Two metrics on separate hubs with spot can cost four memberships per ticker.
Methodology. GEXBot's classified models and FlashAlpha's structural/flow calculations are not interchangeable. Check expiry scope, signs, units and timestamps before reading a difference as a data-quality issue.

Recommendation

Choose FlashAlpha when you need to build and operate an options research system across multiple analytics families. Growth for the live application, Alpha for the historical and advanced layer, commercial plans for dedicated infrastructure.

Start with the endpoints your hypothesis needs, check their output, history and access gates, then pick the tier. For a specific GEXBot profile or an economical standalone GEX stream, GEXBot's packages remain worth considering.

API docs: https://flashalpha.com/docs/api
Pricing: https://flashalpha.com/pricing
Historical API: https://flashalpha.com/docs/historical-api
Institutional: https://flashalpha.com/institutional

FlashAlpha vs LSEG Workspace (Refinitiv Eikon) 2026 - Options Data

tomasz dobrowolski — Thu, 20 Aug 2026 10:32:35 +0000

Originally published at flashalpha.com.

Refinitiv Eikon was retired on 30 June 2025 and replaced by LSEG Workspace. Forced migrations are the moment desks audit what they are paying for, which is usually why this comparison comes up: someone is re-papering a Workspace contract and asking whether the options research it is meant to support is actually being supported.

The honest answer is that Workspace and FlashAlpha barely overlap. One is a multi-asset workstation, the other is a single computed analytics layer. What follows is where the seam actually falls.

Full disclosure: I built FlashAlpha. LSEG is a vastly broader business than mine and I will be direct about where Workspace is the correct purchase.

The TL;DR

	LSEG Workspace	FlashAlpha
Product shape	Multi-asset terminal plus data feeds and an Excel add-in	Options analytics API, no terminal
Coverage	Global equities, FX, fixed income, commodities, macro, Reuters news	US equity / ETF / index options and CME futures options
Options data	Prices, chains, per-contract greeks and implied vols	Aggregated dealer positioning: GEX, DEX, VEX, CHEX, gamma flip, walls, max pain, regime
Volatility surfaces	Available within the platform's analytics	SVI-calibrated with raw parameters and arbitrage flags
Programmatic access	Data Library / Workspace APIs, entitlement-gated per subscription	REST, commercial WebSocket streaming, MCP server, five SDKs
Point-in-time analytics replay	Price history yes; derived positioning analytics, no	51 analytics routes, any minute in the symbol's window, back to 2017-01-03 on the longest-covered names, via `?at=`
Pricing model	Quote-based per seat, data entitlements charged separately	Published self-serve tiers plus quoted commercial tiers
Permanent self-serve free tier	No. LSEG offers sales-led trials, but no open free tier	Yes. 5 requests / day, no card, no expiry

The entitlement model is the thing to understand

Workspace pricing is not one number, and this trips up budgeting more than anything else. There is a base platform licence per user, and then data entitlements are charged separately by asset class and geography. Two colleagues on nominally the same Workspace can have materially different data access depending on what their firm entitled them to.

For options research specifically, that has a practical consequence: whether you can pull the US options chain you need, at the depth you need, is a contract question rather than a product question. Teams routinely discover mid-project that the entitlement they have covers the underlying but not the derivatives at the granularity the study assumed, and the fix is a procurement cycle rather than a code change.

FlashAlpha's equivalent constraint is simpler and visible up front: tiers gate which endpoints you can call, the limits are published, and the response headers tell you where you stand. Narrower product, but you can see the whole shape of it before you buy.

What each one actually computes

LSEG Workspace

Workspace gives you options prices, chains, per-contract greeks and implied volatilities, alongside the rest of the multi-asset universe. The analytics are solid and the Excel integration is genuinely good, which matters more than quants like to admit because a great deal of real institutional analysis still happens in a spreadsheet.

What it does not give you is the aggregation layer. There is no call that returns net gamma exposure by strike under a dealer-sign convention, no gamma flip level, no call or put wall, no charm or vanna exposure aggregate, and no regime classification. Those are a build on top of the chain data, and the build is the seven components covered in build vs buy.

FlashAlpha

FlashAlpha starts where Workspace's options data stops. It publishes the aggregate: per-strike GEX, DEX, VEX and CHEX with a documented dealer-sign convention, gamma flip, call and put walls, max pain, SVI surfaces with raw parameters and arbitrage flags, VRP with z-scores and regime conditioning, and 0DTE analytics. One call returns the computed view rather than the chain you would reduce yourself.

And it has none of the rest. No FX, no fixed income, no macro, no news, no equities fundamentals, no non-US options. If Workspace is a hundred markets one layer deep, FlashAlpha is one market a hundred layers deep.

Where the Reuters newsroom and macro history matter

Two Workspace strengths deserve calling out because they have no FlashAlpha equivalent at all.

Reuters news is a primary newsroom, not an aggregator, and it is tightly integrated into the platform's instrument context. For anything event-driven, that integration is worth real money.

Macro and cross-asset history, including the Datastream lineage, goes back decades across markets FlashAlpha does not touch. If your options signal needs to be conditioned on rates, FX or a macro series, Workspace has that history and FlashAlpha does not.

A vol desk that wants dealer positioning conditioned on the rates path needs both, and there is no version of this comparison where one replaces the other.

History and reproducibility

Workspace has far deeper and far broader price history than FlashAlpha, across far more markets. That is not close.

The difference is again what is archived. Workspace stores prices. FlashAlpha stores computed analytics at minute resolution, replayable at any minute inside each symbol's coverage window (75 symbols; 14 back to 2017-01-03, most from 2018, SPX from 2022; check /v1/tickers), through the same endpoints that serve live data, with a base-URL swap and an ?at= parameter, across 51 mirrored analytics routes. The parity is close rather than total: earnings, screener and structures are live-only, and three historical response schemas differ in shape from their live counterparts. For backtesting a positioning signal that distinction is the whole game: you need the gamma flip level as it stood at 14:12 that day, not a value you recompute afterwards with today's code and today's conventions.

Reconstructing that from Workspace chain history is possible. It is also the multi-quarter build, and the archive is the component that cannot be accelerated by hiring.

Where LSEG Workspace wins

Multi-asset breadth. FX, fixed income, commodities, macro and global equities in one place.
Reuters news, integrated with instrument context.
FX and fixed income depth, where LSEG is genuinely a category leader rather than a follower.
Excel integration that real analysts use daily.
Decades of cross-asset history, including the Datastream macro lineage.
Cheaper than Bloomberg at comparable breadth, which is much of its commercial case.
Global options coverage, where FlashAlpha is US-only.

Where FlashAlpha wins

The aggregation layer is pre-computed, not left to you.
Point-in-time replay of derived analytics at minute resolution, back to 2017-01-03 on the longest-covered symbols.
Transparent limits and entitlements, published rather than negotiated per contract.
Same contract live and historical, so backtest code ships to production unchanged.
Evaluate without procurement. Free tier, no card, no sales cycle.
Depth in US options specifically, including 0DTE, SVI parameters and VRP conditioning that a generalist platform does not carry.

Pricing, with sources

LSEG does not publish Workspace pricing; it is quote-based and varies with entitlements, region and negotiated terms. The figures below are widely reported reference ranges as of August 2026, not vendor statements.

	LSEG Workspace	FlashAlpha
Entry	Reduced-functionality tiers reported from around $4,000 / year	Free: 5 requests / day, no card, no expiry
Typical full seat	Reported in the $10,000 to $22,000+ / seat / year range depending on package	Alpha at $1,499 / mo, or $1,199 / mo billed annually
Data entitlements	Charged separately by asset class and geography	Included in tier; no separate data fees
Dedicated infrastructure	Enterprise feeds quoted separately	Professional from $2,500 / mo, dedicated node
Streaming	Real-time feeds, quoted	From $4,500 / mo, commercial WebSocket
Transparency	Quote-based throughout	Self-serve tiers published; commercial tiers quoted

The reported ranges are wide precisely because the entitlement stack dominates the base licence. Treat any single figure sceptically, including these, and price your own quote against what you are actually entitled to pull.

Who should not use each

Do not buy FlashAlpha if you need multi-asset coverage, news, macro history, non-US options, or a terminal interface for discretionary users. Workspace or a peer is the right purchase.

Do not expect Workspace to deliver aggregated dealer positioning, point-in-time replay of derived options analytics, SVI parameters with arbitrage flags, or an options research feed whose limits you can see without reading a contract. Those are not what it is for.

The realistic answer: both, split by job

LSEG Workspace for cross-asset context, macro conditioning, news, FX and rates, and the discretionary desk's screen.
FlashAlpha for the US options positioning layer feeding models, backtests, screens and alerts.

If you are mid-migration from Eikon, that is also the cheapest moment to scope this properly: you are already auditing entitlements, so it is a good time to check whether the options depth you assumed you had is on the contract, and to price the derived layer separately rather than assuming the terminal covers it.

Try it alongside your Workspace entitlement

Single-expiry GEX on a single-name equity is a Free-tier request:

curl "https://lab.flashalpha.com/v1/exposure/gex/AAPL?expiration=2026-09-18" \
  -H "X-Api-Key: YOUR_KEY"

The full exposure summary is the call worth comparing against a Workspace chain, because it returns the aggregation Workspace does not compute. It is a Growth-tier endpoint, and index symbols such as SPX need Basic or above:

curl "https://lab.flashalpha.com/v1/exposure/summary/SPX" \
  -H "X-Api-Key: YOUR_KEY"   # Growth tier

Then replay it at a minute inside an event you remember, and check the level was actually there at the time:

curl "https://historical.flashalpha.com/v1/exposure/summary/SPX?at=2026-04-07T14:30:00" \
  -H "X-Api-Key: YOUR_KEY"   # Alpha tier

Only the first call is free; the summary needs Growth and the replay needs Alpha. Methodology and stated limitations are in the whitepaper; the institutional datasheet is at /institutional.

Sources

All figures are as of August 2026. Where a vendor does not publish pricing, the figure is marked as reported rather than stated.

Workspace and FlashAlpha are not competitors in any meaningful sense; they sell different things to the same desk. Workspace wins on breadth, news, FX and rates depth, macro history and global coverage, and its commercial case against Bloomberg is real. It does not compute aggregated dealer positioning, and it cannot replay derived options analytics point-in-time. If your options research needs that layer, the choice is not Workspace or FlashAlpha, it is whether you buy the layer or spend several quarters building it on top of chain data you already pay for.

FlashAlpha vs OptionMetrics IvyDB 2026 - Historical Options Data

tomasz dobrowolski — Thu, 20 Aug 2026 10:31:45 +0000

Originally published at flashalpha.com.

This is the comparison I get asked about most by people who actually do research, and it is the one most often described badly. IvyDB is routinely dismissed as "end-of-day only", which is wrong: OptionMetrics has shipped intraday products for years. The real distinction is subtler and more useful, and it comes down to what is stored and how it is delivered.

Full disclosure: I built FlashAlpha. OptionMetrics has been the standard in this field since 1999 and my data does not go back nearly as far. I will be precise about that.

The TL;DR

	OptionMetrics IvyDB	FlashAlpha
Product shape	Historical research dataset, delivered in bulk	Live API; history via the same endpoints across 51 mirrored routes
History depth	EOD from January 1996, about 30 years	Minute resolution, per-symbol windows; longest from 2017-01-03, about 9 years
Intraday	Yes: fixed snapshots at 10:00, 14:00 and 15:45 ET, from January 2018	Continuous minute resolution, any minute of the session
What is stored	Prices, standardised implied vols, per-contract greeks, signed volume	Computed aggregates: GEX, DEX, VEX, CHEX, gamma flip, walls, max pain, regime, SVI, VRP
Real-time	No. It is a research archive	Yes. Near-real-time snapshots, plus commercial streaming
Delivery	Bulk files, WRDS, Snowflake	REST, WebSocket, MCP, five SDKs
Geography	US plus Canada, Europe, Asia-Pacific and global indices	US equities / ETFs / indices and CME futures options
Pricing	Quote only; discounted academic licence	Free tier, self-serve tiers, quoted commercial tiers

What IvyDB actually contains, accurately

Correcting the common mischaracterisation, the IvyDB family is broader than one dataset:

IvyDB US: a complete end-of-day record of every US exchange-traded equity and index option, including options on ETFs and ADRs, from January 1996. Prices, standardised implied volatilities and option sensitivities, computed consistently across the whole history.
IvyDB US Intraday: snapshots of option prices and their corresponding volatility calculations at 10:00, 14:00 and 15:45 ET, from January 2018.
IvyDB Signed Volume: intraday buy / sell pressure in five- and thirty-minute snapshots plus end-of-day, from January 2016.
IvyDB ETF: separately marketed coverage of options on US-listed ETFs.
IvyDB Futures: historical futures option prices for US and EU futures markets.
IvyDB Canada, Europe, Asia-Pacific and Global Indices: international coverage FlashAlpha does not have at all. OptionMetrics also ships IvyDB Beta and IvyDB Implied Dividend.

Signed Volume deserves particular note, because it is the IvyDB product closest to what FlashAlpha does. It classifies trading into buy and sell pressure, which is genuinely adjacent to flow analytics, and it goes back to 2016. If your question is "was volume in this name buyer or seller initiated in 2017", IvyDB answers it and FlashAlpha's flow history does not reach that far.

The real difference: stored values versus stored inputs

Here is the distinction that actually matters, and it is not depth or resolution.

IvyDB stores inputs: prices, implied vols, per-contract greeks, signed volume. Excellent inputs, computed with a consistent and well-documented methodology, which is precisely why it is the peer-review standard. But if you want net gamma exposure by strike, a gamma flip level, a call wall, a regime classification, or a charm and vanna exposure profile, you compute those yourself from IvyDB. The dataset does not carry them.

FlashAlpha stores outputs: the aggregates themselves, already reduced under an explicit and documented dealer-sign convention, at every minute. That is the entire product.

Both positions are defensible and the trade-off is real:

Storing inputs preserves your methodological freedom. If your dealer-positioning assumptions are your edge, IvyDB lets you express them and FlashAlpha makes you adopt mine. For a fund whose alpha is the positioning model, that is decisive, and it is the honest reason to choose IvyDB.
Storing outputs removes a build and a class of look-ahead bugs. Recomputing 2019 analytics from 2019 inputs using 2026 code is where point-in-time integrity quietly dies. The value you backtest should be the value that existed.

Three snapshots a day versus every minute

IvyDB US Intraday is real, but it is three fixed snapshots: 10:00, 14:00 and 15:45 ET. For a great many research questions that is entirely sufficient, and for term-structure or surface work it is often all you need.

It is not sufficient for anything whose thesis is about intraday path. A 0DTE gamma study, a question about how positioning shifted through a Fed statement at 14:00, or a signal that fires on a gamma flip crossing during the session, all need the minutes between the snapshots. 15:45 is also a slightly awkward stopping point for anything concerned with the closing auction and end-of-day hedging.

The framing I would use: IvyDB samples the day, FlashAlpha traces it. Which you need is a property of your research question, not a quality ranking.

Research archive versus production feed

This is the difference people notice last and feel most.

IvyDB is delivered as bulk data: files, WRDS, or Snowflake. That is a good fit for research. You load it, you query it, you write the paper or the backtest. It is not a production feed, and it is not meant to be. There is no real-time IvyDB endpoint you point a live strategy at.

FlashAlpha is a live API where history is the same API. The endpoints that serve the current gamma flip level serve the one from 2019-08-14T14:22 with an ?at= parameter and a base-URL swap. The practical consequence is that the code you backtested is the code that trades, with no reimplementation step between research and production, and no chance of the two drifting apart.

If you research on IvyDB and trade on something else, that reimplementation gap is real work and a real source of bugs. That is not a criticism of IvyDB, it is a consequence of it being a research archive, which is what it is for.

The academic licence detail worth knowing

OptionMetrics offers academic institutions a substantially discounted IvyDB licence. Academic distributions have historically refreshed on a slower cadence than the nightly corporate feed. OptionMetrics described an annual academic refresh when it extended IvyDB Europe licensing to universities, but treat the exact cadence as something to confirm with your librarian or with OptionMetrics rather than as a current universal rule, because it varies by product and by distribution channel.

For historical research the lag is irrelevant, which is why it suits universities so well. For anything current it matters: a dataset refreshed on an annual cycle cannot support a study window that includes recent months, and cannot support anything operational. If you are at an institution with IvyDB access and wondering why your data stops well short of today, the refresh cadence is the usual explanation. It is a licence tier, not a fault.

Where OptionMetrics wins

Thirty years of history. January 1996, every name. FlashAlpha's archive is 75 symbols, the longest-covered 14 starting 2017-01-03 and most of the rest in 2018. For anything touching the dot-com unwind, 2008, or the 2010 flash crash, IvyDB is the only one of the two that can answer.
It is the peer-review standard. If your work will be published or shown to allocators, "we used IvyDB" is understood and accepted without further argument.
Methodological freedom. Raw inputs mean your conventions, your filtering, your dealer assumptions.
Global coverage. Canada, Europe, Asia-Pacific and global indices, plus EU futures options. FlashAlpha is US-only.
Signed volume back to 2016, predating FlashAlpha's flow history.
Reference-quality standardised surfaces, consistent across three decades, which is genuinely hard to do.
Snowflake delivery, which suits firms whose research stack already lives there.

Where FlashAlpha wins

Continuous minute resolution rather than three fixed daily snapshots.
The aggregation is already done, with a published convention and stated limitations.
It is a live feed. Research and production share one API and one contract.
Point-in-time by construction, because the analytic was computed and stored at the time, not recomputed later.
Regime, walls, flip levels, VRP z-scores and SVI parameters exist as first-class fields rather than as a project.
You can evaluate it in five minutes on a free tier with no card and no procurement.

Pricing

OptionMetrics does not publish pricing; IvyDB is quoted per institution and varies with products, history depth and delivery method. Anyone quoting you a specific public IvyDB number is guessing, so this page will not. What is publicly documented is the structure:

	OptionMetrics IvyDB	FlashAlpha
Model	Quote only, per institution	Published self-serve tiers, quoted commercial tiers
Permanent self-serve free tier	No	Yes: 5 requests / day, no card, no expiry
Academic	Substantially discounted; refreshed yearly, not nightly	No separate academic tier; free tier is open to anyone
Self-serve	No	Yes, to Alpha at $1,499 / mo (or $1,199 / mo billed annually)
Dedicated node	Not applicable, bulk delivery	Professional from $2,500 / mo
Streaming	Not offered, research archive	From $4,500 / mo, commercial WebSocket

Who should not use each

Do not buy FlashAlpha if your research needs pre-2017 history, non-US markets, per-contract granularity with your own conventions, or publication-standard provenance. Buy IvyDB. If your positioning methodology is itself your edge, buy IvyDB and build on it.

Do not buy IvyDB if you need a real-time feed, continuous intraday resolution, or you want the aggregates without a build. It is an outstanding research archive and a poor production dependency, because it was never meant to be one.

The combination that actually makes sense

These two compose unusually well:

IvyDB for the long sample. Establish that an effect exists across three decades and several regimes, with methodology you control and provenance you can defend.
FlashAlpha for the live implementation. Once the effect is established, trade it against a feed that computes the same aggregates every minute and replays them identically.

The reconciliation between them is worth doing on its own merits. Compute your GEX from IvyDB for an overlapping date and compare it to FlashAlpha's. Where they disagree you learn something real, either about my conventions or about yours, and two independent computations that agree is a much stronger position than one you cannot check.

Try the overlap

Pick a date you already have in IvyDB and pull the same moment from FlashAlpha:

curl "https://historical.flashalpha.com/v1/exposure/gex/SPY?at=2019-08-14T14:00:00" \
  -H "X-Api-Key: YOUR_KEY"

The at parameter is ET, so 14:00:00 lands exactly on one of IvyDB's three intraday snapshots, which makes it a clean reconciliation point. Replay is Alpha tier and served from historical.flashalpha.com. The methodology whitepaper documents the dealer-sign convention and its stated limitations, so you can see exactly which assumptions you would be adopting before you adopt any of them.

Sources

All figures are as of August 2026.

IvyDB and FlashAlpha are not really competitors, they are different halves of a research programme. IvyDB gives you thirty years, global coverage, methodological freedom and provenance that survives peer review; it does not give you a live feed, continuous intraday resolution, or the aggregates without a build. FlashAlpha gives you the computed layer every minute since 2017, live and historical through one API; it does not give you 1996, non-US markets, or the freedom to substitute your own conventions. If you are choosing on depth alone you will pick IvyDB, and you may well be right. If you are choosing on whether research and production can share one code path, that is the case for the other side.

FlashAlpha vs Bloomberg Terminal 2026 - Options Analytics for Quants

tomasz dobrowolski — Thu, 20 Aug 2026 10:28:24 +0000

Originally published at flashalpha.com.

If you are comparing these two, you are probably not choosing between them. Most desks that run FlashAlpha also have Bloomberg in the building. The useful question is narrower: can the terminal you already pay for feed your systematic options research? Usually it cannot, and the reason is quotas rather than quality.

Full disclosure: I built FlashAlpha. Bloomberg is a far larger and broader product than mine, and I will be specific about where it wins, because pretending otherwise would waste your time.

The TL;DR

	Bloomberg Terminal	FlashAlpha
Primary consumer	A person reading a screen	A model reading an API
Asset class breadth	Everything: equities, rates, FX, credit, commodities, news, chat, execution	US equity / ETF / index options and CME futures options only
Options analytics	Per-contract greeks, vol surfaces, pricers (OMON, OVDV, OVME)	Aggregated dealer positioning: GEX, DEX, VEX, CHEX, gamma flip, call / put wall, max pain, regime
Programmatic access	BLPAPI bundled with the seat, quota-metered; firm-scale access is a separate product (B-PIPE, Data License)	REST, commercial WebSocket streaming, MCP server; SDKs for Python, JS, C#, Go, Java
Published usage limits	Not disclosed by Bloomberg; no programmatic way to check remaining quota	Published per-tier request limits, returned in response headers
Point-in-time replay	Historical prices yes; the derived analytics layer, no	51 analytics routes replayable at any minute in the symbol's window; longest run back to 2017-01-03 via `?at=`
List price	$31,980 / year per seat (single), $28,320 / seat / year multi-seat, 2-year minimum	Free tier, self-serve to $1,499 / mo, Professional from $2,500 / mo, Enterprise custom
Permanent self-serve free tier	No. Trials and demos are sales-led	Yes. 5 requests / day, no card, no expiry

The quota problem, which is the whole argument

This is the part that decides it, so it goes first rather than last.

A Bloomberg seat bundles BLPAPI, the programmatic interface you can drive from Excel or Python. That sounds like it solves systematic access, and for modest jobs it does. But the seat is metered, and the meter is built for a human's incidental data pulls rather than for a research pipeline. The limits consistently documented by university library guides, which are the most reliable public source because Bloomberg itself does not publish them, are:

Roughly 500,000 data points per day, where one "hit" is a single security / field pair.
No more than 3,500 real-time fields open concurrently.
A monthly limit on unique securities derived from a proprietary model. Published university guidance disagrees on the number, ranging from roughly 2,500 to 7,000 unique identifiers per month depending on which institution's guide you read, which is itself the clearest evidence that Bloomberg does not publish it. Intraday data is weighted more heavily than end-of-day.

Now put a real research job against that. A single day of per-strike analytics on the US options market touches far more than 5,000 unique contracts, because each strike and expiry is its own identifier. One liquid underlying alone can carry several thousand live contracts across the chain. A cross-sectional study over a few hundred names does not brush the monthly limit, it exhausts it in an afternoon.

The second problem is worse, and it is the one quants underrate:

Bloomberg does not state the explicit limits, and there is no programmatic way to discover what your limits are or how much of them you have consumed.

To be fair to Bloomberg, the failure is not silent: Excel and the API return explicit codes, #N/A Limit for the concurrent-subscription ceiling, #N/A Daily Capacity for the daily cap, #N/A Mth Lmt for the monthly one. You will know when you hit it.

The problem is that you can only find the ceiling by hitting it. There is no counter to read before you start, so a large backfill cannot be planned against its own budget: it runs until it stops, and the stop lands mid-job. A study that ran in March can fail in April because a colleague on the same licence spent the shared allowance first. That is not a data quality problem, it is an operational one, and no amount of budget fixes it while the access model stays per-seat.

Scoped precisely: market-wide, high-volume options-chain backfills are operationally unreliable on the Desktop API. Smaller and more predictable jobs are fine, and plenty of desks run them happily.

This is not a criticism of Bloomberg's design. The terminal is licensed to a person, and the quota exists precisely to stop a seat becoming a firm-wide data feed. Bloomberg sells that separately, and openly, which is the next section.

What Bloomberg does offer for firm-scale access

It would be wrong to say Bloomberg has no programmatic path. It has two, and they are real products:

B-PIPE: the consolidated, normalised real-time market data feed, licensed for internal applications including non-display and black-box use. This is the correct product if you need Bloomberg's real-time prices inside your own systems.
Data License: bulk and REST enterprise delivery for trading, risk, compliance and operations workflows.

Both are negotiated separately from the terminal seat, priced on data fields, exchanges, redistribution rights and consuming applications, and both require a signed licensing agreement. Neither is included in the $31,980 seat.

Two things follow. First, if you were hoping the seat you already pay for covers systematic access, it does not, and the enterprise products are a separate budget conversation. Second, and more to the point: even at full enterprise scale, Bloomberg ships prices, greeks and surfaces, not aggregated dealer positioning. B-PIPE gives you the inputs. Whether GEX, gamma flip, or a charm-and-vanna exposure profile exists at the end of the pipeline is still a build you own.

What each one actually computes

Bloomberg

Bloomberg's options stack is genuinely strong and aimed at a trader with a screen. OMON gives the option monitor across the chain. OVDV gives the volatility surface. OVME prices and values multi-leg structures. The greeks and implied vols behind them are well-constructed and widely trusted as a reference.

What it does not do is aggregate the market into a positioning view. There is no single call that returns net gamma exposure by strike under a dealer-sign convention, no gamma flip level, no call wall or put wall, no regime classification, and no charm or vanna exposure aggregate. If you want those from Bloomberg, you pull the chain and build them, which lands you back on the quota.

FlashAlpha

FlashAlpha computes exactly that derived layer and nothing else. Per-strike GEX, DEX, VEX and CHEX with an explicit, documented dealer-sign convention; gamma flip; call and put walls; max pain; SVI-calibrated surfaces with raw parameters and arbitrage flags; VRP with z-scores and regime conditioning; and 0DTE analytics. One call returns the aggregate rather than the several thousand contracts you would otherwise reduce yourself.

The narrowness is the point and also the limitation. FlashAlpha has no fundamentals, no news, no chat, no execution, no FX or credit, and no non-US options. It is one layer, deep.

History and reproducibility

Bloomberg has decades of price history and it goes far deeper than FlashAlpha's 2017 start. For pre-2017 work, or for anything outside US options, Bloomberg wins outright and it is not close.

The distinction is what is stored. Bloomberg archives prices. FlashAlpha archives computed analytics, at minute resolution, replayable at any minute inside each symbol's coverage window. Coverage is per symbol: the archive holds 75 symbols, 14 of them back to 2017-01-03 (SPY, QQQ, IWM, TSLA, NVDA, MSFT, NFLX, AMZN, GOOG, AMD, INTC, MSTR, T and TLT), most of the rest from 2018, and SPX from 2022. Check /v1/tickers for the exact window before assuming a date is queryable. That matters for one specific reason: a backtest of a positioning signal needs the positioning value as it stood at 10:47 on a given day, not a reconstruction you assemble later from prices using today's code and today's assumptions. On FlashAlpha the same endpoints serve live and historical through a base-URL swap and an ?at= parameter, so the code you backtested is the code that runs in production.

You could rebuild that from Bloomberg price history. It is the seven-component build covered in build vs buy, and the archive is the part that cannot be compressed by hiring.

Where Bloomberg wins, plainly

These are not concessions, they are the reasons Bloomberg is on nearly every institutional desk:

Breadth. Every asset class, globally, in one place. FlashAlpha covers one slice of one market.
News and research. Bloomberg's newsroom is a genuine product, not a feed reseller. There is no equivalent at any price.
The network. Bloomberg chat is where counterparties actually are. That is a moat no data vendor can attack.
Execution and workflow. Order management, portfolio analytics, compliance. FlashAlpha is a read-only analytics API.
Depth of history and global coverage. Decades, everywhere. FlashAlpha is US options since 2017.
It is the lingua franca. When your risk report disagrees with a counterparty, quoting a Bloomberg screen ends the argument.
Bundled and predictable. Hardware, software, data, news and support in one number, with no add-on data fees on the seat.

Where FlashAlpha wins

The analytics layer exists. Aggregated dealer positioning is pre-computed rather than left as an exercise.
Access is designed for machines. Published limits, returned in headers, with no undisclosed monthly model to plan around.
Point-in-time replay of the analytics themselves, at minute resolution, back to 2017-01-03 on the longest-covered symbols.
Cost per model, not per human. A dedicated node serves your whole research team rather than metering one person's screen.
You can evaluate it today without a salesperson, a two-year commitment, or a card.

Pricing, with sources

Bloomberg does not publish terminal pricing. The figures below are as reported by NeuGroup for 2026 and should be treated as reference points rather than vendor statements. Your negotiated number will differ.

	Bloomberg Terminal	FlashAlpha
Entry	No free or trial tier	Free: 5 requests / day, no card, no expiry
Self-serve	Not available	Basic and Growth tiers, up to Alpha at $1,499 / mo (or $1,199 / mo billed annually)
Single seat / node	$31,980 / year (about $2,665 / mo)	Professional from $2,500 / mo, dedicated node
Multi-seat	$28,320 / seat / year	Node serves the team; no per-user metering
Streaming	B-PIPE, negotiated separately	From $4,500 / mo, commercial WebSocket
Commitment	Two-year minimum, billed quarterly in advance	Monthly or annual

The comparison people reach for is "$2,665 a month against $2,500 a month, roughly the same". That framing is wrong in both directions. A Bloomberg seat buys a person every asset class on earth plus news, chat and execution. A FlashAlpha node buys your models one analytics layer with no per-user meter. They are not substitutes, and the per-month similarity is a coincidence.

Who should not use each

Do not buy FlashAlpha if you need multi-asset coverage, news, execution, pre-2017 history, non-US options, or your consumer is a discretionary trader who wants a screen. Buy or keep Bloomberg.

Do not rely on a Bloomberg seat if your consumer is a model, you need aggregated dealer positioning, you need to replay derived analytics point-in-time, or you need a data access path whose limits you can actually see. The seat will not do it, and the enterprise products solve the access problem without solving the analytics one.

The realistic answer: both

Nearly every desk running FlashAlpha keeps Bloomberg. The split that works in practice:

Bloomberg for discretionary work, cross-asset context, news, counterparty comms, execution, and as the reference number when someone disputes a mark.
FlashAlpha as the machine-readable positioning layer feeding models, backtests, screens and alerts, where the quota is published and the history replays.

There is a second, underrated benefit: two independent computations that agree is a much stronger position than one you cannot verify. Reconciling a FlashAlpha surface against OVDV surfaces real problems in both.

Try it against your Bloomberg screen

Single-expiry GEX on a single-name equity is a Free-tier request, so this runs on a new key with no card:

curl "https://lab.flashalpha.com/v1/exposure/gex/AAPL?expiration=2026-09-18" \
  -H "X-Api-Key: YOUR_KEY"

Compare that to the same expiry on OMON and check the per-strike gamma agrees. To pull the whole chain in one call, drop the ?expiration= filter. That is full-chain GEX and needs Growth. ETFs and index symbols such as SPY, QQQ and SPX need Basic or above:

curl "https://lab.flashalpha.com/v1/exposure/gex/SPY" \
  -H "X-Api-Key: YOUR_KEY"   # full chain + ETF: Growth tier

Point-in-time replay is Alpha tier and lives on a separate host. This is the call that has no Bloomberg equivalent:

curl "https://historical.flashalpha.com/v1/exposure/gex/SPY?at=2026-04-07T14:30:00" \
  -H "X-Api-Key: YOUR_KEY"   # Alpha tier

Methodology and its stated limitations are in the whitepaper, and the institutional datasheet is at /institutional.

Sources

All figures are as of August 2026. Where a vendor does not publish pricing, the figure is marked as reported rather than stated.

Bloomberg is not the competitor a computed-analytics API displaces, and any page claiming otherwise is selling you something. The terminal wins on breadth, news, the network and institutional standing, and it is the right tool when a human is the consumer. It loses when the consumer is a model, for one structural reason: a per-seat licence with an undisclosed, unqueryable quota cannot underwrite a research pipeline. That is a licensing shape, not a quality gap, and it is why the two sit next to each other on most desks rather than replacing one another.

Bitcoin ETF vs CME vs Offshore Options: Which Book Should You Read?

tomasz dobrowolski — Mon, 17 Aug 2026 09:40:32 +0000

The most common mistake in crypto positioning analysis is aggregation. People add CME gamma to ETF gamma to offshore gamma and quote a single "bitcoin GEX" figure. That number is not wrong so much as meaningless, because the hedging flows behind its components are executed in different instruments, by different firms, and never meet.

The fix is to stop aggregating and start selecting. Here is how.

The Four Books

	Spot ETF options	CME options on futures	Equity proxies	Offshore
Examples	IBIT, ETHA, FBTC	BTC=F, ETH=F	MSTR, COIN, MARA	Offshore venues
Hedged by trading	ETF shares	CME futures	The equity	Coin or perp
Pricing	Black-Scholes, spot	Black-76, forward	Black-Scholes, spot	Varies
Settlement	Physical, shares	Cash	Physical, shares	Coin or perp
Structural tilt	Overwriting, dealers long gamma	Basis and macro hedging	Convexity and convert arb	Speculation, short-dated
Expiry ladder	Weekly, monthly, LEAPS	Monthly, quarterly	Weekly, monthly, LEAPS	Near-continuous
Hours	US equity hours	Nearly 24h	US equity hours	24/7

They Disagree, Measurably

Read at one instant before the US open on 17 August 2026:

Book	Net GEX	Regime	Spot vs flip
IBIT (spot ETF)	+$3.98M	Positive	+0.06%
BTC=F (CME)	−$0.85M	Negative	−0.10%
MSTR (proxy)	+$26.86M	Positive	+0.69%
ETHA (spot ETF, ether)	−$2.00M	Negative	−6.71%

Bitcoin dealer gamma was simultaneously positive in the ETF and negative on CME. Both books sat within a tenth of a percent of their own flip, on opposite sides. Any aggregate figure would have averaged these into a number describing neither.

Divergence between books is normal and informative. It is not a signal that one feed is broken, and it is not an arbitrage. It tells you the two participant populations are positioned differently, which is usually the most interesting thing you can learn about a market.

The Decision Rule

Pick the book that governs the hedging flow into your instrument.

If you hold or trade	Read	Because
IBIT, FBTC or another spot BTC ETF	IBIT gamma	Dealer hedging lands in ETF shares, which is your tape
ETHA or ether ETF exposure	ETHA exposure	Ether has its own regime and it is often not bitcoin's
MSTR, COIN or a miner	MSTR positioning	Equity hedging plus convert arb, distinct from crypto flow
CME futures or options	BTC=F gamma	Hedging lands in the futures curve you trade
Spot coin, long horizon	CME plus offshore	Closest to the actual coin-hedging channel
Spot coin, intraday	Offshore, with CME as context	Offshore carries the short-dated flow that moves coin intraday

When To Read A Second Book

Selecting one primary book does not mean ignoring the others. Three cases justify a second look:

Regime disagreement between ETF and CME. When the two flip to opposite signs, the asset is being pulled by two hedging populations at once and realised volatility tends to be higher than either book alone implies.
Ether diverging from bitcoin. On 17 August ETHA sat 6.7% below its flip in clear negative gamma while IBIT sat on its flip in positive gamma. That is a genuine statement about relative fragility, not a wrapper artefact.
MSTR as a stress gauge. Because it is the largest and most levered book, MSTR often shows exposure build-up before the ETFs do.

Three Pitfalls

Comparing contracts instead of dollars. One CME bitcoin contract is 5 BTC, roughly $317,000 of notional at 63,470. One IBIT contract is 100 shares, roughly $3,600. Contract counts across these venues are not comparable by three orders of magnitude. Always convert to dollars.

Pricing CME greeks off spot. CME options are on the future, so they price with Black-76 on the forward. Using a spot index introduces an error that grows with tenor.

Reading ETF put walls as support. When put open interest at a strike dwarfs call open interest by an order of magnitude, that is outright protection buying rather than two-way dealer positioning, and it does not generate the same hedging bid.

Pulling All Four

GET /v1/exposure/summary/IBIT          # spot BTC ETF
GET /v1/exposure/summary/ETHA          # spot ETH ETF
GET /v1/exposure/summary/MSTR          # equity proxy
GET /v1/exposure/gex/BTC%3DF           # CME, Growth plan or higher

There is no single bitcoin options book and no single bitcoin dealer gamma number. The four venues are priced differently, hedged in different instruments, and held by different people, which is why they showed opposite signs at the same instant on 17 August 2026. Rather than aggregating them into an average that describes nobody, select the book whose hedging flow lands in the instrument you actually hold, and read the others as context. When the ETF and CME books disagree on regime, treat that as a statement about competing hedging populations, and expect realised volatility to run higher than either book alone would suggest.

Originally published at flashalpha.com.

Crypto Options Dealer Positioning: CME Bitcoin, Ether and the ETF Complex

tomasz dobrowolski — Mon, 17 Aug 2026 09:40:07 +0000

Most crypto positioning commentary treats "bitcoin options" as one thing. It is not. The same underlying exposure is expressed through at least four different instrument wrappers, each with its own settlement mechanics, pricing model, participant base and hedging channel. Aggregate them naively and you get a number that describes nothing. Read them separately and the disagreements between them become the signal.

The Wrappers Disagree, And That Is The Point

Here is the full crypto complex read at the same instant, before the US open on 17 August 2026. Gamma exposure is computed on settled open interest, so these are structural positions rather than intraday flow.

Instrument	Wrapper	Spot	Regime	Net GEX	Gamma flip
MSTR	Equity proxy	93.91	Positive	+$26.86M	93.26
IBIT	Spot BTC ETF	35.93	Positive	+$3.98M	35.90
COIN	Equity proxy	149.55	Positive	+$1.41M	147.17
ETHA	Spot ETH ETF	14.28	Negative	−$2.00M	15.23
BTC=F	CME option on future	63,470	Negative	−$0.85M	63,531

Read the regime column. Bitcoin exposure held through the spot ETF sits in positive gamma, where dealers dampen moves. The identical exposure held through CME futures sits in negative gamma, where dealers amplify them. Same asset, same moment, opposite hedging behaviour.

The proximity makes it sharper. BTC=F is trading 63,470 against a flip at 63,531, roughly 0.1% below its own zero-gamma level. IBIT is trading 35.93 against a flip at 35.90, about 0.06% above its own. Both books are balanced on the knife edge, on opposite sides of it. A move of a fifth of a percent in bitcoin flips one of them and not the other.

This is not an arbitrage and it is not a data error. Different books can carry genuinely opposite dealer positions because different people trade them for different reasons. The ETF book absorbs covered-call and overwriting flow from long holders; the CME book carries basis and macro-hedging flow from funds. Neither is "wrong". They are describing different populations.

The Four Wrappers

	CME options on futures	Spot ETF options	Equity proxies	Offshore
Examples	BTC=F, ETH=F	IBIT, ETHA, FBTC	MSTR, COIN, MARA	Offshore venues
Regulated	Yes, CFTC	Yes, SEC / OCC	Yes, SEC / OCC	No
Settlement	Cash, CME reference rate	Physical, ETF shares	Physical, shares	Coin or perp
Pricing model	Black-76 on the forward	Black-Scholes on spot	Black-Scholes on spot	Varies
Hedged in	CME futures	ETF shares, then coin via AP	The equity itself	Coin or perp
Expiry ladder	Monthly, quarterly	Weekly, monthly, LEAPS	Weekly, monthly, LEAPS	Near-continuous
Participants	Funds, CTAs, basis desks	Advisors, overwriters, retail	Retail, vol funds, convert arb	Global, retail-heavy

The row that does most of the work is "hedged in". A dealer short gamma on BTC=F hedges by trading CME futures. A dealer short gamma on IBIT hedges by trading IBIT shares, and only indirectly touches coin when authorised participants create or redeem. A dealer short gamma on MSTR hedges by trading MSTR stock, which is a leveraged, convertible-laden claim on bitcoin rather than bitcoin itself.

So the hedging flows land in different places. CME gamma transmits to the futures curve. ETF gamma transmits to ETF share volume. MSTR gamma transmits to a single equity whose relationship to bitcoin is itself unstable. Treating these as one aggregated "crypto GEX" number silently assumes a fungibility of hedging channels that does not exist.

The CME Book: Priced On The Forward

Symbol	Contract	Multiplier	Tick	Settlement
BTC=F	Bitcoin, 5 BTC	$5 / point	5 ($25.00)	Cash-settled
ETH=F	Ether, 50 ETH	$50 / point	0.50 ($25.00)	Cash-settled

Both are quoted in dollars per coin, so the multiplier is simply the contract size and there is no quote-convention trap of the kind that catches out Treasuries and grains. At 63,470 a bitcoin contract is about $317,000 of notional.

These are options on the CME future, so they are priced with Black-76 on the forward, not Black-Scholes on spot. Crypto futures trade in meaningful contango and backwardation, and that basis is a real component of the forward. Pricing these greeks off a spot index introduces an error that grows with tenor.

CME contract sizes are large. One bitcoin contract is 5 BTC, a few hundred thousand dollars of notional. Open interest counts therefore look small next to offshore venues while representing comparable dollar exposure. In the table above, the entire BTC=F hedging requirement for a 1% move is about 13 contracts, which is $850k of gamma, not a rounding error. Always compare in dollars, never in contracts.

Expiry structure matters too. CME crypto concentrates in monthly and quarterly cycles rather than the near-continuous ladder offshore venues offer, so gamma builds and releases on an equity-like rhythm. Classic expiry-week pin logic is more applicable here than anywhere else in crypto.

The ETF Book: Where The Overwriting Lives

IBIT is now the most consequential regulated bitcoin options book by participation, and it behaves unlike the CME one. Its positive net gamma of +$3.98M against a flip essentially at spot reflects a book dominated by call overwriting: long holders selling upside against ETF positions, which leaves dealers long gamma and therefore mean-reverting.

The Ether ETF tells the opposite story at the same moment. ETHA carries −$2.00M of net gamma with its flip at 15.23 against a spot of 14.28, meaning spot sits a full 6.7% below the flip. That is not a knife edge, that is a book decisively in negative-gamma territory, where dealer hedging amplifies moves in both directions.

ETHA is also the only instrument in the complex with negative vanna and negative charm exposure right now (−$29.3M and −$176k respectively). The practical reading: a volatility spike makes ETHA dealers sell delta, amplifying downside, where the same spike in IBIT or MSTR makes dealers buy. If you are looking for the fragile leg of the crypto complex today, the greeks are pointing at ether, not bitcoin.

The Proxies: MSTR Is The Largest Crypto Vol Book In Equities

MSTR carries +$26.86M of net gamma. That is 6.7x IBIT's and 19x COIN's. Its vanna exposure of +$324M is over twenty times COIN's $16.1M. By any exposure measure, the single largest concentration of crypto-linked options risk in the US equity market is not a bitcoin ETF. It is a software company's balance sheet.

That has a mechanical consequence. Dealer hedging of MSTR gamma requires trading MSTR shares, and the hedging requirement for a 1% move is roughly 286,000 shares. MSTR's stock is a levered claim on bitcoin with convertible debt layered on top, so options-driven hedging flow interacts with convert-arb hedging flow in the same tape. This is why MSTR moves are frequently larger than its bitcoin beta alone predicts.

COIN is the cleaner instrument of the two. Its net gamma is small (+$1.41M) but its delta exposure is large (+$222.7M, larger than MSTR's +$107.2M). Dealers hold a big directional book in COIN and a small convexity book. That combination produces steady hedging pressure rather than the reflexive squeezes MSTR is known for.

The Offshore Book: Big, And Not Your Hedging Channel

Offshore venues still hold the majority of global crypto options open interest, and any honest account has to say so. But size is not the same as relevance, and the reason is mechanical rather than ideological.

Offshore books are hedged in coin and in perpetual swaps. If you hold IBIT, no amount of offshore dealer hedging touches your instrument directly. It moves bitcoin, which moves the ETF's net asset value, which authorised participants arbitrage back into the share price. That is a real transmission path, but it is indirect, lagged, and it passes through a creation-redemption mechanism that only operates during US market hours.

Three characteristics make the offshore book behave differently from anything onshore:

A near-continuous expiry ladder. Where CME concentrates in monthlies and quarterlies, offshore venues list expiries almost continuously. Gamma never builds into a single dominant date the way it does on CME, so expiry-week pin effects are weaker and more diffuse.
Coin-margined contracts. Some offshore contracts are margined in the underlying coin, which makes the payoff non-linear in a way a dollar-denominated option is not. Exposure computed as though these were dollar-settled is wrong before you start.
24/7 trading. The book never closes, so it absorbs weekend flow that the onshore wrappers cannot. Much of the gap risk that shows up as a Monday move in IBIT was already traded offshore on Saturday.

The practical position: read offshore for the coin, read onshore for the wrapper you hold. Do not add them together.

Expiry: The One Week The Wrappers Converge

The wrappers spend most of the month telling different stories. Monthly expiry week is when they partially align, because that is the one date on which CME, the ETFs and the equity proxies all have material gamma rolling off simultaneously.

Three things happen at once. CME's monthly and quarterly concentration releases, which is the single largest scheduled gamma event in the regulated crypto complex. The ETF overwriting cycle resets, as covered calls sold against IBIT and ETHA positions expire or are rolled up and out. And the equity proxies clear their monthly chains alongside every other US equity.

The consequence is that the week after monthly expiry frequently has a different volatility character from the week before, and the strike maps you were reading are stale the moment the chains roll. Two practical rules follow:

Re-read every wrapper after monthly expiry, not before. Walls computed on a chain that is about to expire describe a book that is about to cease existing.
Expect the ETF dampening to weaken first. Overwriters who get assigned are out of the position until they re-establish it, so the long-gamma tilt that suppresses IBIT volatility is at its weakest in the days immediately following expiry.

Five Mistakes That Show Up Constantly

Aggregating into one "crypto GEX" number. The single most common error, and the one that makes everything downstream meaningless. The hedging flows behind each wrapper are executed in different instruments by different firms and never net.

Comparing contract counts. One CME bitcoin contract is 5 BTC, roughly $317,000 of notional. One IBIT contract is 100 shares, roughly $3,600. Open-interest counts across the two differ by about two orders of magnitude and mean nothing side by side.

Pricing CME greeks off spot. These are options on the future and price with Black-76 on the forward. At 10% annualised contango, feeding spot instead underprices a one-year at-the-money call by 23.8% and puts delta out by nearly seven percentage points.

Reading heavy put open interest as support. When puts at a strike outnumber calls by an order of magnitude, that is outright protection buying by holders, not two-way dealer positioning. It does not create the hedging bid that a genuine put wall implies.

Assuming the ETF book reflects overnight crypto moves. IBIT, ETHA, MSTR and COIN options trade US equity hours. The underlying trades continuously. A large weekend move in coin does not appear in ETF exposure until the equity market reopens, so exposure pulled on a Sunday describes Friday's book.

How To Read It

Pick the wrapper that matches your risk. If you trade IBIT, IBIT gamma is your hedging tape. CME gamma is somebody else's.
Regime before levels. Positive gamma means dealers dampen; negative means they amplify. Everything else is secondary.
Treat divergence as information about who is positioned, not as an arbitrage. The wrappers are not fungible and the hedging flows do not net.
Compare in dollars, never in contracts, especially across CME and the ETFs, where contract sizes differ by orders of magnitude.
Watch distance to flip, not just sign. A book 0.1% from its flip is a different animal from one 6.7% away, even if both read "negative".
Price CME greeks on the forward. Black-76, not Black-Scholes. The basis is not noise.

Pulling It Programmatically

GET /v1/exposure/summary/IBIT          # spot bitcoin ETF, full greek summary
GET /v1/exposure/gex/MSTR              # equity proxy gamma by strike
GET /v1/exposure/summary/ETHA          # ether ETF - watch the negative vanna
GET /v1/exposure/gex/BTC%3DF           # CME bitcoin gamma by strike
GET /v1/stock/IBIT/summary             # incl. IV term structure

Equity and ETF symbols (IBIT, ETHA, MSTR, COIN) are ordinary tickers. Futures symbols take the =F suffix with = URL-encoded as %3D, and require the Growth plan or higher. Everything that works for an equity works across the complex: GEX, DEX, VEX, CHEX, levels, max pain, the volatility surface and the exposure summary.

Crypto dealer positioning is not one book, it is four, and on 17 August 2026 they disagreed about the sign of dealer gamma while bitcoin sat within 0.1% of the CME flip and IBIT within 0.06% of its own. That disagreement is structural, not spurious: each wrapper is priced differently, hedged in a different instrument, and held by a different set of people. Read the wrapper that matches your risk, compare exposure in dollars rather than contracts, price CME greeks on the forward rather than spot, and treat cross-venue divergence as information about who is positioned rather than as a trade.

Originally published at flashalpha.com.

How Much Does IV Drop After Earnings? Real Crush Numbers by Name

tomasz dobrowolski — Tue, 04 Aug 2026 07:54:53 +0000

If you are asking how much does IV drop after earnings, the honest answer is: it depends on the name, and the difference is measurable. This post puts real numbers on earnings IV crush using event-history data, then explains the mechanics that make META's crush three times NVDA's.

IV crush, defined in one paragraph: implied volatility before earnings contains a one-time jump premium for the announcement. The moment results are out, that uncertainty is resolved and the jump premium evaporates - ATM implied volatility drops discontinuously, typically at the next open. The size of the drop is the share of total option-implied variance that the event itself represented.

The measured distributions

From GET /v1/earnings/iv-crush/{symbol} on 2026-08-03, which returns the live expected-crush estimate plus the distribution over up to 20 past events:

Symbol	Median crush	P25	P75	Best event	Events	Next earnings
META	42.5%	41.0%	43.4%	46.5%	6	2026-10-27
AAPL	23.2%	20.4%	27.5%	28.6%	6	2026-10-28
NVDA	14.8%	14.1%	15.5%	16.8%	4	2026-08-26

Crush here is the percentage drop in ATM IV from the last pre-event reading to the first post-event reading, front expiry.

Honest footnotes: the samples are the platform's covered event history (four to six events per name at the time of writing, growing each quarter), and a zero in a distribution's worst column - both AAPL and META carry one - marks an event where the measured crush did not materialise in the data. The interquartile range is the robust read, not the extremes.

Why META crushes 3x harder than NVDA

Pre-event IV is a blend of two components: baseline diffusion (the vol the stock runs on ordinary days) and the event jump. The crush percentage is essentially the event's share of total implied variance. Two things drive it:

How large the expected jump is relative to baseline vol. META's post-earnings moves have repeatedly been double-digit percent against a baseline vol in the 30s - the event dominates the front expiry, so resolving it removes most of the IV. NVDA runs a high baseline vol (around 37% in early August 2026, three weeks before its report) with an implied move that is large in dollars but smaller relative to that baseline, so the event share - and the crush - is smaller.
Days to expiry at the event. The shorter the expiry, the larger the event's share of remaining variance, the more violent the crush. Weeklies crush hardest; a 60-day option barely notices.

The expected-move endpoint performs exactly this decomposition - splitting the front-expiry straddle into jump and diffusion using the pre/post-event term structure - which is what makes a live crush estimate possible before the event.

The ramp: expected crush grows into the event

Three weeks before NVDA's 2026-08-26 report, the live estimate read a modest expected crush (about 4% at the front expiry, pre-IV 42.5 against post-IV 40.8) - far below the 15% the distribution says the event delivers.

That is not a contradiction; it is the ramp. Event variance concentrates into the front expiry as the calendar rolls toward the report: with three weeks of ordinary trading days still in the expiry, the jump is a small share of total variance. By the week of the event, the front expiry is mostly jump, and the expected crush converges toward the historical distribution.

Watching the live estimate ramp against the historical median is the cleanest way to see whether this quarter's event premium is building rich or cheap relative to the name's own history.

Trading implications, honestly stated

Crush is not free money. The stock moves at the same moment the IV collapses, and whether short-premium structures win depends on implied vs realised move, not on the existence of crush. Measured separately across 70 events: the median event harvested a third of the implied move with a 67% win rate and a fat left tail.

The per-name crush distribution adds the structure-selection layer. Names with large, reliable crush and modest realised moves favour short-vega structures; names where the crush is small relative to gap risk favour defined-risk or long-gamma-into-ramp structures.

Pulling it yourself

import requests

for sym in ["AAPL", "META", "NVDA"]:
    r = requests.get(
        f"https://lab.flashalpha.com/v1/earnings/iv-crush/{sym}",
        headers={"X-Api-Key": KEY},
    ).json()
    est, dist = r["current_estimate"], r["distribution"]
    print(sym, r["earnings_date"],
          f"expected {est['expected_crush_pct']}%",
          f"median {dist['median']}%  p25 {dist['p25']}  p75 {dist['p75']}")

Per-event detail - EPS and revenue surprises, implied vs actual moves, realised crush per event - comes from the companion /v1/earnings/history/{symbol} endpoint, and the upcoming calendar from /v1/earnings/calendar.

FAQ

How much does IV drop after earnings on average?
Across the names measured here, median crush ranges from about 15% (NVDA) through 23% (AAPL) to 43% (META) of pre-event ATM IV at the front expiry. There is no useful single average: the number is a per-name property driven by the event's share of total implied variance, and it is stable enough per name to be worth looking up rather than guessing.

When exactly does IV crush happen?
At the resolution of the uncertainty: effectively instantaneous at the first quotes after the announcement (the next open for after-close reporters). The decay into the event is a separate, slower effect - the jump premium itself holds until the news is out.

Can you profit from IV crush by selling options before earnings?
Only when the implied move overprices the realised move - the crush and the gap arrive together. The measured base rate: about two-thirds of events pay the seller something, the median event pays a third of the implied move, and the tail events cost multiples of it.

Does IV crush affect all expirations equally?
No. Crush concentrates in the front expiry, where the event is the dominant share of remaining variance. Back-month IV barely moves, which is why calendar structures are one of the standard earnings expressions and why measuring crush requires expiry-matched pre/post readings.

Wrapping up

IV crush is real, large, and - the part almost nobody quantifies - radically different across names: the same mega-cap quarter produced a 15% median crush in NVDA and a 43% median crush in META. The distribution for any covered name is one API call, and the live estimate ramps against it into each event.

Originally published at flashalpha.com.

Gamma Scalping: The Complete Guide to Delta-Hedged Straddle P&L

tomasz dobrowolski — Tue, 04 Aug 2026 07:54:41 +0000

If you searched for gamma scalping - or for why your delta-hedged straddle made money on a day the market barely closed changed - this is the complete mechanical picture: the identity, the breakeven, the hedging tradeoffs, the entry conditions, and the data to run it on.

Gamma scalping, defined in one paragraph: gamma scalping is delta-hedging a long-gamma options position (typically an ATM straddle) so that each move in the underlying forces profitable re-hedges - buying dips and selling rips mechanically - while paying theta for the privilege. It converts an options position into a trade of realised volatility against the implied volatility you paid.

The identity that runs the whole strategy

Delta-hedge a long option continuously and the direction drops out. What remains, per small time step, is the canonical P&L decomposition:

dP&L ≈ ½ Γ S² (σ²realised − σ²implied) dt

Read it term by term. ½ΓS² is dollar gamma - how much delta the position manufactures per squared move. The bracket is the variance spread - realised variance delivered minus implied variance paid (the theta you bleed is the implied leg).

Everything about gamma scalping falls out of this line. You are not "trading options"; you are long realised variance and short implied variance, sized by dollar gamma. The strategy wins if, and only if, the underlying realises more than the options implied over the holding period. Re-hedging is merely the collection mechanism.

The same identity with the sign flipped is every premium seller's income statement, which is why realised vs implied is the spread that runs the entire volatility complex.

The breakeven, with live numbers

The intuitive version of the identity: each day, the position must move enough to pay that day's theta. For an ATM straddle the breakeven daily move is approximately:

breakeven ≈ S × IV / √252

On 2026-08-03, SPY closed at 758.34 with 30-day ATM implied vol around 13%. That prices a breakeven daily move of roughly 0.82%, or about 6.2 SPY points. Days that move more than that earn the long-gamma book money; days that move less bleed it.

And the regime context said bleed: VIX stood at 15.86 against an SPX 20-day realised of 12.48 - implied comfortably above realised, the normal volatility-risk-premium state in which the average long-gamma day loses. That single comparison is the entry gate for the whole strategy, and it is one API call (below).

The payoff curve is quadratic, because P&L tracks variance rather than the move itself.

Hedging frequency: the tradeoff nobody escapes

Hedge continuously and P&L converges to the identity with minimal noise - but transaction costs scale with the number of hedges and eat the edge.
Hedge rarely (daily, or at fixed delta bands) and costs drop, but P&L picks up path noise: you can realise high vol and still lose if the path whipsaws between your hedge points. The expected value is unchanged; the variance of outcomes grows.
Band-based hedging (re-hedge when delta drifts past a threshold) is the standard practical compromise, with bands widened as costs rise. On index products with tight markets the costs are manageable; on single names the spread cost per hedge is a first-order input.

One practical asymmetry: scalping into a gap is not optional. Overnight gaps deliver realised variance with no opportunity to hedge along the way - which is precisely why gap-heavy names (earnings season, biotech) are where long gamma pays best, and why realised-vol estimators that ignore overnight moves mislead. Use an estimator that handles the open.

When long gamma actually pays

The identity says: when realised beats implied. The measurable states where that happens:

Negative VRP episodes. The volatility risk premium is positive most of the time (that is the premium), but it inverts around shocks and regime breaks. A negative or deeply compressed VRP z-score is the systematic entry flag.
Pre-event ramps. Into earnings, implied rises but realised rises with it through the ramp; the post-event crush is the exit, not the trade.
Short-gamma dealer regimes. When the dealer complex is short gamma, forced hedging amplifies moves - realised vol runs hot relative to quiet-regime pricing.

The biggest gamma scalper in the market is the dealer complex

Here is the connection that makes gamma scalping more than a niche strategy. When dealers are net long gamma, the entire market-making complex is running this exact playbook at index scale - buying every dip and selling every rally to stay delta-neutral.

That mechanical flow is why long-gamma regimes pin and dampen markets, and why GEX - the aggregate dollar gamma of that complex, by strike - predicts intraday behaviour. When you gamma scalp, you are joining (or opposing) the largest systematic vol trader in existence, and the signed polarity of dealer gamma tells you which side they are on today.

Running the numbers on the API

import requests

BASE, H = "https://lab.flashalpha.com", {"X-Api-Key": KEY}

vrp = requests.get(f"{BASE}/v1/vrp/SPY", headers=H).json()
rv  = requests.get(f"{BASE}/v1/volatility/SPY", headers=H).json()

# The gate: is implied trading rich or cheap to realised?
# vrp payload carries the IV-RV spread, z-score and percentile;
# volatility payload carries the realised-vol estimators.
print(vrp)
print(rv)

The volatility endpoint carries the implied and realised series for the comparison. The VRP dashboard adds the z-score and percentile that place today's spread against the name's own history - the systematic version of the VIX-vs-realised eyeball test - and its historical counterpart replays the series point-in-time for backtests (SPY minute data from 2017-01-03). For per-strike dollar gamma to size the position, the greeks endpoint serves the chain live.

FAQ

What is gamma scalping in simple terms?
Buy a straddle so you make money if the stock moves either way. As it moves, keep flattening your directional exposure - selling some stock after rallies, buying after dips. Each flatten locks in profit from the move. If the stock moves around a lot, the locked-in profits exceed the daily cost of owning the options; if it goes quiet, they do not.

Is gamma scalping profitable?
Only when realised volatility exceeds the implied volatility you paid - which is the exception, not the rule, because implied usually carries a premium. Profitability is a timing question: the strategy pays around shocks, events, and short-gamma dealer regimes, and bleeds in the long calm stretches. Measure the spread before entering; do not run it as a permanent posture.

How often should you re-hedge?
There is no free choice: frequent hedging reduces path noise but multiplies transaction costs; infrequent hedging is cheaper but noisier. Delta bands with band width scaled to the name's spread cost is standard practice. The expected P&L is set by realised-vs-implied either way - hedging style mainly chooses your variance around it.

Is it the same as what market makers do?
Mechanically yes - dealers delta-hedge their books continuously, and when they are net long gamma the whole complex is gamma scalping against the market, which dampens volatility. The difference is intent: dealers hedge inventory they were paid a spread to carry; a gamma scalper chooses the position to express a realised-vol view.

Wrapping up

Gamma scalping is the cleanest expression of the only question in volatility trading: will realised beat implied? The identity ½ΓS²(RV²-IV²) decides the outcome, the breakeven daily move (about 0.82% for SPY at August 2026 pricing) makes it concrete, and the implied-vs-realised spread that gates the trade is one volatility call away.

Originally published at flashalpha.com.

DEV Community: tomasz dobrowolski

50 Options Strategies, 6 Years, Real Bid-Ask Prices: Only 10 Had a Positive Mean

Reading the numbers

Monthly ETF table, the positive half

The stricter comparison: six structures, same 133 months

The spread is the story

Signal filters: one of four did anything

Earnings: 12 events, useful as worked examples only

The wheel

Method

Reproduce it

Every API Response Should Prove Its Own Freshness. Here Is How We Do It for Options Data

Three properties, six layers

1. Ingest with per-feed liveness

2. Cross-source reconciliation, several times a day

3. Serving guards that fail closed

4. Thirty pipelines, one health registry

5. Point-in-time archive with archive_as_of

6. data_as_of on every response

Verified from outside

Verify it in sixty seconds

FAQ

Links

Trading Gamma Flip Crosses Without Getting Faked Out: regime, unknown, and a Reference Detector in Python

Three fields, read as a unit

How regime is computed

The three meanings of unknown

Pre-cross or post-cross regime?

Reference cross detector

Backtesting

Four anti-patterns

Links

Why We Made Our Gamma Flip Nullable (And Two Thirds of Chains Now Return Null)

The problem

How the flip is computed

The three gates

Why the last hour is where levels vanish

Reason codes

Validation

Handling it in code

Backtesting

Verify it yourself

GEXBot vs FlashAlpha: Beyond GEX to Quant Research

TL;DR

Endpoint breadth that works together

Example workflow

Historical replay is the live API with a timestamp

From notebook to production

Which tier

Where GEXBot remains a good choice

Recommendation

FlashAlpha vs LSEG Workspace (Refinitiv Eikon) 2026 - Options Data

The TL;DR

The entitlement model is the thing to understand

What each one actually computes

LSEG Workspace

FlashAlpha

Where the Reuters newsroom and macro history matter

History and reproducibility

Where LSEG Workspace wins

Where FlashAlpha wins

Pricing, with sources

Who should not use each

The realistic answer: both, split by job

Try it alongside your Workspace entitlement

Sources

FlashAlpha vs OptionMetrics IvyDB 2026 - Historical Options Data

The TL;DR

What IvyDB actually contains, accurately

The real difference: stored values versus stored inputs

Three snapshots a day versus every minute

Research archive versus production feed

The academic licence detail worth knowing

Where OptionMetrics wins

Where FlashAlpha wins

Pricing

Who should not use each

The combination that actually makes sense

Try the overlap

Sources