Options API How-To

How to Use Options Data for Earnings Research

A developer workflow for turning a known earnings timestamp into an options research artifact with listed expirations, exact OCC contracts, bid/ask validation, and replayable evidence.

Quick answerLast verified June 4, 2026

Start with an external earnings timestamp, discover listed expirations, select the event-window chain, reconstruct the point-in-time contracts, and validate every implied-move or post-event fill with quotes, trades, and aggregate bars.

Event source

External calendar

Use a dedicated earnings calendar for the date and time, then join CuteMarkets options data around it.

Core data

Chain + quotes

The chain gives candidates; bid/ask history decides whether the candidate was tradable.

Research output

Replay artifact

Store the contract, timestamp window, spread, quote age, open interest, and reject reason.

Event setup

Anchor the event before touching the chain

Treat the earnings date as a separate input, then use Expirations to find listed option expiration dates that cover the announcement. For after-close earnings, the relevant option surface is usually the session before the report and the first regular session after it; for before-open earnings, the pre-event chain and the next opening quote window matter more than the previous close.

The first technical failure mode is selecting a contract from the wrong date. Use Contracts with `as_of` when you need the historical universe, because an event replay should not see strikes, weeklies, adjusted options, or delisted contracts that were unavailable at the decision timestamp.

Surface construction

Build the pre-event option surface

Pull the Options Chain API for one expiration at a time and keep the exact OCC ticker, expiration, strike, call/put side, multiplier, open interest, implied volatility, delta, gamma, theta, vega, bid, ask, and last trade fields together. That gives the research notebook enough context to separate an at-the-money straddle, a skew trade, a calendar spread, or a far-out-of-the-money lottery contract.

For implied-move research, rank candidate calls and puts by moneyness first, then reject contracts with stale quotes, no-bid exits, crossed markets, or spread percent above your threshold. Midpoint, quote age, spread percent, open interest, volume, trade condition, and aggregate bar all belong inside the scoring logic because they determine whether the event result is usable.

ATM straddle

Use the closest call and put by strike, then calculate the straddle midpoint divided by the underlying reference price.

Output: implied move percent.

Skew read

Compare put and call implied volatility, delta buckets, and spread percent before the report.

Output: downside/upside premium bias.

Event replay

Join quotes, trades, and aggregates around entry and exit windows so the post-event result has fill evidence.

Output: replay artifact.

Execution evidence

Validate the result after the announcement

Use Quotes for bid/ask validation and Trades for print context, then use Aggregates to describe the contract price path. Aggregates are useful for visualizing OHLC, VWAP, and volume, but the fill model should still reference the quote window when deciding whether the option could be bought or sold.

A strong earnings result should include rejected candidates beside the winners. Store reject reasons such as missing quote window, stale quote, wide spread, no-bid exit, low open interest, and incomplete pagination so the next research pass can separate market behavior from data-quality noise.

Implementation detail

How to Use Options Data for Earnings Research in practice

Treat this page as an implementation boundary, more than a short answer. For How to Use Options Data for Earnings Research, the practical record should include the request inputs, timestamp context, selected object, freshness state, and the reason a row was accepted or rejected. That is what keeps a concise answer usable when it becomes a scanner, dashboard, backtest, alert, or support note.

The core page facts are Event source: External calendar; Core data: Chain + quotes; Research output: Replay artifact. Those values should map to fields in code or to visible labels in the interface. If a developer cannot point to the endpoint family, market-data object, date window, entitlement state, or review artifact behind the answer, the workflow is still too vague for production use.

A reliable implementation should store source URLs or endpoint paths, query parameters, pagination state, market timestamps, application timestamps, and any reject reason beside the result. That evidence makes it possible to rerun the answer later, compare it with another provider, and explain why a value changed after a calendar update, feed repair, plan change, or data-quality review.

In the checklist, the handoff starts with Import the event timestamp and ends with Validate fills and summarize movement. Keep those steps connected with stable identifiers rather than display labels, especially when the workflow moves from stocks into options, from chains into exact contracts, or from current snapshots into historical replay.

Earnings research request order

Each later request depends on a validated date, contract, or timestamp window from the previous step.

StepEndpoint familyWhy it matters
1. Event calendarExternal sourceDefines the earnings timestamp and whether the event is before open, during market hours, or after close.
2. ExpirationsListed expirationsPrevents the workflow from assuming a weekly or monthly date that is not listed for the underlying.
3. ChainCurrent chain snapshotBuilds the candidate surface with strike, side, open interest, Greeks, IV, bid, ask, and last trade context.
4. ContractsHistorical contracts with as_ofReconstructs the tradable universe for historical earnings events and avoids look-ahead contract selection.
5. Quotes and tradesHistorical quote and trade windowsValidates midpoint, bid/ask spread, quote age, trade condition, and plausible entry or exit fills.
6. AggregatesHistorical OHLC barsSummarizes price path, volume, VWAP, and post-event movement for charts and reporting.

What to store in the research artifact

Artifact fieldExampleReview use
event timestamp2026-05-12T20:05:00ZKeeps the options surface aligned to the actual earnings release window.
contract identityO:NVDA260515C00120000Preserves the OCC ticker, expiration, strike, side, and multiplier used in the test.
quote evidencebid, ask, quote age, spread percentExplains whether the midpoint, bid-side exit, or ask-side entry was plausible.
reject reasonwide-spread, no-bid-exit, stale-quoteMakes the filter auditable instead of silently dropping bad candidates.

API example

Verify the answer with listed data

earnings event request sequence

# 1) Start with an external earnings timestamp, then discover listed expirations.
curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.cutemarkets.com/v1/tickers/expirations/NVDA/"

# 2) Pull the chain that covers the event window.
curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.cutemarkets.com/v1/options/chain/NVDA/?expiration_date=2026-05-15&limit=100"

# 3) Reconstruct the point-in-time contract set for the pre-event session.
curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.cutemarkets.com/v1/options/contracts/?underlying_ticker=NVDA&as_of=2026-05-12&expiration_date=2026-05-15&limit=100"

# 4) Validate fills with bid/ask history and trade history around the event.
curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.cutemarkets.com/v1/options/quotes/O:NVDA260515C00120000/?timestamp.gte=2026-05-12T13:30:00Z&timestamp.lt=2026-05-13T20:00:00Z"
curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.cutemarkets.com/v1/options/trades/O:NVDA260515C00120000/?timestamp.gte=2026-05-12T13:30:00Z&timestamp.lt=2026-05-13T20:00:00Z"

quote-quality straddle filter

from math import isfinite

def midpoint(quote):
    bid = float(quote["bid_price"])
    ask = float(quote["ask_price"])
    if bid <= 0 or ask <= 0 or ask < bid:
        return None
    return (bid + ask) / 2

def spread_pct(quote):
    mid = midpoint(quote)
    if not mid:
        return None
    return (float(quote["ask_price"]) - float(quote["bid_price"])) / mid

def estimate_atm_straddle(chain, underlying_price, max_spread_pct=0.12):
    candidates = []
    for contract in chain["results"]:
        strike = float(contract["strike_price"])
        quote = contract.get("last_quote") or {}
        mid = midpoint(quote)
        spread = spread_pct(quote)
        if mid is None or spread is None or spread > max_spread_pct:
            continue
        candidates.append({
            "ticker": contract["ticker"],
            "side": contract["contract_type"],
            "strike": strike,
            "mid": mid,
            "spread_pct": spread,
            "distance": abs(strike - underlying_price),
        })

    calls = [c for c in candidates if c["side"] == "call"]
    puts = [c for c in candidates if c["side"] == "put"]
    call = min(calls, key=lambda c: c["distance"])
    put = min(puts, key=lambda c: c["distance"])
    implied_move = (call["mid"] + put["mid"]) / underlying_price
    return {"call": call, "put": put, "implied_move_pct": implied_move * 100}

def rank_event_candidates(rows):
    return sorted(
        [row for row in rows if isfinite(row["implied_move_pct"])],
        key=lambda row: (row["quote_reject_count"], -row["open_interest"], row["spread_pct"]),
    )

How to implement

Implementation checklist

01

Import the event timestamp

Load the earnings date and release timing from a dedicated calendar source, then normalize it to the market session and timestamp window you will test.

02

Discover listed expirations

Request listed expirations for the underlying and select the nearest event-window expiration or the longer-dated expiration required by the strategy.

03

Build the chain surface

Pull the chain for each selected expiration and store strike, side, open interest, Greeks, IV, bid, ask, last trade, and snapshot timestamp.

04

Reconstruct historical contracts

For historical events, request contracts with as_of set to the pre-event decision date so the replay cannot select future listings.

05

Validate fills and summarize movement

Join quotes, trades, and aggregate bars around entry and exit windows, then record spread percent, quote age, fill price, and reject reason.

Last verified

This guide was last reviewed on June 4, 2026. Date-sensitive market calendars, provider docs, and listed contracts can change, so production workflows should verify the live source before trading or publishing an automated answer.

Related questions

Does CuteMarkets provide the earnings calendar?

CuteMarkets provides the options data layer. Use a dedicated earnings calendar for event timing, then join the options chain, contracts, quotes, trades, and aggregates around that timestamp.

Should earnings research use last price or bid/ask quotes?

Use bid/ask quotes for tradability. Last price can describe a print, but it does not prove that an entry or exit was available at the research timestamp.

What makes an earnings replay point-in-time?

The replay should select contracts with as_of, use the quote window that existed at the decision time, and store reject reasons for stale, missing, or too-wide markets.

Operational usage

How to use How to Use Options Data for Earnings Research in a real workflow

Treat this page as a decision boundary for the surrounding API workflow. Before a value from How to Use Options Data for Earnings Researchenters a scanner, dashboard, calendar, backtest, or support answer, store the source route, request parameters, relevant timestamp, freshness label, and the reason the value is suitable for the next step.

The important implementation habit is to keep display labels separate from stable identifiers. Dates should remain tied to the calendar rule or listed-expiration source that produced them. Option rows should keep the OCC symbol, expiration, strike, side, quote state, and pagination context that created the row. Provider or product answers should keep the entitlement, licensing, and support assumptions visible.

When the workflow changes, rerun the page against one concrete example instead of trusting a general claim. Pick the ticker, date window, endpoint family, and expected output artifact. Then verify that the same terminology appears in the API request, UI label, log entry, and review checklist.

Related pages