Como calcular a volatilidade implícita

A volatilidade implícita é calculada por iteração, não por uma fórmula direta. Não existe uma expressão fechada que converta o preço de mercado de uma opção novamente em um número de volatilidade. Por isso, um algoritmo testa uma volatilidade, calcula o preço da opção com Black-Scholes, compara esse preço teórico com a cotação e repete o processo até que os dois coincidam ao centavo. A seguir, apresentamos o método completo: a função de precificação, o loop de busca em Python usando apenas a biblioteca padrão e os motivos pelos quais dois fornecedores publicam números diferentes para o mesmo contrato.

Por que a volatilidade implícita não tem uma fórmula fechada

O modelo Black-Scholes funciona em uma direção. Informe o preço à vista, o preço de exercício, o prazo até o vencimento, a taxa de juros e a volatilidade, e ele retorna um preço teórico. Cinco dessas seis grandezas são observáveis. A volatilidade não é. Ela é uma hipótese sobre quanto a ação se deslocará entre agora e o vencimento.

Os traders invertem o problema. O preço está na tela, e a volatilidade é a incógnita. A volatilidade implícita é o valor de volatilidade que faz o preço do modelo Black-Scholes ser igual ao preço de mercado da opção. Sigma, o termo de volatilidade, aparece dentro da função de distribuição normal duas vezes, em d1 e d2. Nenhuma transformação algébrica o isola. A álgebra termina aí. Entra em cena a busca numérica. O que a volatilidade implícita mede explica a interpretação; esta página trata do mecanismo.

Duas propriedades do modelo facilitam a busca. O preço teórico de uma call sobe sempre que a volatilidade aumenta, sem exceções, e se move de forma contínua. Uma grandeza que só aumenta pode ser encontrada estreitando-se um intervalo ao redor dela.

O solucionador é executado uma vez por contrato

O resultado é um número por contrato, não um número por ação. Contratos sobre a mesma ação, na mesma janela de vencimento, podem chegar a resultados diferentes. Esses cálculos por contrato aparecem para o leitor como uma coluna na tela da corretora, com um valor para cada strike: ler uma cadeia de opções coluna a coluna explica o que aparece ao lado. Todas as opções da Apple (AAPL) com 20 a 45 dias até o vencimento que foram negociadas em 30 de junho de 2026, agrupadas pelo strike como fração do preço da ação:

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)

Subindo pela escala de strikes, a zona 0.80-0.90 chegou a 35.5%, a zona 0.95-1.00 chegou a 28.1% e a zona 1.10-1.20 chegou a 27.3%. Uma empresa, uma sessão, 6 respostas. A curvatura desse gráfico tem um nome: skew de volatilidade. Uma única volatilidade por ação não consegue representá-la.

O preço de Black-Scholes que o solver precisa igualar

S é o preço da ação, K é o preço de exercício, T é o prazo até o vencimento em anos, r é a taxa livre de risco, e N() é a distribuição cumulativa normal padrão, ou seja, a probabilidade de uma variável aleatória normal padrão ficar abaixo de determinado ponto. O Python disponibiliza essa função em math.erf, portanto o próprio interpretador é suficiente.

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

Em uma máquina na qual você não é o usuário root, acrescente sudo ao início dos dois comandos. Depois, salve isto 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)

Esse é o modelo forward completo. Informe uma volatilidade e obtenha um preço.

Como a volatilidade implícita é calculada, passo a passo

O método da bisseção é o primeiro que se deve aprender. Ele não pode divergir e não exige cálculo diferencial.

1. Delimite a resposta entre 0,01 (1% ao ano) e 5,0 (500%). Toda opção negociada fica dentro desse intervalo.
2. Calcule o preço da opção no ponto médio do intervalo.
3. Se o preço do modelo ficar acima da cotação de mercado, a estimativa foi alta demais: reduza o limite superior do intervalo até o ponto médio. Se ficar abaixo, eleve o limite inferior.
4. Pare quando o preço do modelo ficar a menos de um centavo da cotação.

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)

# $100 stock, $100 strike, three months, 4% rates, $5.00 on the screen
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

Execute python3 iv.py. O resultado é aproximadamente 0,226, indicando uma volatilidade implícita próxima de 22,6% ao ano para essa cotação hipotética. A cada iteração, o intervalo cai pela metade. Um intervalo inicial de 4,99, dividido ao meio vinte vezes, fica menor que 0,00001. Por isso, o limite de 100 iterações nunca é atingido.

Por que o método de Newton-Raphson converge mais rápido e onde falha

A bisseção descarta informações que o modelo já contém. Vega é a variação do preço da opção por unidade de volatilidade, e o modelo Black-Scholes fornece esse valor em forma fechada. O método de Newton-Raphson trata a vega como uma inclinação: mede o erro de precificação, divide-o pela vega e ajusta a estimativa nessa proporção.

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          # no slope left, hand the job back to bisection
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # the step overshot into nonsense
        if abs(step) < 1e-6:
            return sigma
    return None

Nas opções at-the-money, isso converge em três ou quatro iterações, contra cerca de uma dúzia na bisseção. O problema está no denominador: a vega diminui à medida que o strike se afasta do preço da ação. Nos mesmos contratos de AAPL, a vega média de cada zona aparece como percentual da leitura 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)

As pontas da curva têm apenas uma fração da sensibilidade: 33.1% da vega at-the-money na zona 0.80-0.90 e 31.6% na zona 1.10-1.20. Dividir um erro de precificação por um número tão pequeno produz um ajuste enorme, que pode levar a estimativa abaixo de zero, onde o modelo deixa de fornecer uma solução. Em produção, os solvers combinam os dois métodos: primeiro delimitam o intervalo e depois refinam a estimativa com Newton. Vega explica a própria grega.

Por que duas fontes reportam volatilidades implícitas diferentes

O modelo é público e a aritmética está definida. A divergência está nos dados de entrada.

• Mid versus último negócio. O solver precisa de um único preço. Um contrato cotado a $2,00 na compra e $2,20 na venda tem midpoint de $2,10, enquanto o último negócio pode ter sido a $2,02, 90 minutos atrás. Em um contrato assim, dez centavos no preço valem mais do que um ponto de volatilidade.
• Dividendos e custo de carregamento. A função acima precifica uma call europeia sobre uma ação que não paga dividendos. Um dividendo antes do vencimento reduz o preço a termo, e cada mesa aplica seu próprio ajuste e sua própria taxa.
• Exercício antecipado em opções americanas. As opções de ações individuais nos EUA podem ser exercidas em qualquer dia, e esse direito tem valor que a fórmula europeia não consegue incorporar. Um solver que o ignora transfere a diferença para a volatilidade. Árvores binomiais precificam diretamente o direito de exercício.
• Cotações defasadas. Um strike negociado pela última vez na terça-feira ainda pode exibir uma cotação, e o solver trata como verdadeira qualquer informação que receba.

A convergência torna os dois últimos pontos visíveis. O painel abaixo analisa oito ações conhecidas em 30 de junho de 2026, conta os contratos negociados com 20 a 45 dias restantes e apresenta tanto a volatilidade at the money quanto a parcela de contratos para os quais o cálculo convergiu:

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 apresentou a maior leitura at the money entre os 8 nomes, em 47.7%, contra 14.4% para SPY, que ficou na última posição. Na cadeia de TSLA, 97.8% dos contratos negociados produziram uma resposta convergente. Os demais correspondem a strikes em que o preço fornecido ao solver está fora do intervalo que qualquer volatilidade consegue reproduzir, a uma cotação abaixo do valor intrínseco ou a um mercado cruzado. Saber se um número assim é alto é outra questão: 30% de IV é alto? aborda esse ponto, e o movimento esperado o converte em uma faixa em dólares.

O mesmo contrato, recalculado em cada sessão

Nada é armazenado sobre a volatilidade implícita. Ela é recalculada com base no preço exibido na tela. Abaixo está o contrato de AAPL com vencimento em 17 de julho de 2026 e maior volume de negociação, acompanhado desde 1º de junho até o vencimento. O strike não mudou, e o vencimento também não:

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

Ao longo de 29 sessões, a leitura calculada abriu em 25.1%, com 46 dias restantes, e terminou em 26.6%, com 4 dias restantes. Cada ponto dessa linha corresponde a uma execução do loop acima usando a cotação daquela sessão. Nossas páginas por ticker publicam o mesmo cálculo: volatilidade implícita de AAPL o executa diariamente para toda a cadeia de opções, permitindo que o leitor reproduza qualquer número apresentado ali com o código desta página.

Perguntas frequentes sobre o cálculo da volatilidade implícita

Existe uma fórmula para a volatilidade implícita?

Não. O modelo Black-Scholes relaciona a volatilidade ao preço, mas essa relação não tem uma inversa elementar, porque sigma aparece duas vezes dentro da distribuição normal. Todo número de volatilidade implícita que você encontra, aqui ou em qualquer outro lugar, é obtido por um algoritmo iterativo.

Quantas iterações são necessárias?

A cada passagem do método da bisseção, o intervalo é reduzido pela metade. Assim, um intervalo de 0,01 a 5,0 cai para menos de 0,00001 em vinte passagens. Para ajustar a cotação ao centavo mais próximo, normalmente são necessárias cerca de uma dúzia de passagens. O método de Newton-Raphson chega ao resultado em três ou quatro iterações quando está próximo do preço de exercício, mas pode se comportar mal quando o vega é baixo.

Por que meu broker e um fornecedor de dados mostram volatilidades implícitas diferentes?

Eles forneceram entradas diferentes ao algoritmo. As diferenças mais comuns são a utilização da cotação média em vez do último negócio, a taxa de juros e a premissa de dividendos, além de o modelo considerar ou não o exercício antecipado de opções americanas. Em um strike com pouca liquidez, uma cotação defasada, sozinha, pode alterar o resultado em vários pontos percentuais.

Calls e puts com o mesmo strike apresentam a mesma volatilidade implícita?

Em teoria, sim. A paridade entre put e call relaciona as duas opções ao mesmo strike e vencimento. Na prática, as duas cotações são definidas de forma independente, e os números calculados diferem um pouco. Esse é mais um motivo para as médias de toda a cadeia variarem entre fornecedores.

Posso calcular a volatilidade implícita sem dados de mercado?

Sim, para uma cotação hipotética. O código acima recebe um preço, um strike, o preço do ativo à vista, o prazo até o vencimento e uma taxa, todos inseridos manualmente. Reproduzir o número de um fornecedor em tempo real é a parte mais difícil: isso exige usar exatamente as mesmas entradas adotadas pelo fornecedor.

Cada painel aqui armazena o SQL correspondente. Abra um deles e execute o mesmo cálculo em uma cadeia de opções em tempo real no terminal da Strasmore.