Introducing

Unusual Options Trades Expand Massive's Options Data

Nov 16, 2026

Massive's options data now includes Unusual Options Trades, a new endpoint that returns every U.S. options trade with at least $100,000 of premium, at least 1,000 contracts, or an intermarket sweep condition. Each trade comes with a flags list naming which of those tests it met, along with its price, size, exchange, condition codes, and nanosecond SIP timestamp.

Finding these trades used to mean processing every print in the options market yourself, and now it takes one request for a contract, an underlying, or the whole market. The data is real-time for recent sessions and goes back to September 1, 2022. Unusual Options Trades is included in the Options Advanced plan and the Real-time Unusual Options Trades Business plan.

What Unusual Options Trades Are

Most options trades are small, and the large ones tend to get attention because they show where institutions are putting real money. Traders usually look at two kinds. Block trades are large in premium or contract count, and sweeps are orders that are split across several exchanges at once to fill as quickly as possible, which is often read as a sign of urgency. Neither one is automatically a directional bet. A large trade can be a hedge, one leg of a spread, or a position being closed, so the condition codes and the contract's open interest matter as much as the size.

Massive already serves every options trade through the Trades endpoint, along with quotes, open interest, and aggregates for each contract. Unusual Options Trades adds a filtered view across every contract, so you can see the large and urgent trades for the entire market without pulling the full trade feed. It uses the same option tickers and condition codes as those endpoints, so you can go from an unusual trade to the contract's open interest, quotes, or price history with a few more calls. The examples below use the Massive Python client.

Unusual Options Trades API

The Unusual Options Trades endpoint returns one row per qualifying trade. A trade qualifies when its premium (price × size × 100) is $100,000 or more, when it is 1,000 contracts or more, or when it carries the intermarket sweep condition (219). Cancels, late reports, and compression trades are excluded.

Here is how to look up the first unusual trades of the day in one NVIDIA contract.

Request Example

from massive import RESTClient

client = RESTClient("YOUR_API_KEY", pagination=False)

trades = []
for t in client.list_options_unusual_trades(
    ticker="O:NVDA270115C00170000",
    sip_timestamp_gte="2026-11-12",
    sip_timestamp_lt="2026-11-13",
    sort="sip_timestamp.asc",
    limit=2,
):
    trades.append(t)
print(trades)

Response Example

[
    OptionsUnusualTrade(
        ticker="O:NVDA270115C00170000",
        underlying_ticker="NVDA",
        root="NVDA",
        sip_timestamp=1794493800677784184,
        sequence_number=30815171,
        price=6.05,
        size=2,
        exchange=308,
        conditions=[219],
        flags=["iso"],
    ),
    OptionsUnusualTrade(
        ticker="O:NVDA270115C00170000",
        underlying_ticker="NVDA",
        root="NVDA",
        sip_timestamp=1794493846306036587,
        sequence_number=52437567,
        price=7.45,
        size=275,
        exchange=313,
        conditions=[209],
        flags=["block_premium"],
    ),
]

A few fields are worth knowing:

  • flags lists every test the trade met: block_premium for $100,000 or more of premium, block_size for 1,000 or more contracts, and iso for an intermarket sweep. The first trade above is a two-contract sweep at the open, and the second is a 275-contract trade worth about $205,000.
  • price is quoted per share, as options prices usually are, so the premium of a trade is price * size * 100.
  • conditions are the same OPRA condition codes used by the Trades endpoint. They tell you whether a trade was electronic or on the floor, and whether it was a single option or one leg of a multi-leg order, which matters a lot when you are deciding whether a trade is directional.
  • underlying_ticker and root differ for weekly and adjusted contracts. SPXW contracts report an underlying of SPX, so you can group by underlying_ticker and still tell the roots apart.

The ticker filter takes a full option ticker, and it also supports ranges. Option tickers sort by root, so ticker_gte="O:NVDA" with ticker_lt="O:NVDB" returns every NVDA contract. The sip_timestamp filters accept nanosecond timestamps, plain dates, or ISO 8601 times, and leaving out ticker returns trades for the whole market.

Demo: Following One Day of Options Flow

A good way to see what the endpoint can do is to take one full session and narrow it down. We will use November 12, 2026, a day when NVDA opened at $151.01 after closing at $173.73 the day before, then recovered to $166.19 by the close.

The first step is to pull every unusual trade for the session and group them by flag:

from collections import defaultdict
from massive import RESTClient

client = RESTClient("YOUR_API_KEY")  # pagination on: iterates every page

# 1. Pull every unusual trade for one session
trades = list(client.list_options_unusual_trades(
    sip_timestamp_gte="2026-11-12",
    sip_timestamp_lt="2026-11-13",
    limit=50000,
))

# 2. Group by the combination of flags and add up premium
groups = defaultdict(lambda: [0, 0.0])
for t in trades:
    g = groups[", ".join(sorted(t.flags))]
    g[0] += 1
    g[1] += t.price * t.size * 100

print(f"{'Flags':<38}{'Trades':>10}{'Premium':>18}")
for flags, (n, premium) in sorted(groups.items(), key=lambda kv: -kv[1][0]):
    print(f"{flags:<38}{n:>10,}{premium:>18,.0f}")
Flags                                     Trades           Premium
iso                                      306,926       363,258,550
block_premium                             35,899    15,480,872,224
block_premium, block_size                  2,012     9,031,655,201
block_size                                   899        29,132,631
block_premium, iso                           164        28,798,821
block_size, iso                                9           142,014
block_premium, block_size, iso                 4         1,402,316

The request returned 345,913 trades. Most of them are sweeps, but the median sweep was only two contracts and $296 of premium, so the sweep flag on its own mostly picks up small orders routed across exchanges. Nearly all of the money is in the block trades. If you also split the blocks by condition code, about two thirds of the block premium came from multi-leg orders such as spreads, which are much harder to read as a view on direction than a single option trade.

The next step is to keep single-leg block trades and add up the premium by underlying. The condition names come from Massive's existing condition codes endpoint, so the multi-leg filter does not need any hard-coded values:

import re

# Condition codes for multi-leg and stock-tied trades
multi_leg = {
    c.id for c in client.list_conditions(asset_class="options")
    if "Multi Leg" in c.name or "Stock Options" in c.name
}

# Keep single-leg trades with at least $100,000 of premium
blocks = [
    t for t in trades
    if "block_premium" in t.flags and not multi_leg & set(t.conditions)
]

# Total premium by underlying, split into calls and puts
flow = defaultdict(lambda: {"C": 0.0, "P": 0.0})
for t in blocks:
    call_or_put = re.search(r"\d{6}([CP])\d{8}$", t.ticker).group(1)
    flow[t.underlying_ticker][call_or_put] += t.price * t.size * 100

print(f"{len(blocks):,} single-leg block trades")
print(f"{'Underlying':<12}{'Call Premium':>16}{'Put Premium':>16}{'Calls':>8}")
for und, p in sorted(flow.items(), key=lambda kv: -sum(kv[1].values()))[:10]:
    total = p["C"] + p["P"]
    print(f"{und:<12}{p['C']:>16,.0f}{p['P']:>16,.0f}{p['C'] / total:>8.0%}")
15,407 single-leg block trades
Underlying      Call Premium     Put Premium   Calls
NVDA             408,948,201     760,325,005     35%
QQQ              105,092,992     471,153,938     18%
INTC              13,024,160     508,265,466      2%
MU               127,979,771     355,496,424     26%
BA                 3,393,304     390,334,485      1%
GLD               16,786,646     348,214,275      5%
SPY              194,190,413     110,771,215     64%
LULU                       0     299,273,270      0%
SPX              129,317,055     151,850,025     46%
AMD              200,517,912      47,916,755     81%

NVDA had the most single-leg block premium of any underlying, about $1.17 billion. To see which contracts drove it, use the ticker range filter to pull only NVDA trades and rank the contracts:

# Every unusual NVDA trade: tickers sort by root, so a range selects one underlying
nvda = client.list_options_unusual_trades(
    ticker_gte="O:NVDA",
    ticker_lt="O:NVDB",
    sip_timestamp_gte="2026-11-12",
    sip_timestamp_lt="2026-11-13",
    limit=50000,
)

contracts = defaultdict(lambda: {"premium": 0.0, "size": 0, "trades": 0})
for t in nvda:
    if "block_premium" in t.flags and not multi_leg & set(t.conditions):
        c = contracts[t.ticker]
        c["premium"] += t.price * t.size * 100
        c["size"] += t.size
        c["trades"] += 1

print(f"{'Contract':<24}{'Premium':>14}{'Contracts':>11}{'Trades':>8}")
for ticker, c in sorted(contracts.items(), key=lambda kv: -kv[1]["premium"])[:5]:
    print(f"{ticker:<24}{c['premium']:>14,.0f}{c['size']:>11,}{c['trades']:>8}")
Contract                       Premium  Contracts  Trades
O:NVDA261113P00205000       42,300,925     10,349       3
O:NVDA270115C00170000       41,998,769     39,070      94
O:NVDA270319P00185000       33,895,677     10,049       2
O:NVDA261113P00195000       33,364,544     10,996       2
O:NVDA261120P00250000       33,234,300      3,920       3

Most of these rows are two or three very large trades in puts that were far in the money, which is common for hedging and financing trades. The January 2027 $170 call is different. It traded 39,070 contracts across 94 separate block trades, at prices that rose from $7.40 to $13.37 as the stock recovered. Plotting the trades over the session shows that 28,645 contracts had traded by 9:45 AM and 38,880 by 11:00 AM.

Adding Massive's minute aggregates for the stock puts that timing in context. Almost all of the block volume came during the first ninety minutes, while NVDA climbed from about $150 back above $165.

A large volume of trades does not tell you whether positions were opened or closed. The existing Open Interest endpoint answers that, since open interest only rises when new contracts are created:

for oi in client.list_options_open_interest(
    ticker="O:NVDA270115C00170000",
    date_gte="2026-11-10",
    date_lte="2026-11-13",
    sort="date.asc",
):
    print(oi.date, f"{oi.open_interest:>8,}")
2026-11-10   14,185
2026-11-11   20,868
2026-11-12   20,326
2026-11-13   57,370

Open interest is reported each morning for the prior session, so the November 13 value reflects trading on November 12. It rose by 37,044 contracts, almost exactly the 39,070 contracts of block volume, which means most of those trades opened new positions rather than closing old ones. Three endpoints and a few dozen lines of Python took us from 345,913 unusual trades across the market to one contract where new positions of roughly $42 million were opened in the first ninety minutes of a volatile session.

There are several natural ways to extend this:

  • You can compare each trade's price with the national best bid and offer from the Quotes endpoint to estimate whether the buyer or the seller started it.
  • You can run the same screen every morning on the prior session and flag contracts where block volume was larger than the existing open interest.
  • You can use the history back to 2022 to measure how underlyings performed after heavy call or put block activity.
  • You can group by root instead of underlying_ticker to separate SPX from SPXW, or to watch contracts that were adjusted after a corporate action.

Next Steps

Unusual Options Trades is available now in the Options Advanced plan and the Real-time Unusual Options Trades Business plan, with real-time data and history back to September 1, 2022. It returns every block and sweep in the U.S. options market with flags that explain why each trade qualified. It shares tickers and condition codes with the Trades, Quotes, Open Interest, and Aggregates endpoints we already offer, so the context around any trade is a few calls away.

If you already use Massive for options data, unusual activity is now one more view you can build on, whether you are running a flow scanner, studying positioning around events, or checking what traded in a contract you hold. You can get started with the Python client and an API key from your dashboard, and our sales team at sales@massive.com can help with business plans and larger integrations.

Disclaimer

This content is for educational purposes only. It is not investment advice or a recommendation to buy or sell any security, and the companies mentioned are used only to illustrate the data.

From the blog

See what's happening at Massive