Dividendos 2026: Como Construir Renda Passiva com Ações que Pagam Proventos

def poder_dos_dividendos():
    """
    Demonstra o poder dos dividendos reinvestidos
    """
    # Cenário: R$ 100.000 investidos, DY 6%, sem crescimento de preço
    valor_inicial = 100000
    dividend_yield = 0.06
    anos = 20
    
    # Sem reinvestir
    renda_anual_simples = valor_inicial * dividend_yield
    total_simples = valor_inicial + (renda_anual_simples * anos)
    
    # Reinvestindo (juros compostos)
    valor_composto = valor_inicial
    for ano in range(anos):
        dividendo = valor_composto * dividend_yield
        valor_composto += dividendo
    
    print("Cenário: R$ 100.000 | DY: 6% | 20 anos")
    print("=" * 50)
    print(f"\n❌ SEM reinvestir dividendos:")
    print(f"   Renda anual: R$ {renda_anual_simples:,.0f}")
    print(f"   Patrimônio final: R$ {total_simples:,.0f}")
    
    print(f"\n✅ COM reinvestimento (juros compostos):")
    print(f"   Patrimônio final: R$ {valor_composto:,.0f}")
    print(f"   Renda anual no ano 20: R$ {valor_composto * dividend_yield:,.0f}")
    
    print(f"\nDiferença: R$ {valor_composto - total_simples:,.0f} a mais!")

poder_dos_dividendos()

1. Empresa apura lucro
        ↓
2. Conselho aprova distribuição
        ↓
3. Divulga: Data Com, Data Ex, Data de Pagamento
        ↓
4. Quem tiver ações na Data Com recebe
        ↓
5. Na Data Ex, ação abre descontada
        ↓
6. Pagamento na data anunciada

def exemplo_dividendo():
    """
    Exemplo de como funciona um dividendo na prática
    """
    # Empresa XYZ anuncia dividendo
    preco_acao = 50.00
    dividendo_por_acao = 2.50
    dy = dividendo_por_acao / preco_acao
    
    print("=== EXEMPLO: Ação XYZ ===")
    print(f"Preço antes do dividendo: R$ {preco_acao:.2f}")
    print(f"Dividendo anunciado: R$ {dividendo_por_acao:.2f} por ação")
    print(f"Dividend Yield: {dy*100:.1f}%")
    
    print("\n--- Cronograma ---")
    print("15/01 - Data Com: último dia para comprar")
    print("16/01 - Data Ex: ação abre a R$ 47,50 (desconto do dividendo)")
    print("30/01 - Pagamento: R$ 2,50 por ação na conta")
    
    print("\n--- Se você tem 100 ações ---")
    print(f"Antes: 100 ações x R$ 50,00 = R$ 5.000,00")
    print(f"Depois: 100 ações x R$ 47,50 = R$ 4.750,00 + R$ 250 em dividendos")
    print(f"Total: R$ 5.000,00 (mesmo valor, só mudou de lugar)")

exemplo_dividendo()

import requests

def calcular_dividend_yield(symbol: str, token: str):
    """
    Busca e analisa Dividend Yield de uma ação
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"fundamental": "true", "dividends": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    
    preco = acao["regularMarketPrice"]
    dy = acao.get("dividendYield")
    
    print(f"=== {symbol} ===")
    print(f"Preço: R$ {preco:.2f}")
    
    if dy:
        dividendo_anual = preco * dy
        dividendo_mensal = dividendo_anual / 12
        
        print(f"Dividend Yield: {dy*100:.2f}%")
        print(f"Dividendo anual estimado: R$ {dividendo_anual:.2f} por ação")
        print(f"Dividendo mensal médio: R$ {dividendo_mensal:.2f} por ação")
        
        # Quanto preciso para R$ 1.000/mês?
        acoes_necessarias = 1000 / dividendo_mensal
        investimento = acoes_necessarias * preco
        
        print(f"\nPara receber R$ 1.000/mês:")
        print(f"  Ações necessárias: {acoes_necessarias:,.0f}")
        print(f"  Investimento: R$ {investimento:,.2f}")
    
    return dy

calcular_dividend_yield("TAEE11", "SEU_TOKEN")

def analisar_payout(lucro_por_acao: float, dividendo_por_acao: float):
    """
    Calcula e analisa o payout ratio
    """
    payout = (dividendo_por_acao / lucro_por_acao) * 100
    
    print(f"LPA (Lucro/Ação): R$ {lucro_por_acao:.2f}")
    print(f"Dividendo/Ação: R$ {dividendo_por_acao:.2f}")
    print(f"Payout: {payout:.0f}%")
    
    if payout < 50:
        print("✅ Payout conservador - empresa retém lucros para crescer")
    elif payout < 80:
        print("⚠️ Payout moderado - equilíbrio entre dividendos e crescimento")
    elif payout <= 100:
        print("⚠️ Payout alto - pouco reinvestimento")
    else:
        print("🔴 Payout > 100% - insustentável no longo prazo!")
    
    return payout

# Empresa com LPA de R$ 5 e dividendo de R$ 4
analisar_payout(5.00, 4.00)

import requests

def ranking_dividendos(token: str, top_n: int = 20):
    """
    Ranking das melhores pagadoras de dividendos
    """
    url = "https://brapi.dev/api/quote/list"
    params = {"type": "stock", "sortBy": "dividendYield", "sortOrder": "desc", "limit": 50}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    lista = response.json()
    
    acoes_validas = []
    
    for stock in lista.get("stocks", []):
        symbol = stock["stock"]
        
        try:
            url = f"https://brapi.dev/api/quote/{symbol}"
            params = {"fundamental": "true"}
            response = requests.get(url, params=params, headers=headers)
            data = response.json()
            
            if not data["results"]:
                continue
            
            acao = data["results"][0]
            dy = acao.get("dividendYield")
            
            if dy and dy > 0.03 and dy < 0.20:  # DY entre 3% e 20%
                acoes_validas.append({
                    "symbol": symbol,
                    "name": acao["shortName"][:25],
                    "preco": acao["regularMarketPrice"],
                    "dy": dy * 100
                })
        except:
            continue
    
    # Ordenar por DY
    acoes_validas.sort(key=lambda x: x["dy"], reverse=True)
    
    print("=== RANKING DIVIDEND YIELD ===")
    print(f"{'#':>3} {'Ticker':8} {'DY%':>7} {'Preço':>10}")
    print("-" * 35)
    
    for i, a in enumerate(acoes_validas[:top_n], 1):
        print(f"{i:3} {a['symbol']:8} {a['dy']:6.2f}% R$ {a['preco']:>8.2f}")
    
    return acoes_validas[:top_n]

# Top 20 pagadoras
top = ranking_dividendos("SEU_TOKEN", 20)

import requests

def calculadora_renda_passiva(
    renda_mensal_desejada: float,
    dy_medio: float,
    anos_acumulacao: int,
    aporte_mensal: float,
    token: str
):
    """
    Calcula quanto investir para atingir renda passiva desejada
    """
    print("=" * 55)
    print("CALCULADORA DE RENDA PASSIVA")
    print("=" * 55)
    
    # Patrimônio necessário para a renda
    renda_anual = renda_mensal_desejada * 12
    patrimonio_necessario = renda_anual / dy_medio
    
    print(f"\nMeta: R$ {renda_mensal_desejada:,.2f}/mês")
    print(f"Dividend Yield médio: {dy_medio*100:.1f}%")
    print(f"Patrimônio necessário: R$ {patrimonio_necessario:,.2f}")
    
    # Simulação de acumulação
    patrimonio = 0
    for ano in range(1, anos_acumulacao + 1):
        for mes in range(12):
            # Aporte
            patrimonio += aporte_mensal
            # Dividendos (reinvestidos)
            patrimonio *= (1 + dy_medio/12)
    
    renda_alcancada = patrimonio * dy_medio / 12
    
    print(f"\n--- Simulação de Acumulação ---")
    print(f"Aporte mensal: R$ {aporte_mensal:,.2f}")
    print(f"Período: {anos_acumulacao} anos")
    print(f"Total aportado: R$ {aporte_mensal * 12 * anos_acumulacao:,.2f}")
    print(f"Patrimônio acumulado: R$ {patrimonio:,.2f}")
    print(f"Renda mensal alcançada: R$ {renda_alcancada:,.2f}")
    
    if renda_alcancada >= renda_mensal_desejada:
        print(f"\n✅ META ALCANÇADA em {anos_acumulacao} anos!")
    else:
        faltante = renda_mensal_desejada - renda_alcancada
        patrimonio_faltante = faltante * 12 / dy_medio
        print(f"\n⚠️ Falta R$ {faltante:,.2f}/mês")
        print(f"Patrimônio adicional necessário: R$ {patrimonio_faltante:,.2f}")
    
    return patrimonio, renda_alcancada

# Meta: R$ 5.000/mês | DY: 7% | 20 anos | Aporte: R$ 2.000/mês
calculadora_renda_passiva(5000, 0.07, 20, 2000, "SEU_TOKEN")

carteira_renda = {
    # Transmissão (35%)
    "TAEE11": 0.15,
    "TRPL4": 0.10,
    "CPLE6": 0.10,
    
    # Bancos (25%)
    "BBAS3": 0.15,
    "ITUB4": 0.10,
    
    # Seguros (15%)
    "BBSE3": 0.15,
    
    # Energia (15%)
    "EGIE3": 0.10,
    "CMIG4": 0.05,
    
    # Telecom (10%)
    "VIVT3": 0.10
}

print("Carteira Foco em Renda")
print("Meta: DY médio > 7%")
print("-" * 40)
for ticker, peso in carteira_renda.items():
    print(f"{ticker}: {peso*100:.0f}%")

carteira_crescimento_dividendos = {
    # Crescimento + Dividendos
    "WEGE3": 0.15,   # Cresce dividendo 10%+ a.a.
    "ITUB4": 0.15,   # Dividendo crescente
    "BBSE3": 0.15,   # Payout alto, lucro crescente
    "EGIE3": 0.15,   # Energia limpa + dividendos
    "TAEE11": 0.15,  # Transmissão estável
    "VALE3": 0.10,   # Dividendos cíclicos altos
    "VIVT3": 0.15,   # Telecom + dividendos
}

carteira_barbell = {
    # Alto DY (60%)
    "TAEE11": 0.20,
    "BBAS3": 0.20,
    "BBSE3": 0.20,
    
    # Growth (40%)
    "WEGE3": 0.15,
    "PRIO3": 0.15,
    "TOTS3": 0.10
}

import requests
from datetime import datetime

def historico_dividendos(symbol: str, token: str):
    """
    Busca histórico de dividendos de uma ação
    """
    url = f"https://brapi.dev/api/quote/{symbol}"
    params = {"dividends": "true", "range": "5y"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    acao = data["results"][0]
    dividendos = acao.get("dividendsData", {}).get("cashDividends", [])
    
    print(f"=== HISTÓRICO DE DIVIDENDOS: {symbol} ===")
    print(f"{'Data':<12} {'Tipo':<12} {'Valor':>10}")
    print("-" * 36)
    
    total_5_anos = 0
    for div in dividendos[-20:]:  # Últimos 20
        data = div.get("paymentDate", "N/A")[:10]
        tipo = div.get("type", "DIVIDENDO")
        valor = div.get("value", 0)
        total_5_anos += valor
        
        print(f"{data:<12} {tipo:<12} R$ {valor:>8.4f}")
    
    print("-" * 36)
    print(f"Total últimos 5 anos: R$ {total_5_anos:.2f} por ação")
    
    return dividendos

historico_dividendos("TAEE11", "SEU_TOKEN")

import requests
from datetime import datetime, timedelta

def calendario_dividendos(symbols: list, token: str):
    """
    Monta calendário de próximos dividendos
    """
    print("=== CALENDÁRIO DE DIVIDENDOS ===")
    print(f"{'Ação':<10} {'Data Ex':<12} {'Pagamento':<12} {'Valor':>10}")
    print("-" * 50)
    
    for symbol in symbols:
        url = f"https://brapi.dev/api/quote/{symbol}"
        params = {"dividends": "true"}
        headers = {"Authorization": f"Bearer {token}"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        acao = data["results"][0]
        dividendos = acao.get("dividendsData", {}).get("cashDividends", [])
        
        # Último dividendo anunciado
        if dividendos:
            ultimo = dividendos[-1]
            print(f"{symbol:<10} {ultimo.get('exDividendDate', 'N/A')[:10]:<12} "
                  f"{ultimo.get('paymentDate', 'N/A')[:10]:<12} "
                  f"R$ {ultimo.get('value', 0):>8.4f}")

# Verificar dividendos da carteira
carteira = ["TAEE11", "BBAS3", "ITUB4", "EGIE3", "BBSE3"]
calendario_dividendos(carteira, "SEU_TOKEN")

import requests

def dashboard_renda(carteira: dict, token: str):
    """
    Dashboard de renda passiva da carteira
    """
    symbols = ",".join(carteira.keys())
    url = f"https://brapi.dev/api/quote/{symbols}"
    params = {"fundamental": "true", "dividends": "true"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    print("=" * 65)
    print("DASHBOARD DE RENDA PASSIVA")
    print("=" * 65)
    
    total_investido = 0
    renda_anual_total = 0
    
    for r in data["results"]:
        symbol = r["symbol"]
        qtd = carteira.get(symbol, 0)
        preco = r["regularMarketPrice"]
        dy = r.get("dividendYield", 0)
        
        valor_investido = qtd * preco
        renda_anual = valor_investido * dy if dy else 0
        renda_mensal = renda_anual / 12
        
        total_investido += valor_investido
        renda_anual_total += renda_anual
        
        print(f"\n{symbol}:")
        print(f"  Quantidade: {qtd}")
        print(f"  Preço: R$ {preco:.2f}")
        print(f"  Valor: R$ {valor_investido:,.2f}")
        print(f"  DY: {dy*100:.2f}%" if dy else "  DY: N/A")
        print(f"  Renda mensal: R$ {renda_mensal:.2f}")
    
    print("\n" + "=" * 65)
    print(f"TOTAL INVESTIDO: R$ {total_investido:,.2f}")
    print(f"RENDA ANUAL: R$ {renda_anual_total:,.2f}")
    print(f"RENDA MENSAL: R$ {renda_anual_total/12:,.2f}")
    print(f"DY MÉDIO: {(renda_anual_total/total_investido)*100:.2f}%")
    print("=" * 65)

# Minha carteira
minha_carteira = {
    "TAEE11": 500,
    "BBAS3": 300,
    "ITUB4": 400,
    "EGIE3": 200,
    "BBSE3": 250
}

dashboard_renda(minha_carteira, "SEU_TOKEN")

def alerta_dy_alto(symbol: str, dy: float):
    """
    Alerta sobre DY suspeitosamente alto
    """
    if dy > 0.15:  # 15%+
        print(f"🔴 ALERTA: {symbol} com DY de {dy*100:.1f}%")
        print("   Possíveis motivos:")
        print("   - Dividendo extraordinário (não recorrente)")
        print("   - Ação caiu muito (problema na empresa)")
        print("   - Payout insustentável")
        print("   - Empresa vendendo ativos")
        print("\n   ⚠️ VERIFICAR antes de comprar!")
        return True
    return False

# DY de 18% = sinal de alerta
alerta_dy_alto("XYZZ3", 0.18)

RENDIMENTOS ISENTOS E NÃO TRIBUTÁVEIS
Tipo: 09 - Lucros e dividendos recebidos

CNPJ: [da empresa]
Nome: [Nome da empresa]
Valor: R$ X.XXX,XX

RENDIMENTOS SUJEITOS À TRIBUTAÇÃO EXCLUSIVA
Tipo: 10 - Juros sobre Capital Próprio

CNPJ: [da empresa]
Nome: [Nome da empresa]
Valor bruto: R$ X.XXX,XX
IR retido: R$ XXX,XX (15%)

def quanto_preciso_para_viver(
    despesa_mensal: float,
    dy_medio: float,
    margem_seguranca: float = 0.20
):
    """
    Calcula patrimônio necessário para viver de dividendos
    """
    despesa_anual = despesa_mensal * 12
    despesa_com_margem = despesa_anual * (1 + margem_seguranca)
    
    patrimonio = despesa_com_margem / dy_medio
    
    print("=== QUANTO PRECISO PARA VIVER DE DIVIDENDOS? ===")
    print(f"\nDespesa mensal: R$ {despesa_mensal:,.2f}")
    print(f"Despesa anual: R$ {despesa_anual:,.2f}")
    print(f"Margem de segurança: {margem_seguranca*100:.0f}%")
    print(f"Despesa anual com margem: R$ {despesa_com_margem:,.2f}")
    print(f"\nDividend Yield médio: {dy_medio*100:.1f}%")
    print(f"\n💰 PATRIMÔNIO NECESSÁRIO: R$ {patrimonio:,.2f}")
    
    # Tabela de cenários
    print("\n--- Cenários por DY ---")
    for dy in [0.05, 0.06, 0.07, 0.08, 0.10]:
        pat = despesa_com_margem / dy
        print(f"DY {dy*100:.0f}%: R$ {pat:,.2f}")
    
    return patrimonio

# Quero viver com R$ 10.000/mês
quanto_preciso_para_viver(10000, 0.07)