Mejores y peores mil dólares de junio 2026

¿Cuál fue la mejor operación con opciones de junio de 2026 y en cuánto se habría convertido una inversión de mil dólares? La respuesta honesta tiene cuatro vertientes: el premio mayor; la anomalía de la impresión de un centavo con dos contratos que genera el titular; las nueve mil pérdidas casi totales que la rodean; y la operación espejo —vender lo que el ganador compró— donde mil dólares de prima cobrada se convirtieron en un agujero de seis cifras. Todo se calcula DESPUÉS de los hechos mediante el registro de transacciones; una operación óptima retrospectivamente mide lo que el mes contuvo, no una estrategia que alguien pudiera haber ejecutado. Cada número es el resultado de una consulta almacenada; expanda cualquier panel para ver el SQL exacto.

¿Qué tan volátil fue junio de 2026?

¿Requiere un ganador de opciones de cien veces un mes histórico en el mercado? Junio dice que no. El panel recalcula cada mes de 2026 de forma idéntica —desde la apertura al cierre en horario regular, más el rango de máximo a mínimo como porcentaje de la apertura— para SPY y NVDA, la base de la jugada ganadora. Junio tuvo 21 sesiones.

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 terminó junio -1.2% desde su apertura dentro de un rango del 5.8% —más estrecho que marzo (8.7%) o abril (11.4%). El movimiento ocurrió en un nivel inferior: NVDA cerró -7.4% desde su apertura de junio tras recorrer un rango del 19.7% (el resumen del mercado de junio de 2026 contiene el panorama general del mercado). Un ticket de cien veces no necesitó un mes de desplome; bastó con que una acción de gran capitalización cayera con fuerza en dos semanas.

Los mayores múltiplos del mes

El universo: cada contrato en seis raíces líquidas con al menos cincuenta operaciones en junio — 30951 contratos — con precios desde la primera cotización del primero de junio hasta la última, desde ambas posiciones: cuánto marcó la compra en la primera cotización al cierre, y cuánto terminó debiendo la venta de mil dólares de prima.

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

El ganador fue un put: O:NVDA260629P00200000, con la primera cotización en $0.01 y la última en $4.95 — un múltiplo de 495x. Analice el ticker: un put de NVDA con strike de $200 que vence el 29 de junio. Mil dólares en la primera cotización compraron 1000 contratos; en la última cotización la posición marcó $495000. NVDA cayó durante la segunda mitad de junio — su caída profunda detalla el descenso, sesión por sesión — y este contrato representó esa caída, con apalancamiento. Predecirlo con antelación es algo que ninguna tabla puede venderle; la primera cotización tiene su propio análisis forense abajo.

Otros en la tabla de líderes

Los cinco contratos son puts — la columna is_put es el comprobante — e incluso el múltiplo más pequeño superó los diez veces. La segunda fila, un put de AAPL de $240 con vencimiento el 24 de julio, pasó de $0.01 a $0.34 para un 34x y seguía vigente al cierre del mes (un vencimiento en julio hace que ese último precio sea una marca, no un settlement). La tercera fila, un put de MU de $100 con vencimiento el 10 de julio, registró un 20x y también se extendió hasta julio. Las filas cuatro y cinco, un put de TSLA de $397.50 y un put de QQQ de $707, ambos con vencimiento el 10 de junio, generaron 12.5x y 11.7x tras la caída inicial del mes. Cinco contratos, cinco apuestas a una baja.

La venta: cómo mil dólares se convierten en una pérdida de medio millón

Comprar el activo ganador implicaba un riesgo de exactamente mil dólares. VENDERLO —cobrar ese mismo monto de mil dólares como prima— implicaba arriesgar el movimiento del precio. La columna sold_net_loss_usd analiza cada fila desde la perspectiva del vendedor, sin considerar márgenes, asignaciones ni compras forzosas. La venta de 1000 contratos a $0.01 generó mil dólares; la última cotización marcó la posición en $495000 para el vendedor, lo que representa una pérdida neta de $494,000. El peor escenario para el comprador es el precio del ticket; el peor escenario para el vendedor es el movimiento del mercado, y el mayor movimiento de junio fue de quinientos tickets de profundidad.

El problema de los penny prints

¿De dónde proviene el 495x? El registro a continuación comprime toda la serie de transacciones de junio del ganador en una sola fila forense: su primera ejecución, la segunda y un recuento de cada penny print en su historia.

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)
)

El contrato no figuraba en la serie de junio hasta el 2026-06-15. Su primera ejecución, a las 09:49:30 ET, fue de 2 contratos a $0.01 — aproximadamente dos dólares de prima. La siguiente ejecución, 101 segundos después, fue de $2.44, y el penny no volvió a ejecutarse (1 penny print, 2 contratos, en todo el mes). La posición de mil contratos que asume el titular es quinientas veces mayor que el tamaño que alguna vez se negoció a ese precio. Si se entra en la segunda ejecución, mil dólares alcanzarían los $1980 para la última ejecución del mes — un 2x, no un 495x. El recorrido desde la segunda ejecución — aproximadamente el doble en dos semanas, con una trayectoria violenta— fue real y negociable. El premio mayor, tal como se registró, no lo fue.

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.

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

The 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

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
)

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

The 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.

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 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.

Lo que esta tabla enseña (y lo que no puede enseñar)

Cuatro lecciones. La convexidad es real: una opción out-of-the-money barata se multiplica de forma absurda cuando el subyacente se mueve rápido; es exactamente por eso que los boletos de lotería se negocian por centavos. Los múltiplos de los titulares requieren un análisis forense: el 495x de junio se basa en una sola operación de dos lotes; el rendimiento negociable fue del doble. La distribución es el precio de la convexidad: 14 multiplicadores de diez veces se encuentran junto a 9385 pérdidas casi totales (el explicador de market makers detalla quién vende los boletos). Y la retrospectiva no se puede negociar: el boleto ganador no existía el 1 de junio — se imprimió por primera vez el 15 de junio — y comprarlo significaba conocer, esa mañana, la dirección y el tiempo de las dos semanas siguientes. Esta página mide lo que contuvo junio. No sugiere lo que será julio.

Preguntas frecuentes

¿Cuál fue la mejor operación con opciones de junio de 2026?

Medido desde la primera cotización hasta la última en seis activos líquidos, un put de NVDA con strike de $200 que vence el 29 de junio de 2026: de $0.01 a $4.95, un múltiplo de 495x — basado en una primera cotización de un lote de dos centavos (la siguiente cotización fue de $2.44).

¿Se puede perder más de lo invertido al operar con opciones?

Comprar opciones, no: un comprador puede perder como máximo la prima pagada. Vender opciones, sí — el registro de junio muestra a un vendedor que cobró mil dólares de prima y terminó con una pérdida de $494,000 en la última cotización.

¿Por qué la mayoría de las opciones baratas expiran sin valor?

Una opción barata descuenta un resultado que el mercado considera poco probable: un movimiento grande antes de un plazo cercano. La mayoría de los meses presentan pocos movimientos de este tipo, y la mayoría de los tickets pierden valor por el paso del tiempo. En junio de 2026, el 9385 de 30951 de los contratos con actividad comercial perdió al menos el noventa por ciento de su valor de primera cotización; el 8949 cotizó por última vez a dos centavos o menos.

¿Podría un trader real haber capturado el 495x?

Casi con seguridad no con el tamaño impreso: solo 2 contratos operaron al precio de entrada de $0.01, y el precio alcanzó los $2.44 en 101 segundos. Mil dólares en la segunda cotización representaron aproximadamente $1980 en la cotización final — una operación sólida, un múltiplo que cambia la vida solo en retrospectiva.

Notas de los datos

Metodología

• Periodo: 1 al 30 de junio de 2026; las marcas de tiempo se almacenan en UTC y se filtran con límites UTC brutos. El panel de calibración es el bloque de referencia y analiza deliberadamente el año 2026, calculado de la misma forma.
• Por contrato: el primer precio es la operación con la marca de tiempo SIP más temprana de junio, y el último es la más tardía; los empates se resuelven de forma determinante por precio. Los múltiplos se calculan mediante el último sobre el primero dentro de la consulta.
• El panel de trayectoria diaria vuelve a derivar al ganador desde el mismo escaneo clasificado en cada generación; el recibo de entrada lo fija por símbolo, con límites que mantienen la posición si ambos discrepan.
• La generación es exclusivamente por lotes a través de la ruta de solo lectura restringida; la página nunca consulta datos en vivo. Estado del almacén al 12 de julio de 2026.

Cada panel es un único objeto almacenado: gráfico, tabla y SQL. Consulte el libro mayor usted mismo en la terminal Strasmore.