Como calcular a volatilidade cambial: um guia para desenvolvedores

Saber como calcular a volatilidade cambial é a diferença entre uma aplicação multimoeda que absorve em silêncio uma variação de 2% da noite para o dia e outra que te acorda com um alerta às 3 da manhã. A volatilidade é o número que diz o quanto uma taxa de câmbio tende a se mover — e quase toda decisão prática em um sistema que lida com câmbio depende dela: por quanto tempo uma cotação continua válida, qual folga adicionar a um preço, quando fazer hedge e quando disparar um alerta.

O incômodo é que a maioria dos tutoriais sobre cálculo de volatilidade foi escrita para ações. Eles pressupõem um preço de fechamento diário, um ano de 252 pregões e uma única cotação sem ambiguidade. O mercado de câmbio não tem nada disso. Ele negocia 24 horas por dia, cinco dias por semana, em um mercado de balcão descentralizado sem fechamento oficial, e o "preço" de EUR/USD depende da direção em que você cotar o par.

Este guia percorre a matemática de verdade, as armadilhas específicas do câmbio e código funcional em Python e JavaScript que calcula a volatilidade realizada a partir de dados históricos de taxas de câmbio.

Por que a volatilidade cambial importa agora

Setembro de 2026 é um momento incomumente bom para pensar em volatilidade, porque o mercado passou quase todo o ano em um regime suspeitosamente calmo — e então deixou de ser calmo por um instante.

Ao longo do verão, as moedas emergentes ficaram menos voláteis do que as do G7 por perto de 200 pregões consecutivos, uma sequência que, segundo a Bloomberg, seria a mais longa desde 2000 se fosse mantida. As operações de carry trade financiadas em dólar emendaram a melhor sequência desde 2008, e uma cesta popular financiada em euro de real brasileiro, peso colombiano e lira turca foi reportada em alta de cerca de 19% no ano — o melhor desempenho acumulado desde 2005. Estratégias de carry só funcionam em mercados calmos, então o desempenho delas é, por si só, um sinal de volatilidade.

Depois, no início de setembro, o iene saltou mais de 2% contra o dólar em um único pregão até tocar 155,28, seu nível mais forte desde o começo de agosto, com os operadores se posicionando para uma nova intervenção do Ministério das Finanças do Japão. Isso veio depois de uma intervenção conjunta de EUA e Japão em 31 de julho e de um recorde de 11,73 trilhões de ienes (cerca de US$ 73 bilhões) em intervenções do MOF entre abril e maio, após USD/JPY romper 160.

Esse contraste é a lição inteira. A volatilidade média estava baixa. A volatilidade realizada em um dia específico foi enorme. Um sistema que dimensionasse suas folgas de câmbio por uma média anual móvel teria errado feio exatamente no dia em que isso importava. Medir a volatilidade direito — e continuamente — é o que evita que isso aconteça.

O que a volatilidade cambial realmente mede

A volatilidade é o desvio padrão dos retornos, expresso em base anualizada. Ela não é uma previsão de direção, nem é o tamanho de um movimento. É uma medida de dispersão: o quanto os retornos diários de um par de moedas se espalham em torno da média.

Dois tipos importam:

• Volatilidade realizada (histórica) — calculada para trás, a partir das taxas efetivamente observadas. É a que você mesmo consegue calcular a partir de uma série temporal, e é a que este guia cobre.
• Volatilidade implícita — extraída dos preços de opções de câmbio. É a estimativa prospectiva do mercado. Você não consegue derivá-la das taxas à vista; precisa de um feed de dados de opções.

Para a maioria dos desenvolvedores de aplicações — precificação, faturamento, dashboards de tesouraria, alertas de risco — a volatilidade realizada é suficiente e sai de graça se você já tem taxas históricas.

Uma intuição aproximada dos números: pares principais como EUR/USD costumam rodar entre 5% e 10% anualizados em períodos calmos e entre 10% e 15% em períodos de estresse. Pares emergentes rodam rotineiramente duas a três vezes mais alto. Essas faixas mudam com o tempo, e é justamente por isso que você deve medir em vez de supor.

A fórmula: retornos logarítmicos, desvio padrão e anualização

O cálculo tem três passos.

Passo 1 — Converta as taxas em retornos logarítmicos.

r_t = ln(P_t / P_t-1)

Passo 2 — Calcule o desvio padrão desses retornos na janela escolhida (use o desvio padrão amostral, dividindo por n − 1).

Passo 3 — Anualize multiplicando pela raiz quadrada do número de observações por ano.

annualised_volatility = stdev(r) * sqrt(N)

Juntando tudo:

σ_annual = stdev( ln(P_t / P_t-1) ) × √N

Por que retornos logarítmicos em vez de variação percentual

A variação percentual simples é assimétrica: sair de 1,10 para 1,20 é +9,09%, mas a volta de 1,20 para 1,10 é −8,33%. Deveriam ser iguais e opostos. Os retornos logarítmicos são — ln(1.20/1.10) e ln(1.10/1.20) diferem apenas no sinal.

Isso pesa muito mais no câmbio do que em ações por causa da inversão da cotação. EUR/USD e USD/EUR descrevem o mesmo mercado. Se você calcular a volatilidade com variações percentuais, obtém duas respostas ligeiramente diferentes dependendo da direção em que cotou o par, o que é obviamente errado. Retornos logarítmicos são simétricos à inversão: ln(1/x) = −ln(x), e o desvio padrão ignora o sinal. Mesmo par, mesma volatilidade, em qualquer direção.

Retornos logarítmicos também são aditivos ao longo do tempo, o que torna trivial a agregação de vários dias.

Por que √N — e quanto N deve valer no câmbio

A volatilidade escala com a raiz quadrada do tempo porque a variância escala linearmente com o tempo (sob a hipótese padrão de passeio aleatório). Para converter volatilidade diária em anual, multiplique por √(days per year).

Tutoriais de ações usam 252, o número aproximado de pregões das bolsas norte-americanas. O câmbio é diferente. O mercado funciona continuamente do domingo à noite até a sexta à noite — cerca de 260 sessões em dias úteis por ano, menos um punhado de feriados de baixo movimento. A maioria dos provedores de dados de câmbio publica taxas em todo dia útil, inclusive nos dias em que o mercado local de um país está fechado.

A regra prática: N precisa corresponder à frequência de amostragem dos seus dados, não a uma convenção emprestada de outra classe de ativos.

Passo 1: obtenha dados históricos de taxas de câmbio limpos

A volatilidade só é tão boa quanto a série por trás dela. Puxe uma série diária com uma única chamada ao endpoint /v1/timeseries:

curl -G "https://api.finexly.com/v1/timeseries" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d base=EUR \
  -d symbols=USD,JPY,GBP \
  -d start_date=2026-06-08 \
  -d end_date=2026-09-05

A resposta é um mapa indexado por data:

{
  "success": true,
  "base": "EUR",
  "start_date": "2026-06-08",
  "end_date": "2026-09-05",
  "rates": {
    "2026-06-08": { "USD": 1.1421, "JPY": 178.62, "GBP": 0.8447 },
    "2026-06-09": { "USD": 1.1408, "JPY": 178.94, "GBP": 0.8451 }
  }
}

Uma requisição, uma série, sem loop de paginação. A referência completa de parâmetros está na documentação da API da Finexly, e os padrões mais amplos para trabalhar com intervalos de datas estão no nosso guia da API de taxas de câmbio históricas.

Quatro problemas de dados exclusivos do câmbio

Antes de confiar no resultado, resolva estes. Nenhum deles aparece em um tutorial de volatilidade de ações, e todos os quatro vão distorcer seu número.

1. Não existe fechamento oficial. O câmbio é descentralizado; ninguém toca o sino. Provedores diferentes tiram o snapshot em momentos diferentes — 22:00 UTC, meia-noite UTC, o fixing de referência do BCE das 14:15 CET ou o fix WM/Reuters das 16h de Londres. Misturar horários de snapshot dentro de uma mesma série injeta variância artificial. Escolha uma convenção e nunca misture. Se você não tem certeza do que o seu provedor faz, nosso texto sobre de onde vêm os dados das APIs de câmbio é um bom ponto de partida.

2. Fins de semana e lacunas. O mercado fecha na sexta à noite e reabre no domingo à noite. Um retorno de sexta para segunda cobre cerca de 65 horas de tempo corrido, mas é tratado como um único "dia" em um cálculo ingênuo. A maioria dos profissionais aceita isso e anualiza pela contagem de dias úteis — a abordagem padrão —, mas você precisa ser consistente. Não preencha para frente as taxas de fim de semana na série; uma sequência de valores idênticos vai puxar seu desvio padrão artificialmente para baixo.

3. Assimetria da moeda base. Como visto acima, os retornos logarítmicos resolvem o problema da inversão matematicamente. Mas você ainda precisa decidir em qual base está medindo risco. A volatilidade da sua exposição em USD medida em EUR é uma pergunta de negócio diferente da do mesmo par medido em USD, mesmo que o número saia idêntico. Seja explícito quanto ao numerário.

4. Cruzamentos triangulados. Se o seu provedor deriva, digamos, SEK/NOK dividindo SEK/USD por NOK/USD, o resultado herda ruído das duas pernas e de qualquer descasamento de horário entre elas. Cruzamentos sintéticos podem exibir volatilidade sensivelmente maior do que a do mercado cotado diretamente. Nosso guia sobre taxas de câmbio cruzadas explica quando a triangulação é segura e quando não é.

Atenção também à precisão. Truncar pares com JPY em duas casas decimais antes de calcular os retornos transforma movimentos pequenos em zeros e enviesa a volatilidade para baixo — veja arredondamento de moedas e casas decimais para a regra geral. Armazene com precisão total; arredonde apenas na exibição.

Passo 2: calcule a volatilidade realizada em Python

Aqui está uma implementação completa e com poucas dependências. Ela usa requests e a biblioteca padrão — nada de pandas.

import math
import statistics
import requests

FX_DAYS_PER_YEAR = 260  # weekday sessions; use 252 for the equity convention


def fetch_series(base, symbol, start, end, api_key):
    url = "https://api.finexly.com/v1/timeseries"
    params = {
        "base": base,
        "symbols": symbol,
        "start_date": start,
        "end_date": end,
    }
    headers = {"Authorization": "Bearer " + api_key}
    response = requests.get(url, params=params, headers=headers, timeout=10)
    response.raise_for_status()
    return response.json()["rates"]


def log_returns(rates, symbol):
    """Ordered log returns from a date-keyed rates map."""
    dates = sorted(rates.keys())
    series = [rates[d][symbol] for d in dates]
    return [
        math.log(series[i] / series[i - 1])
        for i in range(1, len(series))
        if series[i] > 0 and series[i - 1] > 0
    ]


def annualised_volatility(returns, periods_per_year=FX_DAYS_PER_YEAR):
    if len(returns) < 2:
        raise ValueError("need at least two returns")
    return statistics.stdev(returns) * math.sqrt(periods_per_year)


rates = fetch_series("EUR", "USD", "2026-06-08", "2026-09-05", "YOUR_API_KEY")
returns = log_returns(rates, "USD")

vol = annualised_volatility(returns)
print("Observations:      {}".format(len(returns)))
print("Daily volatility:  {:.4%}".format(vol / math.sqrt(FX_DAYS_PER_YEAR)))
print("Annual volatility: {:.2%}".format(vol))

statistics.stdev é o desvio padrão amostral (denominador n − 1), que é o que você quer. Se migrar para o NumPy, lembre-se de que numpy.std usa por padrão a versão populacional — passe ddof=1 para bater.

Duas proteções que vale a pena manter em código de produção: descarte taxas não positivas antes de tirar o logaritmo e recuse-se a devolver um número quando a janela tiver observações de menos. Uma volatilidade de 30 dias calculada com nove pontos não é uma volatilidade de 30 dias.

Passo 3: o mesmo cálculo em JavaScript

Aqui também não é preciso nenhuma biblioteca numérica.

const FX_DAYS_PER_YEAR = 260;

async function fetchSeries(base, symbol, start, end, apiKey) {
  const url = new URL('https://api.finexly.com/v1/timeseries');
  url.searchParams.set('base', base);
  url.searchParams.set('symbols', symbol);
  url.searchParams.set('start_date', start);
  url.searchParams.set('end_date', end);

  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${apiKey}` },
  });
  if (!res.ok) throw new Error(`Finexly returned ${res.status}`);
  const body = await res.json();
  return body.rates;
}

function logReturns(rates, symbol) {
  const dates = Object.keys(rates).sort();
  const series = dates.map((d) => rates[d][symbol]);
  const out = [];
  for (let i = 1; i < series.length; i += 1) {
    if (series[i] > 0 && series[i - 1] > 0) {
      out.push(Math.log(series[i] / series[i - 1]));
    }
  }
  return out;
}

function annualisedVolatility(returns, periodsPerYear = FX_DAYS_PER_YEAR) {
  if (returns.length < 2) throw new Error('need at least two returns');
  const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
  const variance =
    returns.reduce((acc, r) => acc + (r - mean) ** 2, 0) / (returns.length - 1);
  return Math.sqrt(variance) * Math.sqrt(periodsPerYear);
}

const rates = await fetchSeries('EUR', 'USD', '2026-06-08', '2026-09-05', 'YOUR_API_KEY');
const vol = annualisedVolatility(logReturns(rates, 'USD'));
console.log(`Annualised volatility: ${(vol * 100).toFixed(2)}%`);

Repare no denominador (returns.length - 1) — a mesma correção de variância amostral da versão em Python.

Volatilidade móvel e como identificar uma mudança de regime

Um único número sobre uma janela fixa não diz quase nada sobre quando as coisas ficaram agitadas. A volatilidade móvel diz, e é a versão que você realmente quer em um dashboard.

def rolling_volatility(rates, symbol, window=30,
                       periods_per_year=FX_DAYS_PER_YEAR):
    dates = sorted(rates.keys())
    series = [rates[d][symbol] for d in dates]
    returns = [math.log(series[i] / series[i - 1]) for i in range(1, len(series))]
    return_dates = dates[1:]

    out = []
    for i in range(window - 1, len(returns)):
        chunk = returns[i - window + 1:i + 1]
        out.append((
            return_dates[i],
            statistics.stdev(chunk) * math.sqrt(periods_per_year),
        ))
    return out


for date, vol in rolling_volatility(rates, "USD", window=30)[-5:]:
    print("{}  {:.2%}".format(date, vol))

A escolha da janela é um trade-off, não um dogma:

• 10 dias — muito responsiva, muito ruidosa. Boa para alertas, ruim para precificação.
• 30 dias — o padrão mais comum. Reage em poucas sessões sem ficar oscilando à toa.
• 90 dias — suave e estável. Boa para definir índices de hedge e folgas de preço.

Um sinal prático de mudança de regime é a razão de volatilidade: divida a volatilidade de 10 dias pela de 90 dias. Leituras sustentadas acima de aproximadamente 1,5 indicam que a dispersão de curto prazo superou de forma relevante a linha de base mais longa. Aplicada aos pares com iene em torno dos episódios de intervenção descritos antes, essa razão dispara enquanto o número de 90 dias mal se mexe — que é exatamente a questão. Janelas longas escondem eventos; janelas curtas os encontram.

Se você pretende rodar isso continuamente em muitos pares, leia antes nossas notas sobre cache e tratamento de erros em APIs de câmbio. Taxas históricas diárias são imutáveis depois de publicadas, então podem ficar em cache indefinidamente — recalcule apenas a janela mais recente em vez de baixar de novo um ano de histórico a cada carregamento de página. A página de planos e preços mostra onde ficam os volumes de requisições em cada nível.

Transformando um número de volatilidade em uma decisão

Calcular volatilidade é fácil. Usá-la é onde está o valor. Quatro aplicações concretas:

1. Janelas de validade de cotação. Um preço que você mostra a um cliente é uma opção vendida que você emitiu para ele. O deslocamento esperado ao longo de um período de t dias é aproximadamente σ_annual × √(t / 260). A 8% de volatilidade anualizada, uma cotação de 24 horas carrega cerca de 0,5% de deslocamento esperado; a 20%, mais perto de 1,2%. Encurte o TTL quando a volatilidade subir, em vez de usar 15 minutos fixos para sempre.

1. Folgas de precificação. Em vez de cravar uma margem cambial de 2% no código, escale-a: buffer = k × σ_annual × √(settlement_days / 260). A folga se alarga automaticamente em regimes estressados e se estreita quando os mercados acalmam, o que mantém você competitivo sem assumir risco escondido.

1. Gatilhos de hedge. Exposição sozinha não é risco; risco é exposição vezes volatilidade. Uma exposição de US$ 2 milhões a um par com 4% de volatilidade é um problema menor do que US$ 400 mil em um par com 30%. Ordene as decisões de hedge por exposure × σ, não pelo nocional. Nosso guia sobre hedge cambial cobre os instrumentos; o número de volatilidade diz o que merece um.

1. Detecção de anomalias. Converta cada novo movimento diário em um z-score contra o desvio padrão dos 30 dias anteriores e alerte além de ±3. Isso captura tanto eventos genuínos de mercado quanto dados ruins — um feed travado ou um cruzamento mal triangulado costuma se denunciar como um outlier implausível antes que alguém perceba em um relatório.

Para expressar esses movimentos em unidades de mesa de operações em vez de porcentagens, veja o que é um pip.

Erros comuns

• Usar variação percentual em vez de retornos logarítmicos. Introduz assimetria e faz sua resposta depender da direção da cotação.
• Usar o desvio padrão populacional. numpy.std() sem ddof=1 subestima a volatilidade, e muito em janelas curtas.
• Preencher para frente fins de semana e feriados. Valores repetidos são dias de retorno zero que puxam a volatilidade para baixo mecanicamente.
• Anualizar com o N errado. Dados semanais anualizados com 260 em vez de 52 produzem um número cerca de 2,2× maior do que deveria.
• Comparar volatilidades calculadas a partir de horários de snapshot diferentes. Dois provedores, dois horários de fixing, dois números incomparáveis.
• Reportar um único número anual e chamá-lo de risco. A volatilidade se agrupa em clusters. Meses calmos e semanas violentas viram uma média intermediária que não descreve nenhum dos dois. Publique sempre uma série móvel ao lado do valor de destaque.
• Supor que baixa volatilidade significa baixo risco. Os regimes calmos e amigáveis ao carry de 2026 foram calmos até o exato momento em que as manchetes de intervenção moveram o iene 2% em uma sessão. Volatilidade realizada baixa é uma descrição do passado recente, não uma promessa sobre a semana que vem.

Perguntas frequentes

Qual é um nível normal de volatilidade para um par de moedas?

Pares principais como EUR/USD e GBP/USD historicamente rodaram entre 5% e 10% anualizados em condições calmas e entre 10% e 15% sob estresse. Pares emergentes costumam ficar duas a três vezes acima disso. Em vez de confiar em regras de bolso, calcule uma volatilidade móvel de 90 dias para os pares que te interessam e use sua própria linha de base — os níveis mudam com o regime.

Devo usar 252 ou 260 pregões para anualizar a volatilidade cambial?

260 se encaixa melhor, porque o mercado de câmbio negocia todo dia útil em vez de seguir o calendário de uma única bolsa. 252 é a convenção de ações e é bastante usada mesmo assim. A diferença é de cerca de 1,6% relativos, então o importante é escolher uma, documentar e aplicar de forma consistente em todo lugar onde você compare números.

Consigo calcular volatilidade implícita a partir de uma API de câmbio?

Não. A volatilidade implícita é extraída dos preços de opções de câmbio e exige um feed de dados de opções. O que você consegue calcular a partir de uma série de taxas à vista ou históricas é a volatilidade realizada. Para precificação, limites de hedge e alertas no código da aplicação, a volatilidade realizada costuma ser a medida apropriada.

De quantos dados históricos eu preciso?

No mínimo, uma observação a mais que o tamanho da sua janela — mas isso dá uma estimativa instável. Como piso prático, use 30 observações para uma janela de 30 dias e puxe pelo menos um ano de histórico para poder comparar a leitura atual com uma linha de base mais longa. O endpoint /v1/timeseries retorna um intervalo de datas arbitrário em uma única requisição.

Por que meu número de volatilidade difere do do meu provedor de dados?

Quase sempre por uma de quatro causas: um fator de anualização diferente (252 vs. 260), desvio padrão populacional em vez de amostral, um horário de snapshot diferente para a taxa diária, ou retornos simples em vez de logarítmicos. Verifique esses quatro antes de supor que os dados estão errados.

A volatilidade prevê em que direção uma moeda vai se mover?

Não. A volatilidade mede dispersão, não direção. Espera-se que um par com 20% de volatilidade anualizada se mova bastante; o cálculo não diz nada sobre se ele sobe ou desce. Use-a para dimensionar risco, não para tomar uma posição direcional.

Pronto para calcular volatilidade com dados ao vivo? Pegue sua chave gratuita da API da Finexly — sem cartão de crédito. Você tem acesso a taxas em tempo real e históricas de mais de 170 moedas, com 1.000 requisições gratuitas por mês e um endpoint /v1/timeseries que devolve um intervalo de datas completo em uma só chamada. Comece pela API gratuita de taxas de câmbio e evolua conforme suas necessidades de dados crescerem.