Strasmore Research
Deep Dives · Matt ConnorBy Matt Connor · · Updated 2026-07-23

Melhor e pior mil dólares de junho de 2026

O melhor contrato de opções rendeu 495x enquanto a venda do mesmo ticker gerou prejuízo de 494,000 dólares por mil de prêmio. Análise retrospectiva.

Qual foi a melhor operação de opções de junho de 2026 — e quanto mil dólares teriam rendido? A resposta honesta apresenta quatro cenários: o jackpot; a anomalia de dois contratos de um centavo que gera a manchete; os nove mil casos de perdas quase totais ao redor; e a operação espelho — VENDER o que o vencedor comprou — onde mil dólares em prêmios coletados tornaram-se um prejuízo de seis dígitos. Tudo é calculado APÓS o evento, com base no histórico de negociações; uma operação otimizada retrospectivamente mede o que o mês ofereceu, não uma estratégia que alguém poderia ter executado. Cada número é o resultado de uma consulta armazenada; expanda qualquer painel para ver o SQL exato.

O quão volátil foi o mês de junho de 2026?

Um vencedor de opções com retorno de cem vezes exige um mês histórico no mercado? Junho mostra que não. O painel recalcula cada mês de 2026 de forma idêntica — da abertura ao fechamento em horário regular, somado à variação entre máxima e mínima como percentual da abertura — para SPY e NVDA, a base do bilhete vencedor. Junho teve 21 sessões.

QueryCalibração: todos os meses de 2026 calculados de forma idêntica — SPY e NVDA, open-to-close e range
O SQL exato por trás de cada número
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

O SPY encerrou junho a -1.2% de sua abertura dentro de um range de 5.8% — mais estreito que março (8.7%) ou abril (11.4%). O movimento ocorreu em um nível inferior: a NVDA fechou a -7.4% de sua abertura de junho após percorrer um range de 19.7% (o resumo do mercado de junho de 2026 apresenta o panorama geral do mercado). Um bilhete de cem vezes não precisou de um mês de crash — a queda acentuada de uma única ação em duas semanas foi suficiente.

Os maiores múltiplos do mês

O universo: todos os contratos de seis ativos líquidos com pelo menos cinquenta negociações em junho — 30951 contratos — com preços do primeiro ao último registro de junho, em ambos os lados: quanto a compra no primeiro registro rendeu no último, e quanto a venda por mil dólares de prêmio resultou em prejuízo.

QueryOs cinco maiores múltiplos (first-to-last print) de junho, precificados por ambos os lados (6 roots líquidas, 50+ trades)
O SQL exato por trás de cada número
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

A vencedora foi uma put: O:NVDA260629P00200000, negociada inicialmente a $0.01 e por último a $4.95 — um múltiplo de 495x. Analise o ticker: uma put de NVDA com strike de $200 vencendo em 29 de junho. Mil dólares no primeiro registro compraram 1000 contratos; no último registro, a posição valia $495000. A NVDA caiu na segunda metade de junho — sua queda detalhada mostra o declínio, sessão por sessão — e este contrato foi essa queda, alavancada. Prever isso com antecedência é algo que nenhuma tabela pode vender; o primeiro registro possui uma seção de análise detalhada abaixo.

Outros destaques do ranking

Todos os cinco contratos são puts — a coluna is_put é o comprovante — e mesmo o menor múltiplo superou dez vezes o valor inicial. A segunda linha, uma put de AAPL com strike de $240 vencendo em 24 de julho, subiu de $0.01 para $0.34, um múltiplo de 34x, e ainda estava ativa no fim do mês (o vencimento em julho faz com que esse último preço seja uma marcação, não um settlement). A terceira linha, uma put de MU com strike de $100 vencendo em 10 de julho, registrou 20x e também seguiu para julho. As linhas quatro e cinco, uma put de TSLA com strike de $397.50 e uma put de QQQ com strike de $707, ambas vencendo em 10 de junho, renderam 12.5x e 11.7x na queda inicial do mês. Cinco contratos, cinco apostas em queda.

Vendendo a posição: como mil dólares se tornam um prejuízo de meio milhão

Comprar o ativo vencedor arriscava exatamente mil dólares. VENDÊ-lo — coletando esses mesmos mil dólares como prêmio — arriscava a oscilação do preço. A coluna sold_net_loss_usd apresenta cada linha sob a perspectiva do vendedor, desconsiderando margem, exercício e compras compulsórias. A venda de 1000 contratos a $0.01 coletou mil dólares; a última cotação marcou a posição em $495000 para o vendedor — um prejuízo líquido de $494,000. O pior cenário para o comprador é o preço do contrato; o pior cenário para o vendedor é a oscilação do preço, e a maior oscilação de junho foi de quinhentos contratos de profundidade.

O problema do penny print

De onde vem o multiplicador de 495x? O comprovante abaixo condensa todo o histórico de negociações de junho do vencedor em uma única linha forense: sua primeira execução, a segunda e um censo de cada penny print de sua vida.

QueryO histórico de entrada: o primeiro print do vencedor, o segundo e cada centavo do seu movimento em junho (uma linha)
O SQL exato por trás de cada número
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)
)

O contrato não constava no histórico de junho até 2026-06-15. Sua primeira execução, às 09:49:30 ET, foi de 2 contratos a $0.01 — cerca de dois dólares de prêmio. A execução seguinte, 101 segundos depois, foi de $2.44, e o penny nunca mais foi negociado (1 penny print, 2 contratos, durante todo o mês). A posição de mil contratos que a manchete assume é quinhentas vezes maior do que o volume que já foi negociado naquele preço. Se a entrada fosse na segunda execução, mil dólares teriam atingido $1980 na última negociação do mês — um retorno de 2x, não de 495x. A valorização a partir da segunda execução — aproximadamente o dobro em duas semanas, com alta volatilidade — foi real e negociável. O jackpot, conforme registrado, não foi.

O percurso: dez sessões do listagem ao vencimento

Considere o preenchimento impossível de qualquer forma e mantenha até o fim: cada sessão o ticket foi negociado — turnover, último preço e o mark do position.

QueryO percurso, sessão a sessão: turnover diário, último preço e a marca da posição de mil dólares
O SQL exato por trás de cada número
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

O contrato foi registrado em todas as 10 sessões de sua vida, de 2026-06-15 até o vencimento em 2026-06-29. O primeiro dia encerrou a $1.4, com o mil dólares já marcado a $140000 de distância do preço de entrada. Então o movimento mudou: um mark de $287000 em 2026-06-17 encolheu para $106000 em 2026-06-22, um drawdown de quase dois terços. O pico, $745000, ocorreu em 2026-06-26, uma sessão antes do vencimento; o registro final marcou $495000 — 66.4% do pico. Mesmo a melhor operação do mês terminou um terço abaixo de sua própria máxima. Turnover: o primeiro dia negociou 385 contratos durante toda a sessão — aproximadamente o position assumido somando as três primeiras sessões — enquanto o dia de maior volume, 2026-06-23, fez 9718 contratos e $2.86 milhões em prêmio. O tamanho do position surgiu apenas após o movimento estar em curso.

O outro lado do balanço

QueryDistribuição completa: para cada jackpot, milhares de perdas quase totais (incluindo split put/call)
O SQL exato por trás de cada número
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
)
QueryO ticket mais caro para o zero: o contrato mais caro que encerrou a dois centavos ou menos
O SQL exato por trás de cada número
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

O número que acompanha o jackpot: de 30951 contratos líquidos, exatamente 1 retornaram cem vezes o capital — e 9385 perderam noventa por cento ou mais, com 8949 contratos de todo o universo registrando o último preço de dois centavos ou menos. Ao escolher aleatoriamente neste conjunto, o grupo de noventa por cento de perda apareceu milhares de vezes para cada jackpot. A rota de perda mais cara: O:MU260612C01350000, uma call de MU com strike de $1.350 vencendo em 12 de junho, abriu em junho a $10 e fechou a $0.01, transformando mil dólares em $1.

Calls ou puts: qual lado venceu?

Os dois extremos não são iguais. O lado vencedor foi composto apenas por puts: cada um dos 14 ten-baggers era uma put (14 puts, 0 calls) em um universo que continha 14994 puts entre 30951 contratos. O lado perdedor foi quase equilibrado: dos 9385 de perdas quase totais, 4403 — 46.9% — eram calls, com as puts tendo uma leve maioria. A direção acertou todos os grandes vencedores, mas não salvou ninguém sozinha: milhares de puts também acabaram no grupo de perdas, por erro de strike, erro de semana ou ambos.

Onde as perdas se acumularam

Qual ativo subjacente forneceu o cemitério? Não foi o nome do crash.

QueryAcúmulo de perdas por root: contratos com queda de 90%+ desde o primeiro print, share do total e ten-baggers de cada root
O SQL exato por trás de cada número
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 forneceu o maior volume: 2923 de perdas quase totais — 31.1% de todo o grupo — com 35.7% de seus contratos líquidos zerados. Somando os 24.7% do SPY, os índices representam mais da metade do cemitério. As duas menores taxas de perda pertencem a NVDA e AAPL (21.8% e 21.8%) — o primeiro deles é NVDA, o subjacente do maior vencedor do mês. O volume de perdas cresceu mais onde o prêmio ficou estagnado. O lado oposto, na mesma tabela: QQQ produziu 9 dos 14 ten-baggers do mês; o SPY, com 2319 contratos no grupo de perdas, produziu 0.

O que esta tabela ensina (e o que não ensina)

Quatro lições. A convexidade é real: uma opção out-of-the-money barata multiplica seu valor absurdamente quando o ativo subjacente se move rápido — exatamente por isso bilhetes de loteria são negociados por centavos. Múltiplos de manchete exigem análise detalhada: o 495x de junho baseia-se em um único registro de dois lotes; o retorno negociável foi de dois. A distribuição é o preço da convexidade: 14 multiplicadores de dez vezes estão ao lado de 9385 perdas quase totais (o explicativo sobre market makers detalha quem vende os bilhetes). E o retrospecto não pode ser negociado: o bilhete vencedor não existia em 1º de junho — ele só foi registrado em 15 de junho — e comprá-lo significaria saber, naquela manhã, a direção e o tempo das duas semanas seguintes. Esta página mede o que junho apresentou. Ela não sugere o que julho trará.

FAQ

Qual foi a melhor operação de opções de junho de 2026?

Medindo da primeira para a última cotação em seis ativos líquidos, uma put de NVDA com strike de $200 vencendo em 29 de junho de 2026: $0.01 a $4.95, um múltiplo de 495x — baseada em uma primeira cotação de um lote de um centavo (a cotação seguinte foi $2.44).

É possível perder mais do que o valor investido ao negociar opções?

Comprando opções, não: o comprador pode perder, no máximo, o prêmio pago. Vendendo opções, sim — o registro de junho mostra um vendedor que coletou mil dólares de prêmio e terminou com um prejuízo de $494,000 na última cotação.

Por que a maioria das opções baratas expira sem valor?

Uma opção barata precifica um cenário que o mercado considera improvável: um movimento grande antes de um prazo próximo. A maioria dos meses apresenta poucos movimentos desse tipo, e a maioria dos contratos sofre o efeito do tempo (decay). Em junho de 2026, 9385 de 30951 contratos negociados perderam pelo menos noventa por cento de seu valor inicial; 8949 negociaram pela última vez a dois centavos ou menos.

Um trader real poderia ter capturado o 495x?

Quase certamente não no tamanho negociado: apenas 2 contratos chegaram a negociar no preço de entrada de $0.01, e o preço atingiu $2.44 em 101 segundos. Mil dólares na segunda cotação representariam cerca de $1980 na cotação final — uma operação forte, mas o múltiplo transformador só é visível em retrospecto.

Notas dos dados

Notas completas dos dados
  • O cálculo do vendedor ignora margem, atribuição e liquidação forçada por design: uma posição vendida real teria sido encerrada ou atribuída muito antes do último registro. O objetivo é medir o movimento, não um extrato de corretora.
  • Análise retrospectiva, não é recomendação. Todos os números são calculados após o fato, com base em negociações armazenadas.
  • Do primeiro ao último registro é uma régua de medição, não um relatório de execução; por isso, estes valores são rotulados como múltiplos, não retornos.
  • A ressalva do centavo é generalizada: qualquer linha com um primeiro preço de um centavo (o vencedor; o segundo colocado da AAPL) herda a mesma fragilidade.
  • Universo: seis ativos — MU, NVDA, TSLA, SPY, QQQ, AAPL — apenas símbolos padrão da OCC (contratos ajustados foram excluídos pelo comprimento), ≥50 negociações em junho, primeiro registro diferente de zero.

Metodologia

  • Período: 1 a 30 de junho de 2026; timestamps armazenados em UTC, filtrados com limites UTC brutos. O painel de calibração é o bloco de referência e analisa deliberadamente o período de 2026, com computação idêntica.
  • Por contrato: primeiro preço = a negociação mais antiga do timestamp SIP de junho; último = a mais recente; empates são resolvidos deterministicamente pelo preço. Múltiplos priorizam o último sobre o primeiro, computados via query.
  • O painel de trajetória diária rederiva o vencedor a partir do mesmo scan ranqueado em cada geração; o recibo de entrada o fixa por símbolo, com limites que mantêm o post caso haja divergência entre os dois.
  • A geração é feita apenas em lote através do caminho de leitura restrito; a página nunca consulta dados em tempo real. Estado do warehouse em 12 de julho de 2026.

Cada painel é um objeto armazenado — gráfico, tabela e SQL. Consulte o ledger você mesmo no terminal Strasmore.

#options#hindsight#convexity#risk#deepdive