Cómo se calcula la volatilidad implícita

La volatilidad implícita se calcula mediante iteración, no con una fórmula. No existe una expresión cerrada que convierta el precio de mercado de una opción en una cifra de volatilidad. Por eso, un solucionador estima una volatilidad, calcula el precio de la opción con Black-Scholes, compara ese precio teórico con la cotización y repite el proceso hasta que ambos coinciden al centavo. A continuación se explica el método completo: la función de valoración, el ciclo de búsqueda en Python con la biblioteca estándar y las razones por las que dos proveedores publican cifras distintas para el mismo contrato.

Por qué la volatilidad implícita no tiene una fórmula cerrada

Black-Scholes funciona en una sola dirección. Se introducen el precio spot, el strike, el tiempo hasta el vencimiento, la tasa de interés y la volatilidad, y devuelve un precio teórico. Cinco de esas seis variables son observables. La volatilidad no lo es. Es una suposición sobre cuánto se moverá la acción entre ahora y el vencimiento.

Los traders invierten el problema. El precio aparece en pantalla y la volatilidad es la variable desconocida. La volatilidad implícita es el valor de volatilidad que hace que el precio de Black-Scholes sea igual al precio de mercado de la opción. Sigma, el término de volatilidad, aparece dentro de la función de distribución normal dos veces, en d1 y d2, y ningún reordenamiento algebraico permite aislarla. Ahí termina el álgebra. Después comienza la búsqueda numérica. Qué mide la volatilidad implícita explica la interpretación; esta página aborda el funcionamiento del cálculo.

Dos propiedades del modelo facilitan la búsqueda. El precio teórico de una call aumenta cada vez que sube la volatilidad, sin excepciones, y lo hace de manera gradual. Una cantidad que solo aumenta puede acotarse estrechando un intervalo a su alrededor.

El cálculo se ejecuta una vez por contrato

El resultado es un número por contrato, no uno por acción, y los contratos sobre la misma acción dentro del mismo rango de vencimiento difieren entre sí. Estas son todas las opciones de Apple (AAPL) con entre 20 y 45 días restantes que cotizaron el 30 de junio de 2026, agrupadas por strike como fracción del precio de la acción:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

Al recorrer la escalera de strikes, la zona 0.80-0.90 dio como resultado 35.5%, la zona 0.95-1.00 dio 28.1% y la zona 1.10-1.20 dio 27.3%. Una empresa, una sesión, 6 respuestas. La curvatura de esa línea tiene un nombre: sesgo de volatilidad, y una sola volatilidad por acción no puede representarla.

El precio de Black-Scholes que el solucionador debe igualar

S es el precio de la acción, K es el strike, T es el tiempo hasta el vencimiento en años, r es la tasa libre de riesgo y N() es la distribución acumulada normal estándar. Es decir, representa la probabilidad de que una observación normal estándar se sitúe por debajo de un punto determinado. Python incorpora esta última función en math.erf, por lo que el intérprete por sí solo es suficiente.

apt-get update && apt-get install -y python3

Antepon sudo a ambos comandos si no tienes permisos de root en la máquina. Después, guarda esto como iv.py:

import math

def norm_cdf(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs_call(S, K, T, r, sigma):
    if T <= 0.0 or sigma <= 0.0:
        return max(S - K, 0.0)
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    d2 = d1 - sigma * math.sqrt(T)
    return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)

Ese es el modelo directo completo. Se le proporciona una volatilidad y devuelve un precio.

Cómo se calcula la volatilidad implícita, paso a paso

La bisección es el primer método que conviene aprender. No puede divergir y no requiere cálculo diferencial.

1. Encierre la respuesta entre 0.01 (1% anual) y 5.0 (500%). Todas las opciones negociadas se encuentran dentro de ese rango.
2. Calcule el precio de la opción en el punto medio del intervalo.
3. Si el precio del modelo está por encima de la cotización de mercado, la estimación es demasiado alta: baje el límite superior del intervalo hasta el punto medio. Si está por debajo, suba el límite inferior.
4. Deténgase cuando el precio del modelo quede a menos de un centavo de la cotización.

def implied_vol(price, S, K, T, r, lo=0.01, hi=5.0, tol=0.01):
    for _ in range(100):
        mid = 0.5 * (lo + hi)
        diff = bs_call(S, K, T, r, mid) - price
        if abs(diff) < tol:
            return mid
        if diff > 0.0:
            hi = mid
        else:
            lo = mid
    return 0.5 * (lo + hi)

# Acción a $100, strike de $100, tres meses, tasas de 4%, $5.00 en pantalla
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

Ejecute python3 iv.py. El resultado es aproximadamente 0.226: una volatilidad implícita cercana a 22.6% anual para esa cotización hipotética. Cada iteración reduce el intervalo a la mitad. Un rango de 4.99 reducido a la mitad veinte veces queda por debajo de 0.00001, por lo que el límite de 100 iteraciones nunca se alcanza.

Por qué Newton-Raphson converge más rápido y dónde falla

La bisección descarta información que el modelo ya contiene. Vega es el cambio en el precio de la opción por unidad de volatilidad, y Black-Scholes lo calcula mediante una fórmula cerrada. Newton-Raphson lo trata como una pendiente: mide el error de valoración, lo divide entre vega y ajusta la estimación en esa magnitud.

def bs_vega(S, K, T, r, sigma):
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    return S * math.sqrt(T) * math.exp(-0.5 * d1 * d1) / math.sqrt(2.0 * math.pi)

def implied_vol_newton(price, S, K, T, r, sigma=0.5):
    for _ in range(20):
        v = bs_vega(S, K, T, r, sigma)
        if v < 1e-8:
            return None          # ya no queda pendiente; devolver el cálculo a la bisección
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # el paso se excedió y produjo un valor sin sentido
        if abs(step) < 1e-6:
            return sigma
    return None

Cerca del dinero, converge en tres o cuatro iteraciones, frente a la docena de la bisección. El problema está en el denominador: vega disminuye cuando el strike se aleja del precio de la acción. Para los mismos contratos de AAPL, se muestra la vega promedio de cada zona como porcentaje de la lectura at the money:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness,
     (
         SELECT avg(toFloat64(vega))
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND days_to_expiry BETWEEN 20 AND 45
           AND iv_converged = 1
           AND volume > 0
           AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
     ) AS atm_vega
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(vega)) / atm_vega, 1) AS vega_pct_of_atm,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

Las alas tienen una fracción de la sensibilidad: 33.1% de la vega at the money en la zona 0.80-0.90, y 31.6% en la zona 1.10-1.20. Dividir un error de valoración entre un número tan pequeño produce un paso enorme. Esto puede llevar la estimación por debajo de cero, donde el modelo ya no puede ofrecer una solución. En producción, los solvers combinan ambos métodos: primero acotan la solución y después la refinan con Newton. Vega explica el propio griego.

Por qué dos fuentes reportan una volatilidad implícita diferente

El modelo es público y la aritmética está resuelta. La discrepancia está en los datos de entrada.

• Mid frente a último precio. El cálculo necesita un solo precio. Un contrato cotizado con una oferta de compra de $2.00 y una oferta de venta de $2.20 tiene un punto medio de $2.10, mientras que el último print podría ser de $2.02, ejecutado hace noventa minutos. En un contrato así, diez centavos de precio valen más que un punto de volatilidad.
• Dividendos y carry. La función anterior calcula el precio de una call europea sobre una acción que no paga dividendos. Un dividendo antes del vencimiento reduce el precio forward, y cada mesa aplica su propio ajuste y su propia tasa.
• Ejercicio anticipado en opciones estadounidenses. Las opciones estadounidenses sobre acciones individuales pueden ejercerse cualquier día, y ese derecho tiene un valor que la fórmula europea no puede incorporar. Un cálculo que lo ignora traslada la diferencia a la volatilidad. Los árboles binomiales calculan directamente el valor del derecho de ejercicio.
• Cotizaciones desactualizadas. Un strike cuyo último print ocurrió el martes puede seguir mostrando una cotización, y el cálculo trata como verdadera cualquier cifra que recibe.

La convergencia hace visibles los dos últimos problemas. El panel siguiente toma ocho acciones conocidas al 30 de junio de 2026, cuenta los contratos negociados con entre 20 y 45 días restantes y reporta tanto la volatilidad at the money como la proporción de contratos en los que el cálculo convergió:

WITH abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS distance_from_spot
SELECT underlying_symbol AS symbol,
       round(100 * avgIf(toFloat64(implied_volatility), iv_converged = 1 AND distance_from_spot < 0.05), 1) AS atm_iv_pct,
       round(100 * countIf(iv_converged = 1) / count(), 1) AS solved_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE date = toDate('2026-06-30')
  AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMZN', 'TSLA', 'SPY', 'KO', 'JNJ')
  AND days_to_expiry BETWEEN 20 AND 45
  AND volume > 0
GROUP BY symbol
HAVING countIf(iv_converged = 1 AND distance_from_spot < 0.05) > 0
ORDER BY atm_iv_pct DESC

TSLA registró la lectura at the money más alta entre los 8 nombres, con 47.7%, frente a 14.4% de SPY, que quedó en el último lugar. En la cadena de TSLA, 97.8% de los contratos negociados produjeron una respuesta convergente. El resto corresponde a strikes cuyo precio entregado al cálculo está fuera de lo que cualquier nivel de volatilidad puede reproducir, a una cotización por debajo del valor intrínseco o a un mercado cruzado. Que una cifra así sea alta es otra cuestión: ¿una IV de 30% es alta? lo analiza, y el movimiento esperado lo convierte en un rango en dólares.

El mismo contrato, resuelto de nuevo en cada sesión

No se almacena nada sobre la volatilidad implícita. Se recalcula a partir del precio que aparece en pantalla. A continuación se muestra el contrato de AAPL más negociado con vencimiento el 17 de julio de 2026, seguido desde el 1 de junio hasta el vencimiento. El strike no cambió y el vencimiento tampoco:

WITH (
         SELECT ticker
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND expiration_date = toDate('2026-07-17')
           AND iv_converged = 1
           AND volume > 0
         ORDER BY volume DESC
         LIMIT 1
     ) AS pinned_contract
SELECT date,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       round(avg(days_to_expiry)) AS days_to_expiry
FROM global_markets.options_greeks
WHERE ticker = pinned_contract
  AND date BETWEEN toDate('2026-06-01') AND toDate('2026-07-17')
  AND iv_converged = 1
  AND volume > 0
GROUP BY date
ORDER BY date

A lo largo de 29 sesiones, la lectura calculada comenzó en 25.1%, con 46 días restantes, y terminó en 26.6%, con 4 días restantes. Cada punto de esa línea corresponde a una ejecución del proceso anterior con la cotización de esa sesión. Nuestras páginas por ticker publican el mismo cálculo: volatilidad implícita de AAPL lo ejecuta diariamente para toda la cadena, de modo que el lector puede reproducir cualquier cifra con el código de esta página.

Preguntas frecuentes sobre el cálculo de la volatilidad implícita

¿Existe una fórmula para la volatilidad implícita?

No. Black-Scholes transforma la volatilidad en precio, pero esa transformación no tiene una inversa elemental porque sigma aparece dos veces dentro de la distribución normal. Cada cifra de volatilidad implícita que encuentre, aquí o en cualquier otro sitio, proviene de un solucionador iterativo.

¿Cuántas iteraciones requiere el cálculo?

Cada paso de bisección reduce a la mitad el intervalo. Por eso, un rango de 0.01 a 5.0 cae por debajo de 0.00001 en veinte pasos, y normalmente se necesitan alrededor de una docena para igualar una cotización al centavo más cercano. Newton-Raphson llega al resultado en tres o cuatro pasos cuando está cerca del dinero, pero sus pasos pueden comportarse mal cuando la vega es baja.

¿Por qué mi bróker y un proveedor de datos muestran volatilidades implícitas diferentes?

Introdujeron datos distintos en el solucionador. Las diferencias más comunes son usar la cotización mid frente a la última operación, asumir una tasa o un dividendo diferentes y considerar, o no, el ejercicio anticipado de opciones americanas. En un strike con poca liquidez, una cotización desactualizada por sí sola puede mover el resultado varios puntos.

¿Las calls y las puts con el mismo strike dan la misma volatilidad implícita?

En teoría, sí. La paridad put-call las relaciona cuando comparten strike y vencimiento. En la práctica, las dos cotizaciones se fijan de forma independiente y las cifras resultantes difieren ligeramente. Esta es otra razón por la que los promedios de toda la cadena varían entre proveedores.

¿Puedo calcular la volatilidad implícita sin datos de mercado?

Sí, para una cotización hipotética. El código anterior toma un precio, un strike, un precio spot, un plazo hasta el vencimiento y una tasa, todos introducidos manualmente. Igualar la cifra de un proveedor en tiempo real es la parte más difícil: requiere usar exactamente los mismos datos que utilizó el proveedor.

Cada panel de esta página guarda el SQL que lo sustenta. Abra uno y ejecute el mismo cálculo sobre una cadena en tiempo real en la terminal de Strasmore.