By Matt Connor · · Updated 2026-07-23June 2026 के सबसे अच्छे और बुरे ऑप्शंस ट्रेड
June के सबसे अच्छे options contract ने 495x का रिटर्न दिया, जबकि उसी contract को बेचने पर 494,000 dollars का नुकसान हुआ। यह पूर्ण डेटा विश्लेषण है।
जून 2026 का सबसे सफल ऑप्शंस ट्रेड कौन सा था — और इसमें लगाए गए एक हज़ार डॉलर कितने हो जाते? इसका सटीक उत्तर चार हिस्सों में है: जैकपॉट; वह असामान्य दो-कॉन्ट्रैक्ट पेनी प्रिंट जिस पर यह खबर आधारित है; इसके आसपास हुए नौ हज़ार के लगभग पूर्ण नुकसान; और मिरर ट्रेड — यानी विजेता द्वारा खरीदी गई चीज़ को बेचना — जहाँ एकत्रित प्रीमियम का एक हज़ार डॉलर छह-अंकों के घाटे में बदल गया। यह सब डेटा के आधार पर बाद में गणना किया गया है; एक hindsight-optimal ट्रेड यह मापता है कि उस महीने में क्या हुआ, न कि ऐसी कोई रणनीति जिसे कोई अपना सके। प्रत्येक संख्या एक संग्रहीत क्वेरी का परिणाम है; सटीक SQL देखने के लिए किसी भी पैनल का विस्तार करें।
June 2026 कितना उतार-चढ़ाव भरा महीना था?
क्या सौ गुना मुनाफा देने वाले options के लिए ऐतिहासिक मार्केट मंथ की आवश्यकता होती है? June ने यह साबित कर दिया कि नहीं। पैनल हर महीने के लिए 2026 का डेटा समान रूप से पुनर्गणना करता है — SPY और NVDA (जीतने वाले टिकट का आधार) के लिए, नियमित घंटों के ओपन से क्लोज तक, और ओपन के प्रतिशत के रूप में हाई-टू-लो रेंज के साथ। June में 21 सत्र हुए।
हर आंकड़े के पीछे का पूरा SQL
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 June में अपने ओपन से -1.2% पर बंद हुआ और 5.8% की रेंज के भीतर रहा — जो March (8.7%) या April (11.4%) की तुलना में कम थी। यह हलचल एक स्तर नीचे थी: NVDA अपने June ओपन से -7.4% पर बंद हुआ, जबकि इसने 19.7% की रेंज तय की (June 2026 market recap में मार्केट-व्यापी विवरण देखें])। सौ गुना मुनाफे वाले टिकट को किसी मार्केट क्रैश की आवश्यकता नहीं थी — दो सप्ताह के भीतर एक बड़े स्टॉक का भारी गिरना ही काफी था।
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.
हर आंकड़े के पीछे का पूरा SQL
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.
द पेनी प्रिंट प्रॉब्लम
495x कहाँ से आता है? नीचे दिया गया रसीद (receipt) विजेता के पूरे जून टेप को एक फोरेंसिक पंक्ति में समेट देता है: इसका पहला प्रिंट, दूसरा प्रिंट, और इसके जीवन के हर पेनी प्रिंट का डेटा।
हर आंकड़े के पीछे का पूरा SQL
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)
)जून टेप पर यह कॉन्ट्रैक्ट 2026-06-15 तक मौजूद नहीं था। 09:49:30 ET पर इसका पहला प्रिंट 2 कॉन्ट्रैक्ट्स $0.01 पर था — लगभग दो डॉलर का प्रीमियम। इसके 101 सेकंड बाद अगला प्रिंट $2.44 था, और पेनी फिर कभी प्रिंट नहीं हुआ (पूरे महीने में 1 पेनी प्रिंट, 2 कॉन्ट्रैक्ट्स)। हेडलाइन में माना गया हज़ार-कॉन्ट्रैक्ट का पोजीशन उस आकार से पांच सौ गुना बड़ा है जो उस कीमत पर कभी ट्रेड हुआ था। इसके बजाय दूसरे प्रिंट पर प्रवेश करें और महीने के अंतिम प्रिंट तक एक हज़ार डॉलर $1980 के रूप में दर्ज किया गया — जो कि 2x है, 495x नहीं। दूसरे प्रिंट से यात्रा — जो दो हफ्तों में लगभग दोगुनी हुई और एक अस्थिर मार्ग पर थी — वास्तविक और ट्रेड करने योग्य थी। प्रिंट के अनुसार जैकपॉट, वास्तविक नहीं था।
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.
हर आंकड़े के पीछे का पूरा SQL
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
हर आंकड़े के पीछे का पूरा SQL
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
)हर आंकड़े के पीछे का पूरा SQL
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.
हर आंकड़े के पीछे का पूरा SQL
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.
यह तालिका क्या सिखाती है (और क्या नहीं सिखा सकती)
चार सबक। Convexity वास्तविक है: जब underlying तेजी से हिलता है, तो एक सस्ता out-of-the-money option अत्यधिक बढ़ जाता है — यही कारण है कि lottery tickets बहुत कम कीमत पर ट्रेड होते हैं। Headline multiples का सूक्ष्म विश्लेषण आवश्यक है: जून का 495x केवल एक two-lot print पर आधारित है; वास्तविक tradable ride double थी। Distribution convexity की कीमत है: 14 ten-baggers, 9385 near-wipeouts के साथ स्थित हैं (market makers explainer में जानकारी दी गई है कि tickets कौन बेचता है)। और hindsight को ट्रेड नहीं किया जा सकता: जीतने वाली ticket 1 जून को मौजूद नहीं थी — यह पहली बार 15 जून को print हुई थी — और इसे खरीदने का अर्थ था, उस सुबह आने वाले दो हफ्तों की दिशा और timing को जानना। यह पेज जून के डेटा को मापता है। यह जुलाई के बारे में कोई सुझाव नहीं देता है।
FAQ
जून 2026 का सबसे अच्छा ऑप्शंस ट्रेड कौन सा था?
छह लिक्विड रूट्स के पहले और अंतिम प्रिंट के आधार पर, 29 जून, 2026 को समाप्त होने वाला $200-स्ट्राइक NVDA पुट: $0.01 से $4.95, जो कि 495x का मल्टीपल है — यह दो-लॉट पेनी के पहले प्रिंट पर आधारित था (अगला प्रिंट $2.44 था)।
क्या ऑप्शंस ट्रेडिंग में आप अपनी निवेशित राशि से अधिक नुकसान उठा सकते हैं?
ऑप्शंस खरीदने में नहीं: एक खरीदार अधिकतम उतना ही प्रीमियम खो सकता है जितना उसने भुगतान किया है। ऑप्शंस बेचने में, हाँ — जून के डेटा से पता चलता है कि एक विक्रेता जिसने एक हजार डॉलर का प्रीमियम प्राप्त किया था, अंतिम प्रिंट तक $494,000 के नुकसान में रहा।
अधिकांश सस्ते ऑप्शंस का मूल्य शून्य क्यों हो जाता है?
एक सस्ता ऑप्शन ऐसे परिणाम का मूल्य निर्धारित करता है जिसे बाजार असंभव मानता है: यानी समय सीमा समाप्त होने से पहले एक बड़ी हलचल। अधिकांश महीनों में ऐसी हलचलें कम ही होती हैं, और अधिकांश टिकट्स का मूल्य घट जाता है। जून 2026 में, 9385 of 30951 सक्रिय रूप से ट्रेड होने वाले कॉन्ट्रैक्ट्स ने अपने पहले प्रिंट के मूल्य का कम से कम नब्बे प्रतिशत खो दिया; 8949 का अंतिम ट्रेड दो सेंट या उससे कम पर हुआ।
क्या कोई वास्तविक ट्रेडर 495x का लाभ उठा सकता था?
प्रिंट किए गए साइज के साथ लगभग निश्चित रूप से नहीं: केवल 2 कॉन्ट्रैक्ट्स ही $0.01 के एंट्री प्राइस पर ट्रेड हुए थे, और 101 सेकंड के भीतर कीमत $2.44 पर पहुँच गई थी। दूसरे प्रिंट पर एक हजार डॉलर का मूल्य अंतिम प्रिंट तक लगभग $1980 हो गया था — यह एक मजबूत ट्रेड था, लेकिन जीवन बदलने वाला मल्टीपल केवल बाद में देखने पर ही प्रतीत होता है।
डेटा नोट्स
पूर्ण डेटा नोट्स
- सेलर मैथ (seller math) जानबूझकर मार्जिन, असाइनमेंट और फोर्स्ड लिक्विडेशन को नजरअंदाज करता है: एक वास्तविक शॉर्ट पोजीशन अंतिम प्रिंट से बहुत पहले ही बंद या असाइन हो चुकी होती। यह केवल मूवमेंट को मापता है, ब्रोकरेज स्टेटमेंट को नहीं।
- यह पूर्वव्यापी जानकारी है, सलाह नहीं। प्रत्येक आंकड़े की गणना पिछले ट्रेडों के आधार पर की जाती है।
- पहला प्रिंट से अंतिम प्रिंट तक का माप एक मानक है, निष्पादन रिपोर्ट नहीं; इसीलिए इन्हें मल्टीपल्स (multiples) कहा जाता है, रिटर्न (returns) नहीं।
- पेनी चेतावनी (penny caveat) सामान्य है: जिस भी पंक्ति में एक-सेंट का पहला मूल्य है (विजेता; AAPL रनर-अप), वह समान अस्थिरता का सामना करती है।
- यूनिवर्स (Universe): छह रूट्स — MU, NVDA, TSLA, SPY, QQQ, AAPL — केवल मानक OCC सिंबल (लंबाई के कारण एडजस्टेड कॉन्ट्रैक्ट्स शामिल नहीं हैं), ≥50 जून ट्रेड, गैर-शून्य पहला प्रिंट।
कार्यप्रणाली
- अवधि: 1–30 जून, 2026; टाइमस्टैम्प UTC में संग्रहीत हैं, जिन्हें कच्चे UTC सीमाओं के साथ फ़िल्टर किया गया है। कैलिब्रेशन पैनल बेसलाइन ब्लॉक है और जानबूझकर 2026 के दौरान का डेटा देखता है, जिसकी गणना समान रूप से की गई है।
- प्रति अनुबंध: पहला मूल्य = जून SIP टाइमस्टैम्प का सबसे पहले होने वाला ट्रेड, अंतिम = सबसे बाद वाला; बराबरी होने पर मूल्य के आधार पर नियत रूप से निर्णय लिया जाता है। मल्टीपल्स में 'last over first' का उपयोग किया जाता है, जिसकी गणना क्वेरी के भीतर की जाती है।
- डेली-पाथ पैनल प्रत्येक जनरेशन में उसी रैंक किए गए स्कैन से विजेता को पुन: प्राप्त करता है; एंट्री रसीद इसे सिंबल द्वारा पिन करती है, जिसमें ऐसी सीमाएं होती हैं जो तब लागू होती हैं जब दोनों में असहमति हो।
- जनरेशन केवल गेटेड रीड-ओनली पाथ के माध्यम से बैच-आधारित है; पेज कभी भी लाइव क्वेरी नहीं करता है। 12 जुलाई, 2026 तक वेयरहाउस की स्थिति।
प्रत्येक पैनल एक संग्रहीत ऑब्जेक्ट है — चार्ट, टेबल और SQL। Strasmore टर्मिनल पर स्वयं लेजर की जांच करें।