ETFs de Dividendos Brasil 2026: DIVO11, NDIV11, DIVD11 - Guia Completo

Mês de Referência → Data Com → Pagamento
Ex: Janeiro → 28/jan → 05/fev

Rendimento = Dividendos das ações + Prêmio das opções vendidas

import requests
import pandas as pd

def comparar_etfs_dividendos(token: str) -> pd.DataFrame:
    """
    Compara ETFs de dividendos usando brapi.dev
    """
    etfs = ["DIVO11", "DIVD11", "NDIV11", "SPYI11"]
    url = f"https://brapi.dev/api/quote/{','.join(etfs)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    comparativo = []
    for etf in data["results"]:
        comparativo.append({
            "ETF": etf["symbol"],
            "Preço": f"R$ {etf['regularMarketPrice']:.2f}",
            "Variação Dia": f"{etf['regularMarketChangePercent']:.2f}%",
            "Mín 52 sem": f"R$ {etf.get('fiftyTwoWeekLow', 0):.2f}",
            "Máx 52 sem": f"R$ {etf.get('fiftyTwoWeekHigh', 0):.2f}",
        })
    
    return pd.DataFrame(comparativo)

# Comparar ETFs
df = comparar_etfs_dividendos("SEU_TOKEN")
print(df.to_string(index=False))

import requests

def calcular_renda_etf_dividendos(
    etf: str,
    valor_investido: float,
    dy_anual: float,
    token: str
) -> dict:
    """
    Calcula renda mensal esperada de ETF de dividendos
    """
    # Buscar preço atual
    url = f"https://brapi.dev/api/quote/{etf}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    preco = data["results"][0]["regularMarketPrice"]
    nome = data["results"][0]["shortName"]
    
    # Calcular cotas e renda
    cotas = int(valor_investido // preco)
    valor_real = cotas * preco
    
    renda_anual = valor_real * (dy_anual / 100)
    renda_mensal = renda_anual / 12
    
    return {
        "etf": etf,
        "nome": nome,
        "preco_cota": preco,
        "cotas": cotas,
        "valor_investido": valor_real,
        "dy_anual": dy_anual,
        "renda_anual": renda_anual,
        "renda_mensal": renda_mensal
    }

# Exemplo: R$ 50.000 em DIVD11 (DY 8%)
resultado = calcular_renda_etf_dividendos("DIVD11", 50000, 8.0, "SEU_TOKEN")

print(f"\n{'='*50}")
print(f"SIMULAÇÃO DE RENDA PASSIVA COM ETF")
print(f"{'='*50}")
print(f"ETF: {resultado['etf']}")
print(f"Preço da cota: R$ {resultado['preco_cota']:.2f}")
print(f"Cotas adquiridas: {resultado['cotas']}")
print(f"Valor investido: R$ {resultado['valor_investido']:.2f}")
print(f"Dividend yield: {resultado['dy_anual']}% a.a.")
print(f"\nRenda anual esperada: R$ {resultado['renda_anual']:.2f}")
print(f"Renda mensal esperada: R$ {resultado['renda_mensal']:.2f}")

def estrategia_acumulacao_divo11(
    aporte_mensal: float,
    anos: int,
    taxa_crescimento: float,  # % a.a.
    token: str
) -> dict:
    """
    Simula acumulação com DIVO11 (reinvestimento automático)
    """
    import requests
    
    url = "https://brapi.dev/api/quote/DIVO11"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    preco = response.json()["results"][0]["regularMarketPrice"]
    
    # Simulação mês a mês
    meses = anos * 12
    patrimonio = 0
    cotas_totais = 0
    taxa_mensal = (1 + taxa_crescimento/100) ** (1/12) - 1
    
    for mes in range(meses):
        # Compra cotas
        cotas = aporte_mensal // preco
        cotas_totais += cotas
        
        # Valorização do patrimônio
        patrimonio = cotas_totais * preco * ((1 + taxa_mensal) ** (mes + 1))
    
    total_aportado = aporte_mensal * meses
    ganho = patrimonio - total_aportado
    
    return {
        "anos": anos,
        "aporte_mensal": aporte_mensal,
        "total_aportado": total_aportado,
        "patrimonio_final": patrimonio,
        "ganho": ganho,
        "cotas_totais": cotas_totais
    }

# Exemplo: R$ 1.000/mês por 10 anos, crescimento 10% a.a.
resultado = estrategia_acumulacao_divo11(1000, 10, 10, "SEU_TOKEN")
print(f"Total aportado: R$ {resultado['total_aportado']:,.2f}")
print(f"Patrimônio final: R$ {resultado['patrimonio_final']:,.2f}")
print(f"Ganho: R$ {resultado['ganho']:,.2f}")

def estrategia_renda_passiva(
    patrimonio: float,
    etf: str,
    dy: float,
    anos_renda: int,
    token: str
) -> None:
    """
    Projeta renda passiva ao longo dos anos
    """
    import requests
    
    url = f"https://brapi.dev/api/quote/{etf}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    preco = response.json()["results"][0]["regularMarketPrice"]
    
    cotas = int(patrimonio // preco)
    valor_investido = cotas * preco
    
    print(f"\n{'='*60}")
    print(f"PROJEÇÃO DE RENDA PASSIVA - {etf}")
    print(f"{'='*60}")
    print(f"Patrimônio: R$ {valor_investido:,.2f}")
    print(f"Cotas: {cotas:,}")
    print(f"Dividend yield: {dy}% a.a.")
    print(f"\n{'Ano':<6} {'Renda Anual':<15} {'Renda Mensal':<15}")
    print("-" * 40)
    
    for ano in range(1, anos_renda + 1):
        renda_anual = valor_investido * (dy / 100)
        renda_mensal = renda_anual / 12
        print(f"{ano:<6} R$ {renda_anual:>10,.2f}   R$ {renda_mensal:>10,.2f}")

# R$ 500.000 em DIVD11 por 10 anos
estrategia_renda_passiva(500000, "DIVD11", 8.0, 10, "SEU_TOKEN")

portfolio_hibrido = {
    "DIVO11": 0.30,  # 30% - Acumulação Brasil
    "DIVD11": 0.30,  # 30% - Renda Brasil
    "SPYI11": 0.40,  # 40% - Renda EUA + Hedge
}

valor_total = 100000

print("PORTFÓLIO HÍBRIDO DE DIVIDENDOS")
print("=" * 50)
for etf, percentual in portfolio_hibrido.items():
    valor = valor_total * percentual
    print(f"{etf}: R$ {valor:,.2f} ({percentual*100:.0f}%)")

# DY ponderado estimado
dy_ponderado = (0.30 * 0) + (0.30 * 8) + (0.40 * 13)
renda_anual = valor_total * dy_ponderado / 100
print(f"\nDY ponderado estimado: {dy_ponderado:.1f}%")
print(f"Renda anual estimada: R$ {renda_anual:,.2f}")
print(f"Renda mensal estimada: R$ {renda_anual/12:,.2f}")

BENS E DIREITOS
Grupo: 07 - Fundos
Código: 09 - Demais Fundos de Índice de Mercado (ETFs)

Discriminação:
"X cotas do ETF DIVD11 - IT Now IDIV Renda Dividendos
CNPJ: XX.XXX.XXX/XXXX-XX
Custodiante: [Nome da Corretora]
Custo de aquisição: R$ X.XXX,XX"

RENDIMENTOS
- Dividendos recebidos: declarar conforme informe de rendimentos
- Ganhos de capital: calcular e pagar DARF até último dia útil do mês seguinte

def comparar_carteira_vs_etf(
    valor: float,
    acoes: list,
    etf: str,
    token: str
) -> None:
    """
    Compara montar carteira própria vs comprar ETF
    """
    import requests
    
    # Buscar dados das ações
    acoes_str = ",".join(acoes)
    url_acoes = f"https://brapi.dev/api/quote/{acoes_str}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url_acoes, headers=headers)
    dados_acoes = response.json()["results"]
    
    # Buscar dados do ETF
    url_etf = f"https://brapi.dev/api/quote/{etf}"
    response = requests.get(url_etf, headers=headers)
    dados_etf = response.json()["results"][0]
    
    print("\nCARTEIRA PRÓPRIA DE DIVIDENDOS")
    print("-" * 50)
    valor_por_acao = valor / len(acoes)
    total_carteira = 0
    
    for acao in dados_acoes:
        preco = acao["regularMarketPrice"]
        cotas = int(valor_por_acao // preco)
        subtotal = cotas * preco
        total_carteira += subtotal
        print(f"{acao['symbol']}: {cotas} cotas = R$ {subtotal:.2f}")
    
    print(f"\nTotal na carteira: R$ {total_carteira:.2f}")
    print(f"Sobra: R$ {valor - total_carteira:.2f}")
    
    print(f"\nETF {etf}")
    print("-" * 50)
    preco_etf = dados_etf["regularMarketPrice"]
    cotas_etf = int(valor // preco_etf)
    total_etf = cotas_etf * preco_etf
    
    print(f"{etf}: {cotas_etf} cotas = R$ {total_etf:.2f}")
    print(f"Sobra: R$ {valor - total_etf:.2f}")

# Comparar 6 ações de dividendos vs DIVD11
acoes_dividendos = ["TAEE11", "BBAS3", "ITSA4", "CPLE6", "CMIG4", "BBSE3"]
comparar_carteira_vs_etf(30000, acoes_dividendos, "DIVD11", "SEU_TOKEN")

import requests
from datetime import datetime

def dashboard_etfs_dividendos(token: str) -> None:
    """
    Dashboard completo de ETFs de dividendos
    """
    etfs = ["DIVO11", "DIVD11", "NDIV11", "SPYI11"]
    url = f"https://brapi.dev/api/quote/{','.join(etfs)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    print("\n" + "=" * 70)
    print(f"DASHBOARD ETFs DE DIVIDENDOS - {datetime.now().strftime('%d/%m/%Y %H:%M')}")
    print("=" * 70)
    
    print(f"\n{'ETF':<10} {'Preço':<12} {'Variação':<10} {'Mín 52s':<12} {'Máx 52s':<12}")
    print("-" * 70)
    
    for etf in data["results"]:
        symbol = etf["symbol"]
        preco = etf["regularMarketPrice"]
        variacao = etf.get("regularMarketChangePercent", 0)
        min_52 = etf.get("fiftyTwoWeekLow", 0)
        max_52 = etf.get("fiftyTwoWeekHigh", 0)
        
        # Indicador de tendência
        sinal = "+" if variacao > 0 else ""
        
        print(f"{symbol:<10} R$ {preco:<8.2f} {sinal}{variacao:<8.2f}% R$ {min_52:<8.2f} R$ {max_52:<8.2f}")
    
    print("-" * 70)
    print("\nDados fornecidos por brapi.dev")

# Executar dashboard
dashboard_etfs_dividendos("SEU_TOKEN")

def verificar_oportunidades_compra(
    etfs_config: dict,
    token: str
) -> list:
    """
    Verifica se ETFs estão em preço atrativo para compra
    
    etfs_config: {"DIVO11": 110.0, "DIVD11": 55.0}  # preços-alvo
    """
    import requests
    
    etfs = list(etfs_config.keys())
    url = f"https://brapi.dev/api/quote/{','.join(etfs)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    oportunidades = []
    
    for etf in data["results"]:
        symbol = etf["symbol"]
        preco_atual = etf["regularMarketPrice"]
        preco_alvo = etfs_config[symbol]
        
        if preco_atual <= preco_alvo:
            desconto = ((preco_alvo - preco_atual) / preco_alvo) * 100
            oportunidades.append({
                "etf": symbol,
                "preco_atual": preco_atual,
                "preco_alvo": preco_alvo,
                "desconto": desconto
            })
    
    return oportunidades

# Verificar oportunidades
config = {
    "DIVO11": 120.0,
    "DIVD11": 62.0,
    "NDIV11": 125.0,
    "SPYI11": 118.0
}

oportunidades = verificar_oportunidades_compra(config, "SEU_TOKEN")

if oportunidades:
    print("\nOPORTUNIDADES DE COMPRA DETECTADAS!")
    for op in oportunidades:
        print(f"{op['etf']}: R$ {op['preco_atual']:.2f} ({op['desconto']:.1f}% abaixo do alvo)")
else:
    print("\nNenhuma oportunidade no momento.")