BDRs 2026: Como Investir em Ações Americanas Sem Sair do Brasil

Empresa no Exterior (ex: Apple nos EUA)
              ↓
    Instituição Depositária
    (banco que custodia as ações)
              ↓
    Emite BDRs no Brasil
              ↓
    Negociado na B3 (AAPL34)
              ↓
    Você compra pelo Home Broker

import requests

def pesquisar_bdrs(token: str, tipo: str = "bdr"):
    """
    Lista BDRs disponíveis na B3
    """
    url = "https://brapi.dev/api/quote/list"
    params = {"type": tipo, "limit": 50}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    print(f"Total de BDRs: {data['totalCount']}")
    print("\nPrimeiros 10 BDRs:")
    
    for stock in data["stocks"][:10]:
        print(f"  {stock['stock']:8} - {stock['name'][:40]}")
    
    return data

bdrs = pesquisar_bdrs("SEU_TOKEN", "bdr")

import requests

def analisar_bdr(symbol: str, token: str):
    """
    Análise detalhada de um BDR
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    bdr = data["results"][0]
    
    print(f"=== {bdr['symbol']} - {bdr['shortName']} ===")
    print(f"\nPreço: R$ {bdr['regularMarketPrice']:.2f}")
    print(f"Variação dia: {bdr['regularMarketChangePercent']:.2f}%")
    print(f"Volume: {bdr['regularMarketVolume']:,}")
    print(f"\nMínima 52 sem: R$ {bdr.get('fiftyTwoWeekLow', 'N/A')}")
    print(f"Máxima 52 sem: R$ {bdr.get('fiftyTwoWeekHigh', 'N/A')}")
    
    return bdr

apple = analisar_bdr("AAPL34", "SEU_TOKEN")

Ativo: AAPL34
Tipo: Compra
Quantidade: 10 BDRs
Preço: A mercado (ou limite)
Validade: Dia

import requests

def acompanhar_carteira_bdrs(bdrs: list, token: str):
    """
    Monitora carteira de BDRs em tempo real
    """
    symbols = ",".join(bdrs)
    url = f"https://brapi.dev/api/quote/{symbols}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    print("=" * 70)
    print(f"{'BDR':<10} {'Preço':>12} {'Var %':>10} {'Volume':>15}")
    print("=" * 70)
    
    for bdr in data["results"]:
        var = bdr.get('regularMarketChangePercent', 0)
        var_str = f"+{var:.2f}%" if var >= 0 else f"{var:.2f}%"
        print(f"{bdr['symbol']:<10} R$ {bdr['regularMarketPrice']:>8.2f} {var_str:>10} {bdr['regularMarketVolume']:>15,}")
    
    print("=" * 70)

# Monitorar carteira
minha_carteira = ["AAPL34", "MSFT34", "GOGL34", "AMZO34", "TSLA34"]
acompanhar_carteira_bdrs(minha_carteira, "SEU_TOKEN")

def calcular_ir_bdr(preco_compra: float, preco_venda: float, quantidade: int):
    """
    Calcula IR sobre ganho de capital em BDRs
    """
    valor_compra = preco_compra * quantidade
    valor_venda = preco_venda * quantidade
    lucro = valor_venda - valor_compra
    
    # Verifica isenção (vendas até R$ 20.000/mês)
    if valor_venda <= 20000 and lucro > 0:
        ir = 0
        isento = True
    else:
        ir = lucro * 0.15 if lucro > 0 else 0
        isento = False
    
    print(f"Compra: R$ {valor_compra:.2f}")
    print(f"Venda: R$ {valor_venda:.2f}")
    print(f"Lucro: R$ {lucro:.2f}")
    print(f"Isento: {'Sim' if isento else 'Não'}")
    print(f"IR a pagar: R$ {ir:.2f}")
    
    return ir

# Exemplo: Comprou 50 AAPL34 a R$ 180, vendeu a R$ 220
calcular_ir_bdr(180, 220, 50)

Grupo: 04 - Aplicações e Investimentos
Código: 04 - Ativos negociados em bolsa no Brasil (BDRs)

Discriminação:
"50 BDRs de AAPL34 (Apple Inc.)
Instituição: [Nome da Corretora]
CNPJ Corretora: XX.XXX.XXX/XXXX-XX
Custo total de aquisição: R$ 9.000,00"

Situação em 31/12/2024: R$ 9.000,00
Situação em 31/12/2026: R$ 11.000,00 (se manteve)

Programa GCAP ou Carnê-Leão Web
Mês da venda: [Mês]
Valor de alienação: R$ XX.XXX,XX
Custo de aquisição: R$ XX.XXX,XX
Ganho de capital: R$ X.XXX,XX
Imposto devido: R$ XXX,XX (15%)

portfolio_bigtech = {
    "AAPL34": 0.20,   # Apple
    "MSFT34": 0.20,   # Microsoft
    "GOGL34": 0.15,   # Google
    "AMZO34": 0.15,   # Amazon
    "NVDC34": 0.15,   # Nvidia
    "META34": 0.15,   # Meta
}

valor_total = 10000

print("Portfólio Big Techs")
print("=" * 40)
for bdr, peso in portfolio_bigtech.items():
    valor = valor_total * peso
    print(f"{bdr}: R$ {valor:.2f} ({peso*100:.0f}%)")

portfolio_dividendos = {
    "COCA34": 0.15,   # Coca-Cola (Dividend Aristocrat)
    "JNJB34": 0.15,   # Johnson & Johnson
    "PGCO34": 0.15,   # Procter & Gamble
    "MCDC34": 0.15,   # McDonald's
    "JPMC34": 0.15,   # JPMorgan
    "VISA34": 0.15,   # Visa
    "MSFT34": 0.10,   # Microsoft
}

portfolio_setorial = {
    # Tecnologia (40%)
    "AAPL34": 0.15,
    "MSFT34": 0.15,
    "NVDC34": 0.10,
    
    # Financeiro (20%)
    "VISA34": 0.10,
    "JPMC34": 0.10,
    
    # Consumo (20%)
    "AMZO34": 0.10,
    "MCDC34": 0.10,
    
    # Saúde (10%)
    "JNJB34": 0.10,
    
    # Energia (10%)
    "XOMI34": 0.10,
}

import requests

def planejar_dca_bdrs(bdrs: dict, aporte_mensal: float, token: str):
    """
    Planeja aportes mensais em BDRs
    """
    symbols = ",".join(bdrs.keys())
    url = f"https://brapi.dev/api/quote/{symbols}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    precos = {r["symbol"]: r["regularMarketPrice"] for r in data["results"]}
    
    print(f"Aporte mensal: R$ {aporte_mensal:.2f}")
    print("=" * 60)
    
    total_alocado = 0
    for bdr, peso in bdrs.items():
        valor = aporte_mensal * peso
        preco = precos.get(bdr, 0)
        if preco > 0:
            cotas = int(valor // preco)
            gasto = cotas * preco
            total_alocado += gasto
            print(f"{bdr}: R$ {valor:.2f} → {cotas} cotas (R$ {gasto:.2f})")
    
    print("=" * 60)
    print(f"Total alocado: R$ {total_alocado:.2f}")
    print(f"Sobra: R$ {aporte_mensal - total_alocado:.2f}")

# Planejar DCA de R$ 1.000/mês
portfolio = {
    "AAPL34": 0.30,
    "MSFT34": 0.30,
    "GOGL34": 0.20,
    "AMZO34": 0.20,
}

planejar_dca_bdrs(portfolio, 1000, "SEU_TOKEN")

import requests
import pandas as pd

def comparar_bdrs(bdrs: list, token: str):
    """
    Compara múltiplos BDRs em uma tabela
    """
    url = f"https://brapi.dev/api/quote/{','.join(bdrs)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    comparativo = []
    for bdr in data["results"]:
        comparativo.append({
            "Símbolo": bdr["symbol"],
            "Nome": bdr["shortName"][:25],
            "Preço": f"R$ {bdr['regularMarketPrice']:.2f}",
            "Var %": f"{bdr.get('regularMarketChangePercent', 0):.2f}%",
            "Mín 52s": bdr.get("fiftyTwoWeekLow", "-"),
            "Máx 52s": bdr.get("fiftyTwoWeekHigh", "-"),
        })
    
    df = pd.DataFrame(comparativo)
    print(df.to_string(index=False))
    return df

# Comparar big techs
comparar_bdrs(["AAPL34", "MSFT34", "GOGL34", "AMZO34", "NVDC34"], "SEU_TOKEN")

import requests
import matplotlib.pyplot as plt

def grafico_bdr(symbol: str, periodo: str, token: str):
    """
    Gera gráfico histórico do BDR
    periodo: 1mo, 3mo, 6mo, 1y, 2y, 5y
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"range": periodo, "interval": "1d"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    historico = data["results"][0].get("historicalDataPrice", [])
    
    datas = [h["date"] for h in historico]
    precos = [h["close"] for h in historico]
    
    plt.figure(figsize=(12, 6))
    plt.plot(datas, precos, 'b-', linewidth=1.5)
    plt.title(f"{symbol} - Últimos {periodo}")
    plt.xlabel("Data")
    plt.ylabel("Preço (R$)")
    plt.grid(True, alpha=0.3)
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()
    
    return datas, precos

# Gráfico de 1 ano da Apple
grafico_bdr("AAPL34", "1y", "SEU_TOKEN")

import requests

def screener_bdrs(
    token: str,
    ordem: str = "volume",
    limite: int = 20
):
    """
    Filtra BDRs por critérios
    """
    url = "https://brapi.dev/api/quote/list"
    params = {
        "type": "bdr",
        "sortBy": ordem,
        "sortOrder": "desc",
        "limit": limite
    }
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    print(f"Top {limite} BDRs por {ordem}")
    print("=" * 50)
    
    for i, bdr in enumerate(data["stocks"], 1):
        print(f"{i:2}. {bdr['stock']:8} - {bdr['name'][:35]}")
    
    return data["stocks"]

# Top 20 BDRs por volume
screener_bdrs("SEU_TOKEN", "volume", 20)

import requests

def montar_portfolio_global(valor_total: float, token: str):
    """
    Monta portfólio diversificado globalmente com BDRs
    """
    # Alocação por setor/região
    alocacao = {
        # Tecnologia EUA (35%)
        "AAPL34": 0.12,
        "MSFT34": 0.12,
        "NVDC34": 0.11,
        
        # Consumo/Varejo EUA (20%)
        "AMZO34": 0.10,
        "MCDC34": 0.05,
        "COCA34": 0.05,
        
        # Financeiro EUA (15%)
        "VISA34": 0.08,
        "JPMC34": 0.07,
        
        # Saúde EUA (10%)
        "JNJB34": 0.10,
        
        # Asia (10%)
        "BABA34": 0.05,
        "TSMC34": 0.05,
        
        # Energia (10%)
        "XOMI34": 0.10,
    }
    
    symbols = ",".join(alocacao.keys())
    url = f"https://brapi.dev/api/quote/{symbols}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    precos = {r["symbol"]: r["regularMarketPrice"] for r in data["results"]}
    
    print(f"Portfólio Global - R$ {valor_total:,.2f}")
    print("=" * 65)
    
    total_real = 0
    for bdr, peso in alocacao.items():
        valor_alvo = valor_total * peso
        preco = precos.get(bdr, 100)
        cotas = int(valor_alvo // preco)
        valor_real = cotas * preco
        total_real += valor_real
        
        print(f"{bdr}: {peso*100:4.0f}% → R$ {valor_alvo:>8.2f} → {cotas:3} cotas → R$ {valor_real:>8.2f}")
    
    print("=" * 65)
    print(f"Total investido: R$ {total_real:,.2f}")
    print(f"Sobra: R$ {valor_total - total_real:,.2f}")

montar_portfolio_global(10000, "SEU_TOKEN")