Preço Teto de Ações 2026: Como Calcular o Valor Máximo para Comprar

Preço Teto = Preço máximo para garantir rentabilidade mínima esperada

Se Preço Atual < Preço Teto → Oportunidade de compra
Se Preço Atual > Preço Teto → Esperar ou evitar

Preço Teto Bazin = Dividendo Anual / Yield Mínimo Desejado

Exemplo:
- Dividendo anual: R$ 3,00 por ação
- Yield mínimo desejado: 6%

Preço Teto = 3,00 / 0,06 = R$ 50,00

Se a ação estiver abaixo de R$ 50,00, é oportunidade de compra.

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",
        "dividends": "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 calculate_bazin_price(ticker: str, min_yield: float = 0.06) -> dict:
    """
    Calcula preço teto pelo método Bazin
    
    Args:
        ticker: Código da ação
        min_yield: Yield mínimo desejado (default 6%)
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    dy_atual = data.get("dividendYield", 0) / 100 if data.get("dividendYield") else 0
    
    # Calcula dividendo anual estimado
    dividendo_anual = preco_atual * dy_atual if dy_atual > 0 else 0
    
    # Busca histórico de dividendos para média
    dividendos = data.get("dividendsData", {}).get("cashDividends", [])
    
    if dividendos:
        # Soma dividendos dos últimos 12 meses
        from datetime import datetime, timedelta
        um_ano_atras = datetime.now() - timedelta(days=365)
        
        dividendo_12m = sum(
            d.get("rate", 0) for d in dividendos
            if datetime.strptime(d.get("paymentDate", "2000-01-01")[:10], "%Y-%m-%d") >= um_ano_atras
        )
        
        if dividendo_12m > 0:
            dividendo_anual = dividendo_12m
    
    # Calcula preço teto
    if dividendo_anual > 0:
        preco_teto = dividendo_anual / min_yield
    else:
        preco_teto = 0
    
    # Margem de segurança
    if preco_teto > 0 and preco_atual > 0:
        margem = ((preco_teto - preco_atual) / preco_atual) * 100
    else:
        margem = None
    
    return {
        "ticker": ticker,
        "metodo": "Bazin",
        "preco_atual": preco_atual,
        "dividendo_anual": dividendo_anual,
        "dy_atual": dy_atual * 100,
        "yield_minimo": min_yield * 100,
        "preco_teto": preco_teto,
        "margem_seguranca": margem,
        "oportunidade": "✅ Comprar" if margem and margem > 0 else "⚠️ Caro" if margem else "❓ Sem dados"
    }

# Exemplo: Ações pagadoras de dividendos
print("PREÇO TETO - MÉTODO BAZIN (DY mínimo 6%)")
print("=" * 60)

acoes_dividendos = ["TAEE11", "BBAS3", "ITUB4", "CMIG4", "TRPL4", "VIVT3"]

for ticker in acoes_dividendos:
    try:
        result = calculate_bazin_price(ticker, min_yield=0.06)
        
        print(f"\n{result['ticker']}")
        print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
        print(f"  Dividendo Anual: R$ {result['dividendo_anual']:.2f}")
        print(f"  DY Atual: {result['dy_atual']:.2f}%")
        print(f"  Preço Teto (DY 6%): R$ {result['preco_teto']:.2f}")
        
        if result['margem_seguranca'] is not None:
            print(f"  Margem: {result['margem_seguranca']:+.1f}%")
        print(f"  {result['oportunidade']}")
        
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def bazin_multi_yield(ticker: str) -> pd.DataFrame:
    """
    Calcula preço teto Bazin para diferentes yields
    """
    yields = [0.05, 0.06, 0.07, 0.08, 0.10]
    results = []
    
    data = get_stock_data(ticker)
    preco_atual = data.get("regularMarketPrice", 0)
    dy_atual = data.get("dividendYield", 0)
    dividendo_anual = preco_atual * (dy_atual / 100) if dy_atual else 0
    
    for y in yields:
        if dividendo_anual > 0:
            preco_teto = dividendo_anual / y
            margem = ((preco_teto - preco_atual) / preco_atual) * 100
        else:
            preco_teto = 0
            margem = None
        
        results.append({
            "yield_minimo": f"{y*100:.0f}%",
            "preco_teto": preco_teto,
            "margem": margem
        })
    
    return pd.DataFrame(results)

# Exemplo
print("\nPREÇO TETO TAEE11 - DIFERENTES YIELDS")
print("=" * 40)
df = bazin_multi_yield("TAEE11")
print(df.to_string(index=False))

Preço Justo Graham = √(22,5 × LPA × VPA)

Onde:
- LPA = Lucro por Ação
- VPA = Valor Patrimonial por Ação
- 22,5 = constante (P/L máximo 15 × P/VP máximo 1,5)

Preço Justo = LPA × (8,5 + 2g)

Onde:
- LPA = Lucro por Ação
- 8,5 = P/L base para empresa sem crescimento
- g = taxa de crescimento anual esperada (%)

def calculate_graham_price(ticker: str, growth_rate: float = 5) -> dict:
    """
    Calcula preço teto pelos métodos de Graham
    
    Args:
        ticker: Código da ação
        growth_rate: Taxa de crescimento esperada (% ao ano)
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    lpa = data.get("earningsPerShare", 0)  # Lucro por Ação
    vpa = data.get("bookValue", 0)  # Valor Patrimonial por Ação
    
    # Método 1: Graham Clássico
    if lpa > 0 and vpa > 0:
        preco_graham_classico = (22.5 * lpa * vpa) ** 0.5
    else:
        preco_graham_classico = None
    
    # Método 2: Graham Modificado (com crescimento)
    if lpa > 0:
        preco_graham_modificado = lpa * (8.5 + 2 * growth_rate)
    else:
        preco_graham_modificado = None
    
    # Calcula margens de segurança
    if preco_graham_classico and preco_atual > 0:
        margem_classico = ((preco_graham_classico - preco_atual) / preco_atual) * 100
    else:
        margem_classico = None
    
    if preco_graham_modificado and preco_atual > 0:
        margem_modificado = ((preco_graham_modificado - preco_atual) / preco_atual) * 100
    else:
        margem_modificado = None
    
    # Preço teto conservador (o menor dos dois)
    if preco_graham_classico and preco_graham_modificado:
        preco_teto_conservador = min(preco_graham_classico, preco_graham_modificado)
    else:
        preco_teto_conservador = preco_graham_classico or preco_graham_modificado
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "lpa": lpa,
        "vpa": vpa,
        "preco_graham_classico": preco_graham_classico,
        "preco_graham_modificado": preco_graham_modificado,
        "taxa_crescimento": growth_rate,
        "preco_teto_conservador": preco_teto_conservador,
        "margem_classico": margem_classico,
        "margem_modificado": margem_modificado
    }

# Exemplo
print("\nPREÇO TETO - MÉTODO GRAHAM")
print("=" * 60)

acoes_value = ["ITUB4", "BBAS3", "VALE3", "PETR4", "WEGE3"]

for ticker in acoes_value:
    try:
        result = calculate_graham_price(ticker, growth_rate=5)
        
        print(f"\n{result['ticker']}")
        print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
        print(f"  LPA: R$ {result['lpa']:.2f} | VPA: R$ {result['vpa']:.2f}")
        
        if result['preco_graham_classico']:
            print(f"  Graham Clássico: R$ {result['preco_graham_classico']:.2f} ({result['margem_classico']:+.1f}%)")
        
        if result['preco_graham_modificado']:
            print(f"  Graham Modificado (g={result['taxa_crescimento']}%): R$ {result['preco_graham_modificado']:.2f} ({result['margem_modificado']:+.1f}%)")
        
        if result['preco_teto_conservador']:
            status = "✅" if result['preco_teto_conservador'] > result['preco_atual'] else "⚠️"
            print(f"  {status} Preço Teto Conservador: R$ {result['preco_teto_conservador']:.2f}")
            
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

Preço Justo = D1 / (r - g)

Onde:
- D1 = Dividendo esperado no próximo ano
- r = Taxa de retorno exigida (custo de capital)
- g = Taxa de crescimento perpétuo dos dividendos

def calculate_gordon_price(
    ticker: str,
    required_return: float = 0.12,  # 12% retorno exigido
    dividend_growth: float = 0.05   # 5% crescimento de dividendos
) -> dict:
    """
    Calcula preço teto pelo Modelo de Gordon (DDM)
    
    Args:
        ticker: Código da ação
        required_return: Retorno exigido pelo investidor
        dividend_growth: Taxa de crescimento esperada dos dividendos
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    dy_atual = data.get("dividendYield", 0) / 100 if data.get("dividendYield") else 0
    
    # Dividendo atual
    dividendo_atual = preco_atual * dy_atual
    
    # Dividendo esperado (D1 = D0 × (1 + g))
    d1 = dividendo_atual * (1 + dividend_growth)
    
    # Verifica se o modelo é aplicável (r > g)
    if required_return <= dividend_growth:
        return {
            "ticker": ticker,
            "erro": "Modelo não aplicável: retorno exigido deve ser maior que crescimento"
        }
    
    # Preço justo Gordon
    if d1 > 0:
        preco_gordon = d1 / (required_return - dividend_growth)
    else:
        preco_gordon = 0
    
    # Margem de segurança
    if preco_gordon > 0 and preco_atual > 0:
        margem = ((preco_gordon - preco_atual) / preco_atual) * 100
    else:
        margem = None
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "dividendo_atual": dividendo_atual,
        "dividendo_esperado": d1,
        "retorno_exigido": required_return * 100,
        "crescimento_dividendos": dividend_growth * 100,
        "preco_gordon": preco_gordon,
        "margem_seguranca": margem,
        "oportunidade": "✅ Comprar" if margem and margem > 15 else "⚠️ Neutro" if margem and margem > 0 else "❌ Caro"
    }

# Exemplo
print("\nPREÇO TETO - MODELO DE GORDON (DDM)")
print("=" * 60)

for ticker in ["TAEE11", "ITUB4", "BBAS3", "VIVT3"]:
    try:
        result = calculate_gordon_price(
            ticker,
            required_return=0.12,
            dividend_growth=0.05
        )
        
        if "erro" in result:
            print(f"\n{result['ticker']}: {result['erro']}")
            continue
        
        print(f"\n{result['ticker']}")
        print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
        print(f"  Dividendo Atual: R$ {result['dividendo_atual']:.2f}")
        print(f"  Dividendo Esperado (D1): R$ {result['dividendo_esperado']:.2f}")
        print(f"  Retorno Exigido: {result['retorno_exigido']:.1f}%")
        print(f"  Crescimento Dividendos: {result['crescimento_dividendos']:.1f}%")
        print(f"  Preço Gordon: R$ {result['preco_gordon']:.2f}")
        
        if result['margem_seguranca'] is not None:
            print(f"  Margem: {result['margem_seguranca']:+.1f}%")
        print(f"  {result['oportunidade']}")
        
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

def gordon_sensitivity_analysis(ticker: str) -> pd.DataFrame:
    """
    Analisa sensibilidade do preço Gordon a diferentes taxas
    """
    data = get_stock_data(ticker)
    preco_atual = data.get("regularMarketPrice", 0)
    dy_atual = data.get("dividendYield", 0) / 100 if data.get("dividendYield") else 0
    dividendo_atual = preco_atual * dy_atual
    
    # Variações de retorno exigido e crescimento
    returns = [0.10, 0.12, 0.14, 0.16]
    growths = [0.03, 0.05, 0.07]
    
    results = []
    for r in returns:
        for g in growths:
            if r > g:
                d1 = dividendo_atual * (1 + g)
                preco = d1 / (r - g) if d1 > 0 else 0
                margem = ((preco - preco_atual) / preco_atual) * 100 if preco > 0 else 0
                
                results.append({
                    "retorno": f"{r*100:.0f}%",
                    "crescimento": f"{g*100:.0f}%",
                    "preco_gordon": preco,
                    "margem": margem
                })
    
    return pd.DataFrame(results)

# Exemplo
print("\nANÁLISE DE SENSIBILIDADE - TAEE11")
print("=" * 50)
df_sens = gordon_sensitivity_analysis("TAEE11")
print(df_sens.to_string(index=False))

def calculate_pl_ceiling(
    ticker: str,
    max_pl: float = 12
) -> dict:
    """
    Calcula preço teto baseado em P/L máximo aceitável
    
    Args:
        ticker: Código da ação
        max_pl: P/L máximo aceitável
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    pl_atual = data.get("priceToEarnings", 0)
    lpa = data.get("earningsPerShare", 0)
    
    # Preço teto = LPA × P/L máximo
    if lpa > 0:
        preco_teto = lpa * max_pl
    else:
        preco_teto = 0
    
    # Margem de segurança
    if preco_teto > 0 and preco_atual > 0:
        margem = ((preco_teto - preco_atual) / preco_atual) * 100
    else:
        margem = None
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "lpa": lpa,
        "pl_atual": pl_atual,
        "pl_maximo": max_pl,
        "preco_teto": preco_teto,
        "margem_seguranca": margem
    }

# Exemplo
print("\nPREÇO TETO - P/L MÁXIMO")
print("=" * 50)

for ticker in ["ITUB4", "WEGE3", "PETR4", "VALE3"]:
    result = calculate_pl_ceiling(ticker, max_pl=12)
    
    print(f"\n{result['ticker']}")
    print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
    print(f"  P/L Atual: {result['pl_atual']:.1f}")
    print(f"  LPA: R$ {result['lpa']:.2f}")
    print(f"  Preço Teto (P/L máx {result['pl_maximo']}): R$ {result['preco_teto']:.2f}")
    if result['margem_seguranca'] is not None:
        status = "✅" if result['margem_seguranca'] > 0 else "❌"
        print(f"  {status} Margem: {result['margem_seguranca']:+.1f}%")

def calculate_pvp_ceiling(
    ticker: str,
    max_pvp: float = 1.5
) -> dict:
    """
    Calcula preço teto baseado em P/VP máximo aceitável
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    pvp_atual = data.get("priceToBook", 0)
    vpa = data.get("bookValue", 0)  # Valor Patrimonial por Ação
    
    # Preço teto = VPA × P/VP máximo
    if vpa > 0:
        preco_teto = vpa * max_pvp
    else:
        preco_teto = 0
    
    # Margem de segurança
    if preco_teto > 0 and preco_atual > 0:
        margem = ((preco_teto - preco_atual) / preco_atual) * 100
    else:
        margem = None
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "vpa": vpa,
        "pvp_atual": pvp_atual,
        "pvp_maximo": max_pvp,
        "preco_teto": preco_teto,
        "margem_seguranca": margem
    }

# Exemplo para bancos (P/VP geralmente < 2)
print("\nPREÇO TETO - P/VP MÁXIMO (BANCOS)")
print("=" * 50)

for ticker in ["ITUB4", "BBDC4", "SANB11", "BBAS3"]:
    result = calculate_pvp_ceiling(ticker, max_pvp=1.5)
    
    print(f"\n{result['ticker']}")
    print(f"  Preço Atual: R$ {result['preco_atual']:.2f}")
    print(f"  P/VP Atual: {result['pvp_atual']:.2f}")
    print(f"  VPA: R$ {result['vpa']:.2f}")
    print(f"  Preço Teto (P/VP máx {result['pvp_maximo']}): R$ {result['preco_teto']:.2f}")
    if result['margem_seguranca'] is not None:
        status = "✅" if result['margem_seguranca'] > 0 else "❌"
        print(f"  {status} Margem: {result['margem_seguranca']:+.1f}%")

def complete_price_analysis(
    ticker: str,
    min_yield: float = 0.06,
    growth_rate: float = 0.05,
    required_return: float = 0.12,
    max_pl: float = 12,
    max_pvp: float = 1.5
) -> dict:
    """
    Análise completa de preço teto usando todos os métodos
    """
    data = get_stock_data(ticker)
    
    preco_atual = data.get("regularMarketPrice", 0)
    lpa = data.get("earningsPerShare", 0)
    vpa = data.get("bookValue", 0)
    dy_atual = data.get("dividendYield", 0) / 100 if data.get("dividendYield") else 0
    dividendo_anual = preco_atual * dy_atual
    
    precos_teto = {}
    
    # 1. Método Bazin
    if dividendo_anual > 0:
        precos_teto["Bazin"] = dividendo_anual / min_yield
    
    # 2. Graham Clássico
    if lpa > 0 and vpa > 0:
        precos_teto["Graham Clássico"] = (22.5 * lpa * vpa) ** 0.5
    
    # 3. Graham Modificado
    if lpa > 0:
        precos_teto["Graham Modificado"] = lpa * (8.5 + 2 * (growth_rate * 100))
    
    # 4. Gordon (DDM)
    if dividendo_anual > 0 and required_return > growth_rate:
        d1 = dividendo_anual * (1 + growth_rate)
        precos_teto["Gordon"] = d1 / (required_return - growth_rate)
    
    # 5. P/L Máximo
    if lpa > 0:
        precos_teto["P/L Máximo"] = lpa * max_pl
    
    # 6. P/VP Máximo
    if vpa > 0:
        precos_teto["P/VP Máximo"] = vpa * max_pvp
    
    # Calcula estatísticas
    if precos_teto:
        valores = list(precos_teto.values())
        preco_medio = sum(valores) / len(valores)
        preco_minimo = min(valores)
        preco_maximo = max(valores)
        preco_conservador = preco_minimo  # Mais seguro
        
        # Margem de segurança média
        margem_media = ((preco_medio - preco_atual) / preco_atual) * 100
        margem_conservadora = ((preco_conservador - preco_atual) / preco_atual) * 100
    else:
        preco_medio = preco_minimo = preco_maximo = preco_conservador = 0
        margem_media = margem_conservadora = None
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "precos_teto": precos_teto,
        "preco_teto_medio": preco_medio,
        "preco_teto_conservador": preco_conservador,
        "preco_teto_otimista": preco_maximo,
        "margem_media": margem_media,
        "margem_conservadora": margem_conservadora,
        "recomendacao": get_recommendation(margem_conservadora)
    }

def get_recommendation(margem: float) -> str:
    """
    Gera recomendação baseada na margem de segurança
    """
    if margem is None:
        return "❓ Dados insuficientes"
    elif margem > 30:
        return "🔥 Forte Compra - Excelente margem de segurança"
    elif margem > 15:
        return "✅ Compra - Boa margem de segurança"
    elif margem > 0:
        return "⚠️ Neutro - Margem estreita"
    elif margem > -15:
        return "⚠️ Aguardar - Levemente caro"
    else:
        return "❌ Evitar - Muito acima do preço teto"

# Análise completa
print("\n" + "=" * 70)
print("ANÁLISE COMPLETA DE PREÇO TETO")
print("=" * 70)

acoes_analise = ["TAEE11", "ITUB4", "WEGE3", "PETR4", "VALE3", "BBAS3"]

for ticker in acoes_analise:
    try:
        result = complete_price_analysis(ticker)
        
        print(f"\n{'─' * 70}")
        print(f"📊 {ticker}")
        print(f"{'─' * 70}")
        print(f"Preço Atual: R$ {result['preco_atual']:.2f}")
        
        print("\nPreços Teto por Método:")
        for metodo, preco in result['precos_teto'].items():
            margem = ((preco - result['preco_atual']) / result['preco_atual']) * 100
            status = "✅" if margem > 0 else "❌"
            print(f"  {status} {metodo}: R$ {preco:.2f} ({margem:+.1f}%)")
        
        print(f"\nResumo:")
        print(f"  Preço Teto Conservador: R$ {result['preco_teto_conservador']:.2f}")
        print(f"  Preço Teto Médio: R$ {result['preco_teto_medio']:.2f}")
        print(f"  Preço Teto Otimista: R$ {result['preco_teto_otimista']:.2f}")
        
        print(f"\n{result['recomendacao']}")
        
    except Exception as e:
        print(f"\n{ticker}: Erro - {e}")

┌─────────────────────────────────────────────────────────────┐
│              FRAMEWORK DE PREÇO TETO                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. EMPRESA PAGA DIVIDENDOS CONSISTENTES?                   │
│     └── SIM → Use Bazin ou Gordon                           │
│     └── NÃO → Use Graham ou Múltiplos                       │
│                                                              │
│  2. EMPRESA ESTÁ EM CRESCIMENTO?                            │
│     └── SIM → Use Graham Modificado (com g)                 │
│     └── NÃO → Use Graham Clássico                           │
│                                                              │
│  3. É EMPRESA FINANCEIRA (BANCO)?                           │
│     └── SIM → Use P/VP como principal                       │
│     └── NÃO → Use combinação de métodos                     │
│                                                              │
│  4. COMBINE MÚLTIPLOS MÉTODOS                               │
│     └── Preço Conservador = menor valor                     │
│     └── Preço Médio = média dos métodos                     │
│     └── Exija margem de segurança > 15%                     │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def find_best_opportunities(tickers: List[str]) -> pd.DataFrame:
    """
    Encontra as melhores oportunidades baseado em margem de segurança
    """
    opportunities = []
    
    for ticker in tickers:
        try:
            result = complete_price_analysis(ticker)
            
            if result['margem_conservadora'] is not None:
                opportunities.append({
                    "ticker": ticker,
                    "preco_atual": result['preco_atual'],
                    "preco_teto": result['preco_teto_conservador'],
                    "margem": result['margem_conservadora'],
                    "metodos_usados": len(result['precos_teto'])
                })
        except:
            continue
    
    df = pd.DataFrame(opportunities)
    
    if not df.empty:
        df = df.sort_values("margem", ascending=False)
    
    return df

# Encontra oportunidades
print("\n" + "=" * 60)
print("RANKING DE OPORTUNIDADES POR MARGEM DE SEGURANÇA")
print("=" * 60)

todas_acoes = [
    "TAEE11", "ITUB4", "BBDC4", "BBAS3", "WEGE3", "PETR4",
    "VALE3", "RENT3", "RADL3", "EQTL3", "CMIG4", "TRPL4",
    "VIVT3", "SUZB3", "JBSS3", "CSAN3", "PRIO3", "SANB11"
]

df_oportunidades = find_best_opportunities(todas_acoes)

if not df_oportunidades.empty:
    print("\n🔥 Top Oportunidades (Margem > 0%):")
    df_positivas = df_oportunidades[df_oportunidades["margem"] > 0]
    if not df_positivas.empty:
        for _, row in df_positivas.head(10).iterrows():
            print(f"  {row['ticker']}: R$ {row['preco_atual']:.2f} (Teto: R$ {row['preco_teto']:.2f}, Margem: {row['margem']:+.1f}%)")
    else:
        print("  Nenhuma oportunidade encontrada com margem positiva.")