Strasmore Research
Deep Dives · Matt ConnorBy Matt Connor · · Updated 2026-08-03

जून 2026 के सबसे अच्छे और बुरे एक हजार डॉलर

जून में सबसे अच्छे options contract ने 495x रिटर्न दिया; वही contract बेचने पर एक हजार डॉलर के premium पर 494,000 डॉलर का नुकसान होता। पूरा hindsight ledger। सलाह नहीं।

जून 2026 का सबसे लाभदायक single options trade कौन-सा था, और उसमें लगाए गए एक हजार डॉलर का क्या हुआ होता? ईमानदार उत्तर चार हिस्सों में आता है: jackpot; वह असामान्य two-contract penny print, जिस पर इसकी headline आधारित है; इसके आसपास हुए लगभग नौ हजार near-total losses; और mirror trade—winner ने जो खरीदा, उसे बेचने पर—जिसमें एक हजार डॉलर का प्राप्त premium छह अंकों के नुकसान में बदल गया। हर गणना stored tape के आधार पर AFTER the fact की गई है। hindsight-optimal trade यह मापता है कि उस महीने में क्या हुआ, न कि ऐसी रणनीति जिसे कोई पहले से चला सकता था। हर संख्या stored query का परिणाम है। सटीक SQL देखने के लिए किसी भी panel को expand करें।

जून 2026 का महीना कितना अस्थिर रहा?

क्या options में सौ गुना लाभ के लिए बाजार का ऐतिहासिक महीना जरूरी होता है? जून का जवाब है—नहीं। पैनल 2026 के हर महीने की एक समान गणना करता है: नियमित कारोबारी घंटों के open से close तक का बदलाव, साथ ही open के प्रतिशत के रूप में high-to-low range। यह गणना SPY और NVDA के लिए की गई है, जो जीतने वाले ticket का root है। जून में 21 सत्र हुए।

क्वेरीआधार माह संदर्भ: 2026 के प्रत्येक माह की समान गणना, SPY और NVDA, ओपन-टू-क्लोज़ और रेंज
अवधि प्रारंभSPY माह %SPY परास %NVDA माह %NVDA परास %ट्रेडिंग दिवस
2026-01-010.93.10.88.920
2026-02-01-0.53.1-5.414.219
2026-03-01-4.28.7-0.414.122
2026-04-019.911.413.425.821
2026-05-014.964.920.820
2026-06-01-1.25.8-7.419.721
हर आंकड़े के पीछे का पूरा 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 ASC
इसे खुद चलाएँ

SPY जून में अपने open से -1.2% ऊपर या नीचे बंद हुआ और उसकी range 5.8% रही। यह मार्च (8.7%) या अप्रैल (11.4%) से संकरी थी। असली हलचल एक स्तर नीचे थी: NVDA अपने जून open से -7.4% ऊपर या नीचे बंद हुआ, जबकि इस दौरान उसकी range 19.7% रही (जून 2026 के बाजार का सारांश में पूरे बाजार की तस्वीर दी गई है)। सौ गुना लाभ वाले ticket के लिए बाजार का धराशायी होना जरूरी नहीं था; दो सप्ताह के भीतर किसी एक बड़े शेयर का तेज गिरना ही पर्याप्त था।

महीने के सबसे बड़े multiples

दायरा: छह liquid roots पर मौजूद हर contract, जिसमें जून में कम-से-कम fifty trades हुए, 30951 contracts। कीमतें जून के पहले print से आखिरी print तक ली गईं। दोनों दृष्टिकोण शामिल हैं: पहले print पर खरीदकर आखिरी print पर mark करने से क्या मिलता, और एक हजार डॉलर के premium पर बेचने के बाद कितनी देनदारी बनती।

क्वेरीजून के पहले प्रिंट से अंतिम प्रिंट तक के पाँच सबसे बड़े गुणक, दोनों पक्षों से मूल्यांकित (छह लिक्विड रूट, 50+ ट्रेड)
कॉन्ट्रैक्टपुट हैप्रथम मूल्यअंतिम मूल्यगुणकएक हज़ार के लिए कॉन्ट्रैक्टखरीदा गया अंतिम मूल्य ($)बेची गई शुद्ध हानि ($)ट्रेड
O:NVDA260629P0020000010.014.9549510004950004940004650
O:AAPL260724P0024000010.010.343410003400033000119
O:MU260710P0010000010.05120200200001900081
O:TSLA260610P0039750011.2815.9512.57111651146110801
O:QQQ260610P0070700011.2614.7411.77103181069814669
हर आंकड़े के पीछे का पूरा 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 5
इसे खुद चलाएँ

विजेता एक put था: O:NVDA260629P00200000, जिसका पहला print $0.01 और आखिरी print $4.95 था। यह 495x multiple रहा। Symbol को पढ़िए: यह $200-strike वाला NVDA put है, जिसकी expiry June 29 है। पहले print पर एक हजार डॉलर से 1000 contracts खरीदे जा सकते थे। आखिरी print पर उस position का मूल्य $495000 था। जून के दूसरे हिस्से में NVDA लगातार गिरा। उसका विस्तृत विश्लेषण session-दर-session यह गिरावट दिखाता है। यह contract उसी गिरावट का leveraged रूप था। इसे पहले से जान पाना ऐसी चीज है जिसे कोई table आपको नहीं दे सकती। पहले print पर नीचे एक अलग forensic section है।

leaderboard में और कौन शामिल रहा

सभी five contracts puts हैं। is_put column प्राप्त premium दिखाता है। सबसे छोटा multiple भी tenfold से अधिक रहा। दूसरे स्थान पर AAPL का $240 put था, जिसकी expiry July 24 थी। इसका भाव $0.01 से बढ़कर $0.34 हुआ और multiple 34x रहा। यह महीने के अंत में भी खुला था। July expiry होने के कारण आखिरी price settlement नहीं, बल्कि mark है। तीसरे स्थान पर MU का $100 put था, जिसकी expiry July 10 थी। इसका multiple 20x रहा और यह भी July तक खुला रहा। चौथे और पांचवें स्थान पर TSLA का $397.50 put और QQQ का $707 put था, दोनों की expiry June 10 थी। महीने की शुरुआती गिरावट में उन्होंने क्रमशः 12.5x और 11.7x बनाए। Five contracts, और गिरावट पर five bets।

इसे बेचना: कैसे एक हजार डॉलर माइनस आधा मिलियन बन जाते हैं

विजेता को खरीदने में जोखिम ठीक एक हजार डॉलर का था। उसे बेचने में, वही एक हजार डॉलर premium के रूप में लेकर, पूरे price move का जोखिम था। sold_net_loss_usd कॉलम विक्रेता के दृष्टिकोण से हर पंक्ति का हिसाब लगाता है और margin, assignment तथा forced buy-ins को नज़रअंदाज़ करता है। 1000 contracts को $0.01 पर बेचने से एक हजार डॉलर मिले; अंतिम print ने विक्रेता के विरुद्ध पोजीशन का मूल्य $495000 दिखाया, जिससे शुद्ध नुकसान $494,000 हुआ। खरीदार का अधिकतम नुकसान ticket price तक सीमित है; विक्रेता का अधिकतम नुकसान पूरे price move तक हो सकता है, और जून का सबसे बड़ा move पांच सौ tickets तक गया।

एक सेंट वाले ट्रेड की समस्या

495x कहाँ से आया? नीचे दी गई रसीद विजेता के पूरे जून के ट्रेडिंग रिकॉर्ड को एक फॉरेंसिक पंक्ति में समेटती है: उसका पहला प्रिंट, दूसरा प्रिंट और उसके पूरे जीवनकाल में हुए हर एक-सेंट वाले प्रिंट की गणना।

क्वेरीप्रवेश रसीद: विजेता का पहला प्रिंट, दूसरा प्रिंट और जून में उसके हर पेनी प्रिंट (एक पंक्ति)
प्रथम प्रिंट तिथिप्रथम प्रिंट ETप्रथम मूल्यप्रथम प्रिंट कॉन्ट्रैक्टजून में पेनी प्रिंटजून में पेनी कॉन्ट्रैक्टद्वितीय मूल्यद्वितीय प्रिंट तक सेकंडमाह का अंतिम मूल्यद्वितीय प्रिंट से अंतिम तक गुणकद्वितीय प्रिंट के अंत में एक हज़ार ($)
2026-06-1509:49:300.012122.441014.9521980
हर आंकड़े के पीछे का पूरा 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 पर था, यानी premium लगभग दो डॉलर था। इसके 101 सेकंड बाद आया अगला प्रिंट $2.44 था, और उसके बाद वह एक-सेंट कीमत फिर कभी प्रिंट नहीं हुई (पूरे महीने में 1 एक-सेंट प्रिंट, 2 कॉन्ट्रैक्ट)। हेडलाइन में मानी गई एक हजार कॉन्ट्रैक्ट की पोजीशन उस कीमत पर वास्तव में ट्रेड हुए आकार से पांच सौ गुना बड़ी है। इसके बजाय दूसरे प्रिंट पर प्रवेश करने पर, महीने के अंतिम प्रिंट तक $1980 के रूप में चिह्नित एक हजार डॉलर 2x बनते, 495x नहीं। दूसरे प्रिंट से मिली बढ़त—दो सप्ताह में लगभग दोगुनी, हालांकि बेहद अस्थिर रास्ते से—वास्तविक और ट्रेड करने योग्य थी। लेकिन जैसा प्रिंट हुआ, वह जैकपॉट वास्तविक नहीं था।

उतार-चढ़ाव: लिस्टिंग से एक्सपायरी तक दस सत्र

असंभव fill को भी मान लें और अंत तक पोजीशन बनाए रखें: हर सत्र में टिकट का कारोबार हुआ, turnover, अंतिम कीमत और पोजीशन का mark दर्ज करें।

क्वेरीसत्र-दर-सत्र यात्रा: दैनिक टर्नओवर, अंतिम मूल्य और $1,000 पोज़िशन का मार्क
तिथिट्रेड किए गए कॉन्ट्रैक्टदैनिक प्रीमियम ($M)दिन का अंतिम मूल्यपोज़िशन मूल्य ($)शिखर का %
2026-06-153850.061.414000018.8
2026-06-163430.062.1921900029.4
2026-06-173340.082.8728700038.5
2026-06-1811770.161.2712700017
2026-06-2245050.411.0610600014.2
2026-06-2397182.863.636000048.3
2026-06-2431141.034.3343300058.1
2026-06-2547802.945.2552500070.5
2026-06-2638152.437.45745000100
2026-06-2917171.084.9549500066.4
हर आंकड़े के पीछे का पूरा 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 ASC
इसे खुद चलाएँ

कॉन्ट्रैक्ट अपने जीवन के सभी 10 सत्रों में ट्रेड हुआ। यह 2026-06-15 से शुरू होकर 2026-06-29 को expiry तक चला। पहले दिन का समापन $1.4 पर हुआ। यानी thousand-dollar पोजीशन को cent स्तर की शुरुआती कीमत से ही $140000 पर mark किया गया। इसके बाद रुख बदल गया। 2026-06-17 को $287000 का mark घटकर 2026-06-22 तक $106000 रह गया। यह लगभग two-thirds की गिरावट थी। सबसे ऊंचा स्तर, $745000, 2026-06-26 को आया। यह expiry से एक सत्र पहले था। अंतिम print में $495000 दर्ज हुआ, जो peak का 66.4% था। महीने का सबसे अच्छा ट्रेड भी अपने उच्चतम स्तर से एक-third नीचे समाप्त हुआ। Turnover के लिहाज से, पहले दिन पूरे सत्र में 385 contracts का कारोबार हुआ। यह पहले three sessions में संयुक्त रूप से मानी गई पोजीशन के लगभग बराबर था। सबसे व्यस्त दिन 2026-06-23 रहा। उस दिन 9718 contracts का कारोबार हुआ और premium में $2.86 million दर्ज हुए। बड़ी मात्रा में कारोबार तभी आया, जब यह move शुरू हो चुका था।

लेजर का दूसरा पक्ष

क्वेरीपूर्ण वितरण: हर जैकपॉट के लिए हज़ारों लगभग पूर्ण नुकसान (पुट/कॉल विभाजन सहित)
50 ट्रेड वाले कॉन्ट्रैक्टपुट कॉन्ट्रैक्ट100x से अधिक वृद्धि10x से अधिक वृद्धि10 गुना बढ़े Puts10 गुना बढ़े Calls90% या अधिक गिरे90% गिरे Calls90% गिरे Calls का हिस्सा (%)दो सेंट या कम पर समाप्त
30951149941141409385440346.98949
हर आंकड़े के पीछे का पूरा 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
)
इसे खुद चलाएँ
क्वेरीशून्य तक का सबसे महँगा टिकट: समाप्ति पर दो सेंट या उससे कम वाला सबसे महँगा कॉन्ट्रैक्ट
कॉन्ट्रैक्टप्रथम मूल्यअंतिम मूल्यखरीदे गए Contracts (हज़ारों में)अंतिम मूल्य (USD)
O:MU260612C01350000100.0111
हर आंकड़े के पीछे का पूरा 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 1
इसे खुद चलाएँ

जैकपॉट के सामने रखा जाने वाला आंकड़ा: 30951 लिक्विड कॉन्ट्रैक्ट्स में से ठीक 1 ने सौ गुना रिटर्न दिया, जबकि 9385 में नब्बे प्रतिशत या उससे अधिक की गिरावट आई। पूरे यूनिवर्स में 8949 कॉन्ट्रैक्ट्स का अंतिम भाव दो सेंट या उससे कम था। इस समूह में से बिना किसी चयन के कॉन्ट्रैक्ट चुनने पर, हर जैकपॉट के मुकाबले नब्बे प्रतिशत नुकसान वाला समूह हजारों बार सामने आया। नीचे जाने का सबसे महंगा रास्ता: O:MU260612C01350000। $1,350 स्ट्राइक वाला MU call, जिसकी expiry 12 जून थी, जून की शुरुआत में $10 पर खुला और $0.01 पर बंद हुआ। इससे एक हजार डॉलर घटकर $1 रह गए।

Calls या puts: किस पक्ष की जीत हुई?

दोनों छोर एक जैसे नहीं थे। जीतने वाला छोर पूरी तरह put का था: 14 ten-baggers में से हर एक put था (14 puts, 0 calls), जबकि 14994 कॉन्ट्रैक्ट्स वाले यूनिवर्स में 30951 puts थे। लगभग पूरी तरह नुकसान वाले छोर पर स्थिति लगभग बराबर थी: 9385 लगभग पूर्ण नुकसान वाले कॉन्ट्रैक्ट्स में से 4403, 46.9%, calls थे और puts मामूली बहुमत में थे। दिशा ने हर बड़े विजेता का चयन किया, लेकिन अकेले किसी को नहीं बचाया: हजारों puts भी नुकसान वाले समूह में पहुंचे, क्योंकि स्ट्राइक गलत था, सप्ताह गलत था, या दोनों गलत थे।

नुकसान कहां जमा हुआ

किस अंतर्निहित एसेट ने यह कब्रिस्तान बनाया? वह crash name नहीं था।

क्वेरीरूट के अनुसार नुकसान का ढेर: पहले प्रिंट से 90%+ नीचे कॉन्ट्रैक्ट, ढेर में हिस्सा और प्रत्येक रूट के टेन-बैगर
RootContracts90% या अधिक गिरेRoot का मिटा हिस्सा (%)सभी 90% गिरे शेयरों का हिस्सा10x से अधिक वृद्धि
QQQ8199292335.731.19
SPY7460231931.124.70
MU5652166029.417.72
TSLA4527136830.214.61
NVDA307867121.87.11
AAPL203544421.84.71
हर आंकड़े के पीछे का पूरा 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 ASC
इसे खुद चलाएँ

QQQ ने सबसे बड़ा समूह बनाया: लगभग पूर्ण नुकसान वाले 2923 कॉन्ट्रैक्ट्स, जो पूरे समूह का 31.1% थे। उसके लिक्विड कॉन्ट्रैक्ट्स में से 35.7% समाप्त हो गए। SPY के 24.7% को जोड़ने पर index roots इस कब्रिस्तान के आधे से अधिक हिस्से में हैं। सबसे कम wipe rates NVDA और AAPL के थे (21.8% और 21.8%)। इनमें पहला NVDA है, जो महीने के सबसे बड़े विजेता के पीछे का root था। जहां premium स्थिर रहा, वहां यह समूह सबसे बड़ा हुआ। इसी तालिका का दूसरा पक्ष: QQQ ने महीने के 14 ten-baggers में से 9 दिए। समूह में 2319 कॉन्ट्रैक्ट्स वाले SPY ने 0 ten-baggers दिए।

यह तालिका क्या सिखाती है (और क्या नहीं सिखा सकती)

चार बातें स्पष्ट होती हैं। Convexity वास्तविक है: जब अंतर्निहित परिसंपत्ति तेजी से चलती है, तो सस्ता out-of-the-money option कई गुना बढ़ सकता है। यही कारण है कि lottery tickets कुछ पैसों में trade होते हैं। Headline multiples की फॉरेंसिक जांच जरूरी है: जून का 495x केवल two-lot print पर आधारित है; जिस राइड में वास्तव में trade किया जा सकता था, वह दो गुना रही। Convexity की कीमत distribution के रूप में दिखती है: 14 ten-baggers के साथ 9385 लगभग पूरी तरह समाप्त हो जाने वाले विकल्प भी मौजूद हैं (यह market makers की व्याख्या बताती है कि ये टिकट कौन बेचता है)। और hindsight पर trade नहीं किया जा सकता: winning ticket 1 जून को मौजूद नहीं था। वह पहली बार 15 जून को print हुआ। उसे खरीदने का अर्थ था उसी सुबह यह जानना कि उसके बाद के दो सप्ताह में दिशा और समय क्या होगा। यह पेज बताता है कि जून में क्या हुआ। यह जुलाई के बारे में कोई सुझाव नहीं देता।

FAQ

जून 2026 का सबसे अच्छा options trade कौन-सा था?

छह liquid roots में पहले print से आखिरी print तक मापने पर, 29 जून 2026 को expire होने वाला $200-strike NVDA put: $0.01 से $4.95 तक, यानी 495x multiple। यह two-lot penny first print पर आधारित था। अगला print $2.44 था।

क्या options trading में आप अपने निवेश से अधिक गंवा सकते हैं?

Options खरीदने पर नहीं। खरीदार अधिकतम भुगतान किए गए premium तक ही गंवा सकता है। Options बेचने पर हाँ। जून के receipt में एक ऐसे seller का उदाहरण है जिसने एक हजार डॉलर का premium प्राप्त किया, लेकिन अंतिम print पर $494,000 के नुकसान में था।

अधिकांश सस्ते options बेकार क्यों expire हो जाते हैं?

सस्ता option ऐसे परिणाम की कीमत तय करता है जिसे बाजार कम संभावित मानता है: निकट समय-सीमा से पहले बड़ी price move। अधिकांश महीनों में ऐसी moves कम होती हैं और अधिकांश tickets का मूल्य समय के साथ घटता जाता है। जून 2026 में, सक्रिय रूप से कारोबार किए गए 30951 contracts में से 9385 ने अपने first-print value का कम-से-कम ninety percent खो दिया; 8949 का last trade two cents या उससे कम पर हुआ।

क्या कोई वास्तविक trader 495x हासिल कर सकता था?

मुद्रित size पर लगभग निश्चित रूप से नहीं। $0.01 entry पर केवल 2 contracts में trade हुआ और 101 seconds के भीतर कीमत $2.44 हो गई। दूसरे print पर एक हजार डॉलर का निवेश अंतिम print तक लगभग $1980 का हो गया था। यह एक मजबूत trade था, लेकिन life-changing multiple केवल hindsight में दिखाई देता है।

डेटा नोट्स

पूरी डेटा नोट्स
  • डिज़ाइन के अनुसार seller math में margin, assignment और forced liquidation शामिल नहीं हैं: वास्तविक short position को आखिरी print से काफी पहले बंद या assign किया जा चुका होता। यह केवल price move को मापता है, brokerage statement को नहीं।
  • यह hindsight है, सलाह नहीं। हर आंकड़ा stored trades से बाद में निकाला गया है।
  • पहले print से आखिरी print तक का अंतर केवल measuring stick है, execution report नहीं; इसी कारण इन्हें returns नहीं, multiples कहा गया है।
  • एक penny वाली चेतावनी सामान्य रूप से लागू होती है: जिस भी row में पहली कीमत one cent है, उस पर यही fragility लागू होती है—winner और AAPL runner-up पर भी।
  • Universe: छह roots—MU, NVDA, TSLA, SPY, QQQ, AAPL—केवल standard OCC symbols (लंबाई के कारण adjusted contracts शामिल नहीं), ≥50 June trades, और nonzero first print।
  • Expiry, strike और type की जानकारी OCC symbol से parse की गई है; premium math में 100-share multiplier मान लिया गया है।

कार्यप्रणाली

  • अवधि: 1–30 जून, 2026; timestamps UTC में संग्रहीत हैं और raw UTC bounds से फ़िल्टर किए गए हैं। Calibration panel baseline block है और जानबूझकर 2026 की पूरी अवधि पर पीछे जाकर डेटा देखता है। इसकी गणना भी इसी प्रक्रिया से की गई है।
  • प्रत्येक contract के लिए: पहला price जून के SIP timestamps में दर्ज सबसे पहला trade है और अंतिम price सबसे आखिरी trade है। समानता की स्थिति में price के आधार पर deterministic रूप से चयन किया गया है। Multiples अंतिम price को पहले price से भाग देकर निकाले गए हैं और query के भीतर ही गणना की गई है।
  • Daily-path panel हर generation पर उसी ranked scan से winner दोबारा निर्धारित करता है। Entry receipt उसे symbol के आधार पर स्थिर करता है। यदि दोनों में असहमति हो, तो bounds post को बनाए रखते हैं।
  • Generation केवल gated read-only path के माध्यम से batch mode में होती है। पेज कभी live query नहीं करता। Warehouse state 12 जुलाई, 2026 तक की है।

हर panel एक stored object, chart, table और SQL से बना है। Strasmore terminal पर ledger की स्वयं जाँच करें।

#ऑप्शंस#hindsight#convexity#risk#deepdive