ROE (Retorno sobre Patrimônio) 2026: Guia Completo para Análise de Ações

ROE = (Lucro Líquido / Patrimônio Líquido) × 100

Onde:
- Lucro Líquido = Lucro final da empresa (após impostos)
- Patrimônio Líquido = Capital investido pelos acionistas + Lucros retidos

Empresa ABC:
- Lucro Líquido: R$ 500 milhões
- Patrimônio Líquido: R$ 2,5 bilhões

ROE = (500 / 2.500) × 100 = 20%

Interpretação: A empresa gera R$ 0,20 de lucro para cada R$ 1,00 
investido pelos acionistas.

┌─────────────────────────────────────────────────────────────┐
│              IMPACTO DO ROE NO LONGO PRAZO                   │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  Empresa A: ROE 10%        Empresa B: ROE 25%               │
│  Patrimônio: R$ 100        Patrimônio: R$ 100               │
│                                                              │
│  Após 10 anos (reinvestindo 100% dos lucros):               │
│                                                              │
│  Empresa A: R$ 259         Empresa B: R$ 931                │
│  (cresceu 2,6x)            (cresceu 9,3x)                   │
│                                                              │
│  A diferença: 3,6x mais valor gerado!                       │
│                                                              │
└─────────────────────────────────────────────────────────────┘

⚠️ ROE MUITO ALTO (> 40%) - INVESTIGUE:

1. Alta alavancagem? → Patrimônio baixo infla ROE
2. Lucro não-recorrente? → Venda de ativos, ganhos únicos
3. Patrimônio negativo? → ROE não faz sentido
4. Manipulação contábil? → Ajustes agressivos

✅ ROE SUSTENTÁVEL:
- Consistente ao longo dos anos
- Sem alavancagem excessiva
- Baseado em operações recorrentes

import requests
import pandas as pd
from typing import List, Dict

# Configuração
API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def get_stock_data(ticker: str) -> dict:
    """
    Busca dados completos de uma ação na brapi.dev
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()
    
    return response.json()["results"][0]

def analyze_roe(ticker: str) -> dict:
    """
    Analisa o ROE de uma ação
    """
    data = get_stock_data(ticker)
    
    roe = data.get("returnOnEquity", 0)
    if roe:
        roe = roe * 100  # Converte para percentual
    
    # Dados complementares
    debt_equity = data.get("debtToEquity", 0)
    profit_margin = (data.get("profitMargin", 0) or 0) * 100
    
    # Classifica o ROE
    if roe is None or roe == 0:
        classificacao = "Dados não disponíveis"
        status = "❓"
    elif roe < 5:
        classificacao = "Muito Baixo"
        status = "❌"
    elif roe < 10:
        classificacao = "Baixo"
        status = "⚠️"
    elif roe < 15:
        classificacao = "Moderado"
        status = "✓"
    elif roe < 20:
        classificacao = "Bom"
        status = "✅"
    elif roe < 30:
        classificacao = "Excelente"
        status = "🌟"
    else:
        classificacao = "Excepcional (verificar)"
        status = "🔍"
    
    # Verifica se ROE alto é sustentável
    alertas = []
    if roe and roe > 25 and debt_equity and debt_equity > 2:
        alertas.append("⚠️ ROE pode estar inflado por alta alavancagem")
    
    return {
        "ticker": ticker,
        "nome": data.get("longName", "N/A"),
        "roe": roe,
        "classificacao": classificacao,
        "status": status,
        "debt_equity": debt_equity,
        "margem_liquida": profit_margin,
        "alertas": alertas
    }

# Exemplo de uso
print("ANÁLISE DE ROE - PRINCIPAIS AÇÕES BRASILEIRAS")
print("=" * 60)

tickers = ["WEGE3", "ITUB4", "PETR4", "VALE3", "MGLU3", "RENT3", "RADL3"]

for ticker in tickers:
    try:
        analysis = analyze_roe(ticker)
        
        print(f"\n{analysis['ticker']} - {analysis['nome']}")
        print(f"  ROE: {analysis['roe']:.1f}% {analysis['status']} ({analysis['classificacao']})")
        print(f"  Dívida/PL: {analysis['debt_equity']:.2f}")
        print(f"  Margem Líquida: {analysis['margem_liquida']:.1f}%")
        
        for alerta in analysis['alertas']:
            print(f"  {alerta}")
            
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def compare_roe_by_sector(sector_tickers: Dict[str, List[str]]) -> None:
    """
    Compara ROE de empresas agrupadas por setor
    """
    for sector, tickers in sector_tickers.items():
        print(f"\n{'='*60}")
        print(f"SETOR: {sector.upper()}")
        print("="*60)
        
        results = []
        for ticker in tickers:
            try:
                data = get_stock_data(ticker)
                roe = (data.get("returnOnEquity", 0) or 0) * 100
                
                results.append({
                    "ticker": ticker,
                    "roe": roe,
                    "preco": data.get("regularMarketPrice", 0),
                    "pl": data.get("priceToEarnings", 0)
                })
            except:
                continue
        
        if results:
            df = pd.DataFrame(results)
            df = df.sort_values("roe", ascending=False)
            
            # Média do setor
            roe_medio = df["roe"].mean()
            print(f"\nROE Médio do Setor: {roe_medio:.1f}%")
            print("-" * 50)
            print(df[["ticker", "roe", "preco", "pl"]].to_string(index=False))

# Organiza por setores
setores = {
    "Bancos": ["ITUB4", "BBDC4", "SANB11", "BBAS3", "BPAC11"],
    "Energia": ["ELET3", "EQTL3", "CMIG4", "TAEE11", "ENGI11"],
    "Varejo": ["MGLU3", "LREN3", "AMER3", "PETZ3", "AZZA3"],
    "Tecnologia": ["WEGE3", "TOTS3", "LINX3", "POSI3", "LWSA3"]
}

compare_roe_by_sector(setores)

def roe_screener(
    tickers: List[str],
    min_roe: float = 15,
    max_debt_equity: float = 1.5
) -> pd.DataFrame:
    """
    Screener de ações por ROE
    """
    qualified = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            roe = (data.get("returnOnEquity", 0) or 0) * 100
            debt_equity = data.get("debtToEquity", 0) or 0
            
            # Filtros
            if roe < min_roe:
                continue
            
            if debt_equity > max_debt_equity:
                continue
            
            qualified.append({
                "ticker": ticker,
                "nome": data.get("shortName", "N/A"),
                "roe": roe,
                "debt_equity": debt_equity,
                "pl": data.get("priceToEarnings", 0),
                "dy": data.get("dividendYield", 0)
            })
            
        except:
            continue
    
    df = pd.DataFrame(qualified)
    
    if not df.empty:
        df = df.sort_values("roe", ascending=False)
    
    return df

# Lista ampla de ações
tickers_analise = [
    "WEGE3", "ITUB4", "PETR4", "VALE3", "RENT3", "RADL3",
    "EQTL3", "SUZB3", "JBSS3", "PRIO3", "CSAN3", "VIVT3",
    "CMIG4", "TAEE11", "TRPL4", "BEEF3", "MRFG3", "BRFS3",
    "KLBN11", "ENBR3", "CYRE3", "EVEN3", "MULT3", "IGTI11"
]

print("\nSCREENER: ROE > 15% e Dívida/PL < 1.5")
print("=" * 60)

df_screened = roe_screener(tickers_analise, min_roe=15, max_debt_equity=1.5)

if not df_screened.empty:
    print(df_screened.to_string(index=False))
else:
    print("Nenhuma ação encontrada com os critérios.")

ROE = Margem Líquida × Giro do Ativo × Alavancagem

Onde:
- Margem Líquida = Lucro Líquido / Receita (eficiência operacional)
- Giro do Ativo = Receita / Ativo Total (uso de ativos)
- Alavancagem = Ativo Total / Patrimônio Líquido (uso de dívida)

def dupont_analysis(ticker: str) -> dict:
    """
    Realiza análise DuPont do ROE
    """
    data = get_stock_data(ticker)
    
    # Extrair dados (valores aproximados dos fundamentais)
    roe = (data.get("returnOnEquity", 0) or 0) * 100
    roa = (data.get("returnOnAssets", 0) or 0) * 100
    margem = (data.get("profitMargin", 0) or 0) * 100
    
    # Estimar componentes DuPont
    # Alavancagem = ROE / ROA (aproximado)
    alavancagem = roe / roa if roa > 0 else 0
    
    # Giro do Ativo = ROA / Margem Líquida (aproximado)
    giro_ativo = roa / margem if margem > 0 else 0
    
    # Interpretação
    interpretacao = []
    
    if margem > 15:
        interpretacao.append("✅ Alta margem líquida (poder de preço)")
    elif margem > 8:
        interpretacao.append("✓ Margem líquida adequada")
    else:
        interpretacao.append("⚠️ Margem líquida baixa")
    
    if giro_ativo > 1.5:
        interpretacao.append("✅ Alto giro de ativos (eficiência)")
    elif giro_ativo > 0.8:
        interpretacao.append("✓ Giro de ativos adequado")
    else:
        interpretacao.append("⚠️ Baixo giro de ativos")
    
    if alavancagem > 4:
        interpretacao.append("❌ Alta alavancagem (risco)")
    elif alavancagem > 2:
        interpretacao.append("⚠️ Alavancagem moderada-alta")
    else:
        interpretacao.append("✅ Baixa alavancagem (conservador)")
    
    return {
        "ticker": ticker,
        "roe": roe,
        "margem_liquida": margem,
        "giro_ativo": giro_ativo,
        "alavancagem": alavancagem,
        "interpretacao": interpretacao
    }

# Exemplo de análise DuPont
print("\nANÁLISE DUPONT")
print("=" * 60)

for ticker in ["WEGE3", "ITUB4", "PETR4", "MGLU3"]:
    try:
        result = dupont_analysis(ticker)
        
        print(f"\n{result['ticker']}")
        print(f"  ROE: {result['roe']:.1f}%")
        print(f"  Decomposição:")
        print(f"    Margem Líquida: {result['margem_liquida']:.1f}%")
        print(f"    Giro do Ativo: {result['giro_ativo']:.2f}x")
        print(f"    Alavancagem: {result['alavancagem']:.2f}x")
        print(f"  Análise:")
        for item in result['interpretacao']:
            print(f"    {item}")
            
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

ROE = Lucro Líquido / Patrimônio Líquido
     → Retorno para o ACIONISTA
     → Considera dívida (alavancagem)

ROIC = NOPAT / Capital Investido
     → Retorno para TODOS os provedores de capital
     → Exclui efeito da dívida (mais "puro")

Onde:
- NOPAT = Lucro Operacional × (1 - Alíquota IR)
- Capital Investido = Patrimônio Líquido + Dívida Líquida

def calculate_roic(ticker: str) -> dict:
    """
    Calcula ROIC (Return on Invested Capital)
    """
    data = get_stock_data(ticker)
    
    # Dados disponíveis
    roe = (data.get("returnOnEquity", 0) or 0) * 100
    roa = (data.get("returnOnAssets", 0) or 0) * 100
    debt_equity = data.get("debtToEquity", 0) or 0
    
    # ROIC aproximado
    # ROIC ≈ ROA ajustado pela estrutura de capital
    # Simplificação: ROIC = ROE / (1 + D/E) × (1 + D/E × (1-t))
    # Onde t é a taxa de imposto (~34% no Brasil)
    
    taxa_ir = 0.34
    if debt_equity > 0:
        roic_aprox = roa * (1 + debt_equity * (1 - taxa_ir))
    else:
        roic_aprox = roa
    
    return {
        "ticker": ticker,
        "roe": roe,
        "roa": roa,
        "roic_aproximado": roic_aprox,
        "debt_equity": debt_equity,
        "analise": "ROIC < ROE indica benefício da alavancagem" if roic_aprox < roe else "Empresa opera com baixa alavancagem"
    }

# Exemplo
print("\nROE vs ROIC")
print("=" * 50)

for ticker in ["WEGE3", "ITUB4", "RENT3"]:
    result = calculate_roic(ticker)
    print(f"\n{result['ticker']}")
    print(f"  ROE: {result['roe']:.1f}%")
    print(f"  ROA: {result['roa']:.1f}%")
    print(f"  ROIC (aprox): {result['roic_aproximado']:.1f}%")
    print(f"  D/E: {result['debt_equity']:.2f}")
    print(f"  {result['analise']}")

def analyze_roe_consistency(ticker: str, roe_historico: List[float]) -> dict:
    """
    Analisa consistência do ROE ao longo dos anos
    """
    if not roe_historico:
        return {"ticker": ticker, "consistente": False, "mensagem": "Sem dados"}
    
    roe_medio = sum(roe_historico) / len(roe_historico)
    roe_min = min(roe_historico)
    roe_max = max(roe_historico)
    
    # Desvio padrão
    variancia = sum((x - roe_medio) ** 2 for x in roe_historico) / len(roe_historico)
    desvio_padrao = variancia ** 0.5
    
    # Coeficiente de variação
    cv = (desvio_padrao / roe_medio) * 100 if roe_medio > 0 else 100
    
    # Anos com ROE > 15%
    anos_bons = sum(1 for r in roe_historico if r >= 15)
    
    # Tendência
    if len(roe_historico) >= 3:
        tendencia_recente = roe_historico[-1] - roe_historico[-3]
    else:
        tendencia_recente = 0
    
    # Classificação de consistência
    if cv < 15 and roe_min >= 12:
        consistencia = "Muito Consistente"
        status = "🌟"
    elif cv < 25 and roe_min >= 8:
        consistencia = "Consistente"
        status = "✅"
    elif cv < 40:
        consistencia = "Moderadamente Variável"
        status = "⚠️"
    else:
        consistencia = "Muito Variável"
        status = "❌"
    
    return {
        "ticker": ticker,
        "roe_medio": roe_medio,
        "roe_min": roe_min,
        "roe_max": roe_max,
        "desvio_padrao": desvio_padrao,
        "coef_variacao": cv,
        "anos_bons": anos_bons,
        "total_anos": len(roe_historico),
        "tendencia": tendencia_recente,
        "consistencia": consistencia,
        "status": status
    }

# Exemplos de ROE histórico (dados ilustrativos)
historicos = {
    "WEGE3": [25.2, 27.1, 28.5, 26.8, 29.3, 30.1],  # WEG - consistente alto
    "ITUB4": [18.5, 17.2, 16.8, 17.5, 18.2, 17.9],  # Itaú - consistente
    "MGLU3": [35.2, 28.1, 15.3, 8.2, -12.5, -25.3], # Magazine Luiza - variável
    "VALE3": [12.5, 25.8, 45.2, 32.1, 28.5, 15.2]   # Vale - cíclico
}

print("\nANÁLISE DE CONSISTÊNCIA DO ROE")
print("=" * 60)

for ticker, roe_hist in historicos.items():
    result = analyze_roe_consistency(ticker, roe_hist)
    
    print(f"\n{result['ticker']}")
    print(f"  ROE Médio: {result['roe_medio']:.1f}%")
    print(f"  Range: {result['roe_min']:.1f}% - {result['roe_max']:.1f}%")
    print(f"  Desvio Padrão: {result['desvio_padrao']:.1f}%")
    print(f"  Anos com ROE > 15%: {result['anos_bons']}/{result['total_anos']}")
    print(f"  Tendência (3 anos): {result['tendencia']:+.1f}%")
    print(f"  {result['status']} {result['consistencia']}")

def compare_roe_with_sector(ticker: str) -> dict:
    """
    Compara ROE da empresa com a média do setor
    """
    # ROE médio por setor (Brasil)
    sector_roe = {
        "Financial Services": 18,
        "Utilities": 12,
        "Basic Materials": 15,
        "Consumer Cyclical": 12,
        "Technology": 22,
        "Healthcare": 16,
        "Consumer Defensive": 14,
        "Energy": 18,
        "Industrials": 15,
        "Real Estate": 10,
        "Communication Services": 12
    }
    
    data = get_stock_data(ticker)
    
    roe_empresa = (data.get("returnOnEquity", 0) or 0) * 100
    setor = data.get("sector", "Unknown")
    roe_setor = sector_roe.get(setor, 15)
    
    diferenca = roe_empresa - roe_setor
    diferenca_pct = (diferenca / roe_setor) * 100 if roe_setor > 0 else 0
    
    if diferenca > 5:
        avaliacao = "Muito acima do setor"
        status = "🌟"
    elif diferenca > 0:
        avaliacao = "Acima do setor"
        status = "✅"
    elif diferenca > -3:
        avaliacao = "Alinhado com setor"
        status = "✓"
    elif diferenca > -5:
        avaliacao = "Abaixo do setor"
        status = "⚠️"
    else:
        avaliacao = "Muito abaixo do setor"
        status = "❌"
    
    return {
        "ticker": ticker,
        "setor": setor,
        "roe_empresa": roe_empresa,
        "roe_setor": roe_setor,
        "diferenca": diferenca,
        "diferenca_pct": diferenca_pct,
        "avaliacao": avaliacao,
        "status": status
    }

# Exemplo
print("\nCOMPARATIVO ROE vs SETOR")
print("=" * 50)

for ticker in ["WEGE3", "ITUB4", "PETR4", "MGLU3", "RADL3"]:
    result = compare_roe_with_sector(ticker)
    
    print(f"\n{result['ticker']} ({result['setor']})")
    print(f"  ROE Empresa: {result['roe_empresa']:.1f}%")
    print(f"  ROE Setor: {result['roe_setor']:.1f}%")
    print(f"  Diferença: {result['diferenca']:+.1f}% ({result['diferenca_pct']:+.1f}%)")
    print(f"  {result['status']} {result['avaliacao']}")

def find_roe_pl_opportunities(tickers: List[str]) -> pd.DataFrame:
    """
    Encontra ações com ROE alto e P/L baixo
    """
    opportunities = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            roe = (data.get("returnOnEquity", 0) or 0) * 100
            pl = data.get("priceToEarnings", 0)
            
            # Critérios: ROE > 15% e P/L entre 5 e 15
            if roe < 15:
                continue
            if pl <= 0 or pl > 15:
                continue
            
            # Score: quanto maior o ROE e menor o P/L, melhor
            score = roe / pl if pl > 0 else 0
            
            opportunities.append({
                "ticker": ticker,
                "nome": data.get("shortName", "N/A"),
                "roe": roe,
                "pl": pl,
                "dy": data.get("dividendYield", 0),
                "score": score
            })
            
        except:
            continue
    
    df = pd.DataFrame(opportunities)
    
    if not df.empty:
        df = df.sort_values("score", ascending=False)
    
    return df

# Busca oportunidades
tickers = [
    "WEGE3", "ITUB4", "BBDC4", "PETR4", "VALE3", "RENT3",
    "RADL3", "EQTL3", "SUZB3", "JBSS3", "PRIO3", "CSAN3",
    "VIVT3", "CMIG4", "TAEE11", "TRPL4", "BBAS3", "BPAC11"
]

print("\nOPORTUNIDADES: ROE ALTO + P/L BAIXO")
print("=" * 60)

df = find_roe_pl_opportunities(tickers)

if not df.empty:
    print("\nMelhores oportunidades (Score = ROE / P/L):")
    print(df.head(10).to_string(index=False))

def graham_roe_valuation(ticker: str) -> dict:
    """
    Valuation usando fórmula de Graham modificada com ROE
    """
    data = get_stock_data(ticker)
    
    lpa = data.get("earningsPerShare", 0)
    vpa = data.get("bookValue", 0)  # Valor Patrimonial por Ação
    roe = (data.get("returnOnEquity", 0) or 0) * 100
    preco = data.get("regularMarketPrice", 0)
    
    # Fórmula de Graham: √(22.5 × LPA × VPA)
    if lpa > 0 and vpa > 0:
        preco_graham = (22.5 * lpa * vpa) ** 0.5
    else:
        preco_graham = None
    
    # Ajuste por ROE
    # ROE alto justifica prêmio, ROE baixo desconto
    if preco_graham and roe > 0:
        fator_roe = 1 + (roe - 15) / 100  # 15% como base
        preco_ajustado = preco_graham * fator_roe
    else:
        preco_ajustado = preco_graham
    
    if preco_graham and preco > 0:
        margem_seguranca_graham = ((preco_graham - preco) / preco) * 100
        margem_seguranca_ajustada = ((preco_ajustado - preco) / preco) * 100 if preco_ajustado else None
    else:
        margem_seguranca_graham = None
        margem_seguranca_ajustada = None
    
    return {
        "ticker": ticker,
        "preco_atual": preco,
        "preco_graham": preco_graham,
        "preco_ajustado_roe": preco_ajustado,
        "roe": roe,
        "margem_seguranca": margem_seguranca_graham,
        "margem_seguranca_ajustada": margem_seguranca_ajustada
    }

# Exemplo
print("\nVALUATION COM ROE")
print("=" * 50)

for ticker in ["ITUB4", "BBAS3", "WEGE3", "TAEE11"]:
    result = graham_roe_valuation(ticker)
    
    print(f"\n{result['ticker']}")
    print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
    print(f"  ROE: {result['roe']:.1f}%")
    
    if result['preco_graham']:
        print(f"  Preço Graham: R$ {result['preco_graham']:.2f}")
        print(f"  Preço Ajustado (ROE): R$ {result['preco_ajustado_roe']:.2f}")
    
    if result['margem_seguranca']:
        print(f"  Margem de Segurança: {result['margem_seguranca']:+.1f}%")

┌─────────────────────────────────────────────────────────────┐
│              ERROS COMUNS NA ANÁLISE DE ROE                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. ❌ Ignorar a alavancagem                                 │
│     → ROE alto por dívida excessiva é arriscado             │
│                                                              │
│  2. ❌ Comparar setores diferentes                           │
│     → Bancos têm ROE diferente de varejo                    │
│                                                              │
│  3. ❌ Olhar apenas um período                               │
│     → ROE pode variar muito entre anos                      │
│                                                              │
│  4. ❌ Ignorar patrimônio negativo                           │
│     → ROE não faz sentido se PL for negativo                │
│                                                              │
│  5. ❌ Não ajustar por itens não-recorrentes                 │
│     → Venda de ativos pode inflar ROE temporariamente       │
│                                                              │
│  6. ❌ Esquecer da qualidade do lucro                        │
│     → Lucro contábil ≠ geração de caixa                     │
│                                                              │
└─────────────────────────────────────────────────────────────┘