Melhores Ações Pagadoras de Dividendos 2026: Guia Completo para Renda Passiva

comparativo_estrategias = {
    'dividendos': {
        'foco': 'Renda periódica',
        'perfil': 'Conservador a moderado',
        'empresas': 'Maduras, setores estáveis',
        'reinvestimento': 'Juros compostos via reinvestimento',
        'tributacao': 'Isento de IR'
    },
    'valorizacao': {
        'foco': 'Crescimento do capital',
        'perfil': 'Agressivo',
        'empresas': 'Growth, tecnologia, small caps',
        'reinvestimento': 'Empresa reinveste lucros',
        'tributacao': '15-20% sobre ganho de capital'
    }
}

def calcular_dividend_yield(dividendos_12_meses, preco_acao):
    """
    Dividend Yield = (Dividendos 12 meses / Preço da ação) × 100
    """
    dy = (dividendos_12_meses / preco_acao) * 100
    return round(dy, 2)

# Exemplo: TAEE11
dy = calcular_dividend_yield(4.20, 35.00)
print(f"Dividend Yield: {dy}%")
# Dividend Yield: 12.00%

def calcular_payout(dividendos_por_acao, lucro_por_acao):
    """
    Payout = (Dividendos / Lucro) × 100
    """
    if lucro_por_acao <= 0:
        return "Empresa no prejuízo"
    
    payout = (dividendos_por_acao / lucro_por_acao) * 100
    
    if payout > 100:
        return {
            'payout': round(payout, 2),
            'alerta': 'Payout acima de 100% - insustentável no longo prazo'
        }
    
    return round(payout, 2)

# Exemplo
payout = calcular_payout(3.50, 5.00)
print(f"Payout: {payout}%")
# Payout: 70.0%

criterios_historico = {
    'minimo_recomendado': '5 anos pagando dividendos',
    'ideal': '10+ anos sem cortes',
    'excelente': 'Dividend Aristocrat (25+ anos crescendo)',
    'sinais_alerta': [
        'Corte recente de dividendos',
        'Payout acima de 100%',
        'Lucro oscilante',
        'Endividamento crescente'
    ]
}

# Análise setor elétrico com brapi.dev
import requests

def analisar_setor_eletrico(token):
    """Consulta dados do setor elétrico"""
    tickers = ['TAEE11', 'TRPL4', 'EGIE3', 'CPLE6', 'CMIG4']
    
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}?modules=dividendsData&token={token}"
    response = requests.get(url)
    data = response.json()
    
    analise = []
    for ativo in data['results']:
        analise.append({
            'ticker': ativo['symbol'],
            'preco': ativo['regularMarketPrice'],
            'nome': ativo.get('longName', '')
        })
    
    return analise

analise_bancos = {
    'BBAS3': {
        'vantagem': 'Maior dividend yield entre grandes bancos',
        'risco': 'Banco estatal - risco político',
        'perfil': 'Investidor que aceita volatilidade por DY maior'
    },
    'ITUB4': {
        'vantagem': 'Maior banco privado, mais eficiente',
        'risco': 'DY menor, prêmio de qualidade',
        'perfil': 'Investidor conservador de longo prazo'
    }
}

def avaliar_ciclicidade(setor):
    """Avalia risco de ciclicidade nos dividendos"""
    setores = {
        'commodities': {
            'ciclicidade': 'ALTA',
            'previsibilidade': 'BAIXA',
            'recomendacao': 'Não depender para renda fixa mensal',
            'estrategia': 'Aproveitar DY alto, mas não contar sempre'
        },
        'eletrico': {
            'ciclicidade': 'BAIXA',
            'previsibilidade': 'ALTA',
            'recomendacao': 'Ideal para renda passiva estável',
            'estrategia': 'Base da carteira de dividendos'
        },
        'bancos': {
            'ciclicidade': 'MÉDIA',
            'previsibilidade': 'MÉDIA',
            'recomendacao': 'Bom complemento, atenção ao ciclo de crédito',
            'estrategia': 'Diversificar entre bancos'
        }
    }
    return setores.get(setor, 'Setor não mapeado')

def analisar_acao_dividendos(ticker, dados):
    """
    Checklist para avaliar ação pagadora de dividendos
    """
    score = 0
    analise = []
    
    # 1. Dividend Yield
    if dados['dividend_yield'] >= 6:
        score += 2
        analise.append("✅ DY acima de 6%")
    elif dados['dividend_yield'] >= 4:
        score += 1
        analise.append("⚠️ DY moderado (4-6%)")
    else:
        analise.append("❌ DY baixo (< 4%)")
    
    # 2. Payout sustentável
    if 30 <= dados['payout'] <= 70:
        score += 2
        analise.append("✅ Payout saudável (30-70%)")
    elif dados['payout'] <= 30:
        score += 1
        analise.append("⚠️ Payout baixo - empresa retém lucro")
    elif dados['payout'] > 100:
        score -= 1
        analise.append("❌ Payout acima de 100% - insustentável")
    
    # 3. Histórico
    if dados['anos_pagando'] >= 10:
        score += 2
        analise.append("✅ Histórico de 10+ anos")
    elif dados['anos_pagando'] >= 5:
        score += 1
        analise.append("⚠️ Histórico de 5-10 anos")
    else:
        analise.append("❌ Histórico curto")
    
    # 4. Endividamento
    if dados['divida_liquida_ebitda'] <= 2:
        score += 2
        analise.append("✅ Endividamento controlado")
    elif dados['divida_liquida_ebitda'] <= 3:
        score += 1
        analise.append("⚠️ Endividamento moderado")
    else:
        analise.append("❌ Endividamento alto")
    
    # 5. Crescimento de lucro
    if dados['crescimento_lucro_5y'] > 0:
        score += 1
        analise.append("✅ Lucro crescente")
    else:
        analise.append("⚠️ Lucro estagnado ou em queda")
    
    return {
        'ticker': ticker,
        'score': score,
        'max_score': 9,
        'recomendacao': 'Comprar' if score >= 7 else 'Analisar' if score >= 5 else 'Evitar',
        'analise': analise
    }

def filtro_bazin(acao):
    """Aplica os critérios do Método Bazin"""
    aprovado = True
    motivos = []
    
    if acao['dividend_yield'] < 6:
        aprovado = False
        motivos.append(f"DY de {acao['dividend_yield']}% < 6%")
    
    if acao['anos_pagando'] < 5:
        aprovado = False
        motivos.append(f"Apenas {acao['anos_pagando']} anos pagando")
    
    if not acao['lider_setor']:
        aprovado = False
        motivos.append("Não é líder do setor")
    
    return {
        'ticker': acao['ticker'],
        'aprovado': aprovado,
        'motivos': motivos if not aprovado else ['Passou em todos os critérios']
    }

carteira_modelo_dividendos = {
    'total_setores': 5,
    'max_por_setor': '30%',
    'distribuicao_sugerida': {
        'eletrico': {
            'alocacao': '30%',
            'tickers': ['TAEE11', 'TRPL4'],
            'motivo': 'Base estável, contratos longos'
        },
        'bancos': {
            'alocacao': '25%',
            'tickers': ['BBAS3', 'ITUB4'],
            'motivo': 'Lucros consistentes'
        },
        'seguros': {
            'alocacao': '15%',
            'tickers': ['BBSE3'],
            'motivo': 'Baixa ciclicidade'
        },
        'commodities': {
            'alocacao': '15%',
            'tickers': ['PETR4', 'VALE3'],
            'motivo': 'Potencial de DY alto (cíclico)'
        },
        'saneamento_telecom': {
            'alocacao': '15%',
            'tickers': ['SAPR11', 'VIVT3'],
            'motivo': 'Receitas previsíveis'
        }
    }
}

def montar_carteira_dividendos(valor_total, meta_dy_anual=8):
    """Monta carteira diversificada para dividendos"""
    
    carteira = {
        'TAEE11': {'alocacao': 0.15, 'dy_esperado': 11},
        'TRPL4': {'alocacao': 0.10, 'dy_esperado': 9},
        'BBAS3': {'alocacao': 0.15, 'dy_esperado': 10},
        'ITUB4': {'alocacao': 0.10, 'dy_esperado': 6},
        'BBSE3': {'alocacao': 0.15, 'dy_esperado': 9},
        'PETR4': {'alocacao': 0.10, 'dy_esperado': 15},
        'VALE3': {'alocacao': 0.10, 'dy_esperado': 8},
        'VIVT3': {'alocacao': 0.10, 'dy_esperado': 6},
        'SAPR11': {'alocacao': 0.05, 'dy_esperado': 7}
    }
    
    resultado = []
    dy_ponderado = 0
    
    for ticker, dados in carteira.items():
        valor_alocado = valor_total * dados['alocacao']
        dividendo_esperado = valor_alocado * (dados['dy_esperado'] / 100)
        
        resultado.append({
            'ticker': ticker,
            'valor': valor_alocado,
            'dividendo_anual': dividendo_esperado,
            'dividendo_mensal': dividendo_esperado / 12
        })
        
        dy_ponderado += dados['alocacao'] * dados['dy_esperado']
    
    dividendo_total_anual = sum(a['dividendo_anual'] for a in resultado)
    dividendo_total_mensal = dividendo_total_anual / 12
    
    return {
        'carteira': resultado,
        'valor_total': valor_total,
        'dy_medio_ponderado': f"{dy_ponderado:.2f}%",
        'dividendo_anual_estimado': f"R$ {dividendo_total_anual:,.2f}",
        'dividendo_mensal_estimado': f"R$ {dividendo_total_mensal:,.2f}"
    }

# Montar carteira de R$ 100.000
carteira = montar_carteira_dividendos(100000)
print(f"DY médio: {carteira['dy_medio_ponderado']}")
print(f"Dividendo mensal: {carteira['dividendo_mensal_estimado']}")
# DY médio: 9.25%
# Dividendo mensal: R$ 770,83

calendario_dividendos = {
    'data_com': 'Último dia para comprar e ter direito',
    'data_ex': 'Primeiro dia sem direito ao dividendo',
    'data_pagamento': 'Dia que o dinheiro cai na conta',
    
    'frequencias_comuns': {
        'mensal': ['PETR4 (algumas vezes)', 'FIIs em geral'],
        'trimestral': ['ITUB4', 'BBDC4', 'maioria das empresas'],
        'semestral': ['VALE3', 'algumas elétricas'],
        'anual': ['Algumas empresas menores']
    }
}

def identificar_yield_trap(acao):
    """Identifica ações com DY artificialmente alto"""
    alertas = []
    
    # DY muito alto pode indicar queda no preço
    if acao['dividend_yield'] > 15:
        alertas.append("⚠️ DY acima de 15% - verificar se preço caiu muito")
    
    # Payout insustentável
    if acao['payout'] > 100:
        alertas.append("🚨 Payout > 100% - empresa pagando mais do que lucra")
    
    # Dividendo não recorrente
    if acao['dividendo_extraordinario']:
        alertas.append("⚠️ Inclui dividendo extraordinário - não se repetirá")
    
    # Lucro em queda
    if acao['lucro_crescimento'] < -10:
        alertas.append("🚨 Lucro caindo - dividendos podem ser cortados")
    
    return {
        'ticker': acao['ticker'],
        'yield_trap': len([a for a in alertas if '🚨' in a]) > 0,
        'alertas': alertas
    }

exemplo_extraordinario = {
    'empresa': 'PETR4',
    'dividendo_normal': 3.00,  # Por ação, típico
    'dividendo_extraordinario': 8.00,  # Venda de ativos, lucro único
    'dividendo_total_ano': 11.00,
    'dy_calculado': '30%',  # Parece alto!
    'dy_sustentavel': '~10%',  # Sem o extraordinário
    'erro_comum': 'Comprar esperando 30% todo ano'
}

risco_estatais = {
    'PETR4': {
        'vantagem': 'DY altíssimo, maior empresa do Brasil',
        'risco': 'Política de preços pode mudar com governo',
        'mitigacao': 'Não concentrar demais, acompanhar cenário'
    },
    'BBAS3': {
        'vantagem': 'Melhor DY entre grandes bancos',
        'risco': 'Crédito direcionado, interferência política',
        'mitigacao': 'Diversificar com bancos privados'
    }
}

import requests

def analisar_dividendos_brapi(ticker, token):
    """Analisa dividendos de uma ação usando brapi.dev"""
    
    url = f"https://brapi.dev/api/quote/{ticker}?modules=dividendsData,defaultKeyStatistics&token={token}"
    response = requests.get(url)
    data = response.json()
    
    if not data.get('results'):
        return None
    
    acao = data['results'][0]
    
    # Extrair dados de dividendos
    dividendos = acao.get('dividendsData', {}).get('cashDividends', [])
    
    # Calcular dividendos dos últimos 12 meses
    from datetime import datetime, timedelta
    um_ano_atras = datetime.now() - timedelta(days=365)
    
    dividendos_12m = sum(
        d['rate'] for d in dividendos 
        if datetime.strptime(d['paymentDate'], '%Y-%m-%d') > um_ano_atras
    )
    
    preco_atual = acao['regularMarketPrice']
    dy = (dividendos_12m / preco_atual) * 100 if preco_atual > 0 else 0
    
    return {
        'ticker': ticker,
        'preco_atual': preco_atual,
        'dividendos_12m': round(dividendos_12m, 2),
        'dividend_yield': round(dy, 2),
        'quantidade_pagamentos': len([d for d in dividendos if datetime.strptime(d['paymentDate'], '%Y-%m-%d') > um_ano_atras]),
        'ultimo_dividendo': dividendos[0] if dividendos else None
    }

# Exemplo de uso
resultado = analisar_dividendos_brapi('TAEE11', 'SEU_TOKEN')
print(f"TAEE11 - DY: {resultado['dividend_yield']}%")

def comparar_dividendos(tickers, token):
    """Compara dividend yield de múltiplas ações"""
    
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}?modules=dividendsData&token={token}"
    response = requests.get(url)
    data = response.json()
    
    comparativo = []
    for acao in data['results']:
        ticker = acao['symbol']
        preco = acao['regularMarketPrice']
        
        # Simplificação - usar dados da API
        dividendos = acao.get('dividendsData', {}).get('cashDividends', [])
        
        comparativo.append({
            'ticker': ticker,
            'preco': preco,
            'qtd_pagamentos_ano': len(dividendos[:12])  # Últimos 12 pagamentos
        })
    
    # Ordenar por relevância
    return sorted(comparativo, key=lambda x: x['qtd_pagamentos_ano'], reverse=True)

# Comparar principais pagadoras
tickers = ['TAEE11', 'BBAS3', 'PETR4', 'ITUB4', 'VALE3']
resultado = comparar_dividendos(tickers, 'SEU_TOKEN')

def simular_renda_passiva(valor_inicial, aporte_mensal, anos, dy_medio=8):
    """
    Simula crescimento de carteira de dividendos com reinvestimento
    """
    patrimonio = valor_inicial
    dividendos_recebidos_total = 0
    historico = []
    
    for ano in range(1, anos + 1):
        # Dividendos do ano
        dividendos_ano = patrimonio * (dy_medio / 100)
        dividendos_recebidos_total += dividendos_ano
        
        # Aportes do ano
        aportes_ano = aporte_mensal * 12
        
        # Reinvestir dividendos + aportes
        patrimonio += dividendos_ano + aportes_ano
        
        # Valorização conservadora (3% a.a. além dos dividendos)
        patrimonio *= 1.03
        
        historico.append({
            'ano': ano,
            'patrimonio': round(patrimonio, 2),
            'dividendos_ano': round(dividendos_ano, 2),
            'dividendo_mensal': round(dividendos_ano / 12, 2)
        })
    
    return {
        'patrimonio_final': round(patrimonio, 2),
        'dividendos_totais_recebidos': round(dividendos_recebidos_total, 2),
        'renda_mensal_final': round(patrimonio * (dy_medio/100) / 12, 2),
        'historico': historico
    }

# Simulação: R$ 50.000 inicial + R$ 2.000/mês por 15 anos
resultado = simular_renda_passiva(50000, 2000, 15, dy_medio=8)

print(f"""
SIMULAÇÃO DE RENDA PASSIVA
==========================
Investimento inicial: R$ 50.000
Aporte mensal: R$ 2.000
Prazo: 15 anos
DY médio: 8%

RESULTADO:
Patrimônio final: R$ {resultado['patrimonio_final']:,.2f}
Dividendos recebidos: R$ {resultado['dividendos_totais_recebidos']:,.2f}
Renda mensal final: R$ {resultado['renda_mensal_final']:,.2f}
""")