Cross-Rate de Moedas com PTAX Brasileiro: USD/EUR, GBP/EUR via API (2026)

Você precisa do histórico de EUR/USD mas só tem o PTAX do BCB brasileiro? A boa notícia: dá para derivar USD-EUR, GBP-EUR, JPY-USD e qualquer outro par entre as 10 moedas suportadas, dividindo as cotações contra o real. A brapi.dev faz isso por você em uma única requisição.

A maioria das APIs de câmbio brasileiras só oferece pares contra o real (USD-BRL, EUR-BRL, ...). Se você precisa de USD-EUR para uma análise de paridade ou hedge cambial, vira um mini-projeto: fazer duas requisições, juntar pelas datas, dividir.

Em maio de 2026, o /api/v2/currency/historical da brapi.dev passou a oferecer triangulação automática entre as 10 moedas suportadas — inclusive cross-rates onde nenhuma das duas é o real. Este post explica como funciona, quando faz sentido usar, e quando você deve preferir uma fonte externa de cotação.

O que é um cross-rate

Um cross-rate é uma cotação derivada entre duas moedas a partir de uma moeda intermediária. No nosso caso, todas as nossas séries são contra o real (BRL), então o cross-rate de duas moedas X e Y é:

X-Y = (X-BRL) / (Y-BRL)

Em cada data com observação em ambas as séries:

Date         USD-BRL  EUR-BRL  ⇒ USD-EUR (derivado)
2026-04-30   4.9886   5.6712   ⇒ 0.8797
2026-04-29   4.9712   5.6543   ⇒ 0.8792
2026-04-28   4.9854   5.6789   ⇒ 0.8779

Esses números seguem o PTAX brasileiro — não são exatamente o que sai em Bloomberg/Refinitiv (que usam outras bolsas e janelas de fixação), mas são consistentes com balanços e contratos no Brasil.

Endpoint: /api/v2/currency/historical

A brapi suporta três tipos de pares no histórico:

# Cross-rate: USD contra EUR via PTAX brasileiro
curl -H "Authorization: Bearer SEU_TOKEN" \
  "https://brapi.dev/api/v2/currency/historical?currency=USD-EUR"

{
  "results": [
    {
      "pair": "USD-EUR",
      "fromCurrency": "USD",
      "toCurrency": "EUR",
      "observations": [
        { "date": "2026-04-30", "value": 0.8797 },
        { "date": "2026-04-29", "value": 0.8792 }
      ]
    }
  ],
  "requestedAt": "2026-04-30T12:00:00.000Z",
  "took": 21
}

A API:

1. Identifica que USD-EUR não é uma série armazenada (nenhuma das duas moedas é BRL)
2. Resolve para o plano cross: lê USD-BRL e EUR-BRL no intervalo pedido
3. Faz o join pela data — só inclui dias com observação em ambas
4. Calcula value = USD-BRL ÷ EUR-BRL em cada dia

O resultado é uma série limpa, alinhada por data, pronta para gráfico ou back-test.

Múltiplos cross-rates em uma única chamada

curl -H "Authorization: Bearer SEU_TOKEN" \
  "https://brapi.dev/api/v2/currency/historical?currency=USD-EUR,GBP-EUR,JPY-USD,CHF-USD"

A API:

• Identifica todos os slugs base necessários (USD-BRL, EUR-BRL, GBP-BRL, JPY-BRL, CHF-BRL)
• Busca cada um uma única vez mesmo se aparece em múltiplos cross-rates
• Computa cada par e retorna alinhado

Você economiza requisições ao BCB e ao seu próprio servidor.

Inverso (1 / X-BRL)

Para "quanto vale 1 real em dólares" (BRL-USD):

curl -H "Authorization: Bearer SEU_TOKEN" \
  "https://brapi.dev/api/v2/currency/historical?currency=BRL-USD"

{
  "results": [
    {
      "pair": "BRL-USD",
      "fromCurrency": "BRL",
      "toCurrency": "USD",
      "observations": [
        { "date": "2026-04-30", "value": 0.20046 },
        { "date": "2026-04-29", "value": 0.20116 }
      ]
    }
  ]
}

0.20046 significa "1 BRL = 0,20046 USD" (≈ 20 centavos de dólar). É literalmente 1 / 4.9886.

Exemplo prático: paridade EUR/USD via Brasil

Veja como derivar a série EUR/USD nos últimos 5 anos:

TypeScript

type Observation = { date: string; value: number };
type HistoricalResponse = {
  results: Array<{
    pair: string;
    fromCurrency: string;
    toCurrency: string;
    observations: Observation[];
  }>;
  errors?: Array<{ pair: string; code: string; message: string }>;
};

async function fetchEurUsd5y(): Promise<Observation[]> {
  const today = new Date().toISOString().slice(0, 10);
  const past = new Date();
  past.setFullYear(past.getFullYear() - 5);
  const startDate = past.toISOString().slice(0, 10);

  const url = new URL('https://brapi.dev/api/v2/currency/historical');
  url.searchParams.set('currency', 'EUR-USD');
  url.searchParams.set('startDate', startDate);
  url.searchParams.set('endDate', today);
  url.searchParams.set('sortOrder', 'asc');
  url.searchParams.set('limit', '10000');

  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.BRAPI_TOKEN}` },
  });
  const data: HistoricalResponse = await res.json();

  if (data.errors?.length) {
    console.warn('Erros parciais:', data.errors);
  }

  return data.results.find((r) => r.pair === 'EUR-USD')?.observations ?? [];
}

const eurUsd = await fetchEurUsd5y();
console.log(`${eurUsd.length} pontos diários de EUR/USD via PTAX brasileiro`);
console.log('Último:', eurUsd[eurUsd.length - 1]);

Python: cesta global de cross-rates

import os
from datetime import date, timedelta
import requests

PAIRS = ['USD-EUR', 'USD-GBP', 'USD-JPY', 'USD-CHF', 'EUR-GBP', 'EUR-JPY']

def fetch_global_basket(years: int) -> dict[str, list[dict]]:
    end = date.today().isoformat()
    start = (date.today() - timedelta(days=365 * years)).isoformat()
    response = requests.get(
        'https://brapi.dev/api/v2/currency/historical',
        params={
            'currency': ','.join(PAIRS),
            'startDate': start,
            'endDate': end,
            'sortOrder': 'asc',
            'limit': 10000,
        },
        headers={'Authorization': f"Bearer {os.environ['BRAPI_TOKEN']}"},
    )
    response.raise_for_status()
    return {item['pair']: item['observations']
            for item in response.json()['results']}

basket = fetch_global_basket(years=5)
for pair, obs in basket.items():
    last = obs[-1] if obs else {}
    print(f"{pair}: {len(obs)} pts, último {last.get('date')} = {last.get('value')}")

Casos de uso reais

1. Análise de paridade

Comparar EUR-USD derivado do PTAX brasileiro com o EUR-USD de referência internacional (Refinitiv) ajuda a quantificar o "ruído" de fixação local. Em períodos de estresse, esse spread pode chegar a 0,5%.

2. Back-test de carteira multi-moeda

Se você tem carteira global (ações americanas, ETFs europeus, REITs asiáticos), o histórico de cross-rates permite computar o retorno em uma moeda-base sem precisar baixar dados de cada par separadamente.

3. Hedge cambial doméstico

Empresas com exposição a múltiplas moedas (ex: importadora que paga em EUR, exporta em USD) podem estimar o impacto cambial líquido a partir do cross-rate USD-EUR derivado do PTAX.

4. Análise acadêmica e de pesquisa

Para teses sobre integração cambial dos países emergentes, spillovers de política monetária internacional, ou modelos VAR de câmbio: o histórico PTAX-derivado oferece uma base consistente desde 1999 (ou 1984 quando USD está envolvido).

5. Aplicações fintech

Carteiras digitais, apps de remessa internacional e calculadoras de viagem podem mostrar "custaria X dólares por euro" usando a referência brasileira oficial.

Volatilidade e correlação a partir de cross-rates

Calcule volatilidade anualizada e correlação entre pares cruzados:

function logReturns(obs: Observation[]) {
  return obs.slice(1).map((o, i) => Math.log(o.value / obs[i].value));
}

function annualVolatility(returns: number[]) {
  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 * 252) * 100;
}

function correlation(a: number[], b: number[]) {
  const n = Math.min(a.length, b.length);
  const meanA = a.slice(0, n).reduce((x, y) => x + y, 0) / n;
  const meanB = b.slice(0, n).reduce((x, y) => x + y, 0) / n;
  let cov = 0, varA = 0, varB = 0;
  for (let i = 0; i < n; i++) {
    cov += (a[i] - meanA) * (b[i] - meanB);
    varA += (a[i] - meanA) ** 2;
    varB += (b[i] - meanB) ** 2;
  }
  return cov / Math.sqrt(varA * varB);
}

// Uso
const eurUsd = await fetchEurUsd5y();
const ret = logReturns(eurUsd);
console.log(`Volatilidade EUR-USD (PTAX): ${annualVolatility(ret).toFixed(2)}%`);

Erros comuns e cuidados

1. Esperar o PTAX coincidir com cotações internacionais. Não vai. PTAX é fixação brasileira, não Bloomberg fix.
2. Pedir cross-rate com cripto. BTC-USD não funciona em /historical. O endpoint só cobre as 10 moedas fiat suportadas pelo PTAX.
3. Esquecer da janela de datas. Cross-rates só existem em datas com observação em ambas as séries base. Se EUR-BRL tem observação em 2003 mas USD-BRL não tem, esse dia não aparecerá no EUR-USD derivado.
4. Usar plano Startup. Cross-rates e inverso requerem Pro. Pares diretos (X-BRL) ficam no Startup.
5. Pedir cross-rate trivial. USD-BRL é direto, não cross. Se você passar como cross, a API identifica corretamente — mas pedir USD-USD retorna erro UNSUPPORTED_PAIR.

Limitações honestas

• Não substitui feeds profissionais para trading. PTAX é referência oficial brasileira, divulgada uma vez ao dia (fechamento). Para estratégias intraday, você precisa de feeds em tempo real.
• Spread vs. mid-market. O PTAX é uma média ponderada das operações do dia, não um bid/ask. Para precificar exposição cambial real, ajuste com spread bancário.
• Janela de fixação. Diferentes mercados têm diferentes "fixings" (London 16:00, NY Close, BCB 13:00 BRT). Cross-rates derivados do PTAX refletem o fixing brasileiro.

Endpoints relacionados

• 💱 Documentação do /api/v2/currency/historical
• 📈 Histórico do dólar/euro/libra via PTAX (guia completo)
• 💵 Cotações em tempo real (/api/v2/currency)
• 🌎 API de Macroeconomia: Selic, IPCA e mais

Cross-rates derivados do PTAX brasileiro são úteis quando você precisa de consistência com a referência oficial brasileira sem pagar por feeds internacionais. Crie sua conta em brapi.dev, faça upgrade para Pro e teste com USD-EUR ou GBP-EUR.