By Matt Connor · · Updated 2026-07-26The Best and Worst Thousand Dollars of June 2026
June's best options contract returned 495x; selling that same contract lost 494,000 dollars on a thousand of premium. The full hindsight ledger. Not advice.
What was the single best options trade of June 2026, and what would a thousand dollars in it have become? The honest answer comes four times: the jackpot; the anomalous two-contract penny print its headline rests on; the nine thousand near-total losses around it; and the mirror trade, SELLING what the winner bought, where a thousand dollars of collected premium became a six-figure hole. Everything is computed AFTER the fact from the stored tape; a hindsight-optimal trade measures what the month contained, not a strategy anyone could have run. Every number is a stored query result; expand any panel for the exact SQL.
How wild a month was June 2026?
Does a hundredfold options winner need a historic market month? June says no. The panel recomputes every month of 2026 identically, regular-hours open to close, plus high-to-low range as a percent of the open, for SPY and NVDA, the winning ticket's root. June ran 21 sessions.
The exact SQL behind every number
SELECT toString(toStartOfMonth(toDate(toTimeZone(window_start, 'America/New_York')))) AS period_start,
round((argMaxIf(toFloat64(close), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS spy_month_pct,
round((maxIf(toFloat64(high), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS spy_range_pct,
round((argMaxIf(toFloat64(close), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS nvda_month_pct,
round((maxIf(toFloat64(high), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS nvda_range_pct,
uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') AS trading_days
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker IN ('SPY', 'NVDA')
AND window_start >= toDateTime('2026-01-01 05:00:00') AND window_start < toDateTime('2026-07-01 04:00:00')
GROUP BY period_start
HAVING uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') >= 17
ORDER BY period_start ASCSPY finished June -1.2% from its open inside a 5.8% range, narrower than March (8.7%) or April (11.4%). The action lived one layer down: NVDA closed -7.4% from its June open after traveling a 19.7% range (the June 2026 market recap has the market-wide picture). A hundredfold ticket needed no crash month, one large stock falling hard inside two weeks was enough.
The month's biggest multiples
The universe: every contract on six liquid roots with at least fifty June trades, 30951 contracts, priced first-June-print to last, from both chairs: what buying at the first print marked at the last, and what selling it for a thousand dollars of premium ended up owing.
The exact SQL behind every number
SELECT ticker AS contract,
substring(ticker, -9, 1) = 'P' AS is_put,
round(first_px, 2) AS first_price,
round(last_px, 2) AS last_price,
round(last_px / first_px, 1) AS multiple,
toUInt32(floor(1000 / (first_px * 100))) AS contracts_for_a_thousand,
round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS bought_end_value_usd,
round(1000 * (last_px / first_px) - 1000, 0) AS sold_net_loss_usd,
trades
FROM (
SELECT ticker,
toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
count() AS trades
FROM global_markets.options_trades
WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY ticker
HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
ORDER BY multiple DESC, contract ASC
LIMIT 5The winner was a put: O:NVDA260629P00200000, first printed at $0.01 and last printed at $4.95, a 495x multiple. Read the symbol: a $200-strike NVDA put expiring June 29. A thousand dollars at the first print bought 1000 contracts; at the last print the position marked $495000. NVDA spent the back half of June falling, its deep-dive has the slide, session by session, and this contract was that fall, leveraged. Knowing it in advance is the part no table can sell you; the first print itself gets a forensic section below.
Who else made the leaderboard
All five contracts are puts, the is_put column is the receipt, and even the smallest multiple topped tenfold. Row two, an AAPL $240 put expiring July 24, ran $0.01 to $0.34 for a 34x and was still alive at month-end (a July expiry makes that last price a mark, not a settlement). Row three, a MU $100 put expiring July 10, printed a 20x and also carried into July. Rows four and five, a TSLA $397.50 put and a QQQ $707 put both expiring June 10, made 12.5x and 11.7x on the month's opening slide. Five contracts, five bets on something falling.
Selling it: how a thousand dollars becomes minus half a million
Buying the winner risked exactly one thousand dollars. SELLING it, collecting that same thousand as premium, risked the move. The sold_net_loss_usd column runs every row from the seller's chair, ignoring margin, assignment, and forced buy-ins. Selling 1000 contracts at $0.01 collected a thousand dollars; the last print marked the position at $495000 against the seller, a net loss of $494,000. The buyer's worst case is the ticket price; the seller's worst case is the move, and June's biggest move was five hundred tickets deep.
The penny print problem
Where does the 495x come from? The receipt below compresses the winner's whole June tape into one forensic row: its first print, its second, and a census of every penny print in its life.
The exact SQL behind every number
SELECT
toString(toDate(min(sip_timestamp))) AS first_print_date,
formatDateTime(toTimeZone(min(sip_timestamp), 'America/New_York'), '%H:%i:%S') AS first_print_et,
round(anyIf(price, rn = 1), 2) AS first_price,
toUInt64(anyIf(size, rn = 1)) AS first_print_contracts,
countIf(price <= 0.011) AS penny_prints_in_june,
toUInt64(sumIf(size, price <= 0.011)) AS penny_contracts_in_june,
round(anyIf(price, rn = 2), 2) AS second_price,
toUInt32(dateDiff('second', min(sip_timestamp), anyIf(sip_timestamp, rn = 2))) AS seconds_to_second_print,
round(argMax(price, (sip_timestamp, price)), 2) AS month_last_price,
round(argMax(price, (sip_timestamp, price)) / anyIf(price, rn = 2), 1) AS second_print_multiple_to_last,
round(floor(1000 / (anyIf(price, rn = 2) * 100)) * argMax(price, (sip_timestamp, price)) * 100, 0) AS thousand_at_second_print_end_usd
FROM (
SELECT sip_timestamp, toFloat64(price) AS price, size,
row_number() OVER (ORDER BY sip_timestamp, price) AS rn
FROM global_markets.options_trades
WHERE ticker = 'O:NVDA260629P00200000'
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
)The contract did not exist on the June tape until 2026-06-15. Its first print, at 09:49:30 ET, was 2 contracts at $0.01, about two dollars of premium. The next print, 101 seconds later, was $2.44, and the penny never printed again (1 penny print, 2 contracts, all month). The thousand-contract position the headline assumes is five hundred times the size that ever traded at that price. Enter at the second print instead and a thousand dollars marked $1980 by the month's final print, a 2x, not a 495x. The ride from the second print, roughly a double in two weeks, on a violent path, was real and tradable. The jackpot, as printed, was not.
The ride: ten sessions from listing to expiry
Grant the impossible fill anyway, and hold to the end: every session the ticket traded, turnover, last price, and the position's mark.
The exact SQL behind every number
WITH (
SELECT (ticker, first_px)
FROM (
SELECT ticker,
toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
count() AS trades
FROM global_markets.options_trades
WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY ticker
HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
ORDER BY last_px / first_px DESC, ticker ASC
LIMIT 1
) AS winner
SELECT toDate(sip_timestamp) AS date,
toUInt64(sum(size)) AS contracts_traded,
round(sum(toFloat64(price) * toFloat64(size)) * 100 / 1e6, 2) AS day_premium_usd_m,
round(toFloat64(argMax(price, (sip_timestamp, price))), 2) AS day_last_price,
round(floor(1000 / (winner.2 * 100)) * toFloat64(argMax(price, (sip_timestamp, price))) * 100, 0) AS position_value_usd,
round(100 * toFloat64(argMax(price, (sip_timestamp, price))) / max(toFloat64(argMax(price, (sip_timestamp, price)))) OVER (), 1) AS pct_of_peak
FROM global_markets.options_trades
WHERE ticker = winner.1
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY date
ORDER BY date ASCThe contract printed on all 10 sessions of its life, 2026-06-15 through expiry on 2026-06-29. Day one ended at $1.4, the thousand dollars already marked at $140000 off the penny entry. Then the ride turned: a $287000 mark on 2026-06-17 shrank to $106000 by 2026-06-22, a drawdown of nearly two-thirds. The peak, $745000, came on 2026-06-26, one session before expiry; the final print marked $495000, 66.4% of the peak. Even the month's best trade finished a third below its own high. Turnover: day one traded 385 contracts all session, roughly the assumed position across the first three sessions combined, while the busiest day, 2026-06-23, did 9718 contracts and $2.86 million in premium. Size arrived only after the move was underway.
The other side of the ledger
The exact SQL behind every number
SELECT
count() AS contracts_with_50_trades,
countIf(substring(ticker, -9, 1) = 'P') AS put_contracts,
countIf(last_px / first_px >= 100) AS up_100x_plus,
countIf(last_px / first_px >= 10) AS up_10x_plus,
countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'P') AS up_10x_puts,
countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'C') AS up_10x_calls,
countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') AS down_90_calls,
round(100.0 * countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') / countIf(last_px / first_px <= 0.1), 1) AS down_90_call_share_pct,
countIf(last_px <= 0.02) AS ended_at_two_cents_or_less
FROM (
SELECT ticker,
toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
count() AS trades
FROM global_markets.options_trades
WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY ticker
HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)The exact SQL behind every number
SELECT ticker AS contract,
round(first_px, 2) AS first_price,
round(last_px, 2) AS last_price,
toUInt32(floor(1000 / (first_px * 100))) AS contracts_a_thousand_bought,
round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS ending_value_usd
FROM (
SELECT ticker,
toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
count() AS trades
FROM global_markets.options_trades
WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY ticker
HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
WHERE last_px <= 0.02 AND floor(1000 / (first_px * 100)) >= 1
ORDER BY first_px DESC, contract ASC
LIMIT 1The number that belongs next to the jackpot: of 30951 liquid contracts, exactly 1 returned a hundredfold, and 9385 lost ninety percent or more, 8949 contracts across the full universe last printed at two cents or less. Drawing blind from this deck, the ninety-percent-loss pile came up thousands of times for every jackpot. The most expensive route down: O:MU260612C01350000, a $1,350-strike MU call expiring June 12, opened June at $10 and finished at $0.01, turning a thousand dollars into $1.
Calls or puts: which side won?
The two tails do not match. The winning tail was pure put: every one of the 14 ten-baggers was a put (14 puts, 0 calls) in a universe holding 14994 puts among 30951 contracts. The losing tail was nearly even: of the 9385 near-total losses, 4403, 46.9%, were calls, with puts the slight majority. Direction picked every big winner, yet rescued nobody by itself: thousands of puts landed in the loss pile too, wrong on strike, wrong on week, or both.
Where the losses piled up
Which underlying supplied the graveyard? Not the crash name.
The exact SQL behind every number
SELECT
multiIf(startsWith(ticker, 'O:NVDA'), 'NVDA', startsWith(ticker, 'O:TSLA'), 'TSLA', startsWith(ticker, 'O:AAPL'), 'AAPL', startsWith(ticker, 'O:SPY'), 'SPY', startsWith(ticker, 'O:QQQ'), 'QQQ', 'MU') AS root,
count() AS contracts,
countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
round(100.0 * countIf(last_px / first_px <= 0.1) / count(), 1) AS pct_of_root_wiped,
round(100.0 * countIf(last_px / first_px <= 0.1) / sum(countIf(last_px / first_px <= 0.1)) OVER (), 1) AS share_of_all_down_90_pct,
countIf(last_px / first_px >= 10) AS up_10x_plus
FROM (
SELECT ticker,
toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
count() AS trades
FROM global_markets.options_trades
WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY ticker
HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
GROUP BY root
ORDER BY down_90_pct_plus DESC, root ASCQQQ supplied the biggest pile: 2923 near-total losses, 31.1% of the whole pile, with 35.7% of its liquid contracts wiped. Add SPY's 24.7% and the index roots hold over half the graveyard. The two gentlest wipe rates belong to NVDA and AAPL (21.8% and 21.8%), the first of those is NVDA, the root under the month's biggest winner. The pile grew fattest where premium sat still. The flip side, same table: QQQ produced 9 of the month's 14 ten-baggers; SPY, with 2319 contracts in the pile, produced 0.
What this table teaches (and what it can't)
Four lessons. Convexity is real: a cheap out-of-the-money option multiplies absurdly when the underlying moves fast, exactly why lottery tickets trade for pennies. Headline multiples deserve forensics: June's 495x rests on one two-lot print; the tradable ride was a double. The distribution is the price of convexity: 14 ten-baggers sit beside 9385 near-wipeouts (the market makers explainer covers who sells the tickets). And hindsight cannot be traded: the winning ticket did not exist on June 1, it first printed June 15, and buying it meant knowing, that morning, the direction and timing of the two weeks that followed. This page measures what June contained. It does not suggest what July will.
FAQ
What was the best options trade of June 2026?
Measured first print to last across six liquid roots, a $200-strike NVDA put expiring June 29, 2026: $0.01 to $4.95, a 495x multiple, resting on a two-lot penny first print (the next print was $2.44).
Can you lose more than you invest trading options?
Buying options, no: a buyer can lose at most the premium paid. Selling options, yes, June's receipt shows a seller who collected a thousand dollars of premium finishing $494,000 underwater at the final print.
Why do most cheap options expire worthless?
A cheap option prices an outcome the market considers unlikely: a large move before a near deadline. Most months deliver few such moves, and most tickets decay. In June 2026, 9385 of 30951 actively traded contracts lost at least ninety percent of their first-print value; 8949 last traded at two cents or less.
Could a real trader have captured the 495x?
Almost certainly not at the printed size: only 2 contracts ever traded at the $0.01 entry, and the price stood at $2.44 within 101 seconds. A thousand dollars at the second print marked about $1980 by the final print, a strong trade, a life-changing multiple only in hindsight.
Data notes
Full data notes
- The seller math ignores margin, assignment, and forced liquidation by design: a real short position would have been closed or assigned long before the last print. It measures the move, not a brokerage statement.
- Hindsight, not advice. Every figure is computed after the fact from stored trades.
- First print to last is a measuring stick, not an execution report; that is why these are labeled multiples, not returns.
- The penny caveat generalizes: any row with a one-cent first price (the winner; the AAPL runner-up) inherits the same fragility.
- Universe: six roots, MU, NVDA, TSLA, SPY, QQQ, AAPL, standard OCC symbols only (adjusted contracts excluded by length), ≥50 June trades, nonzero first print.
- Expiry/strike/type parse from the OCC symbol; premium math assumes the 100-share multiplier.
Methodology
- Period: June 1–30, 2026; timestamps stored UTC, filtered with raw UTC bounds. The calibration panel is the baseline block and deliberately looks back across 2026, computed identically.
- Per contract: first price = the earliest June SIP timestamp's trade, last = the latest; ties broken deterministically by price. Multiples are last over first, computed in-query.
- The daily-path panel re-derives the winner from the same ranked scan at every generation; the entry receipt pins it by symbol, with bounds that hold the post if the two disagree.
- Generation is batch-only through the gated read-only path; the page never queries live. Warehouse state as of July 12, 2026.
Every panel is one stored object, chart, table, and SQL. Interrogate the ledger yourself on the Strasmore terminal.