Ações de Seguradoras Brasil 2026: BBSE3, PSSA3, CXSE3 - Análise Completa

┌─────────────────────────────────────────────────────────────┐
│                  RECEITAS DAS SEGURADORAS                    │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   1. RESULTADO OPERACIONAL                                   │
│   ┌─────────────────────────────────────────────────────┐   │
│   │  Prêmios Recebidos - Sinistros Pagos - Despesas     │   │
│   │  = Lucro Técnico (underwriting)                     │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                              │
│   2. RESULTADO FINANCEIRO                                    │
│   ┌─────────────────────────────────────────────────────┐   │
│   │  Float (reservas) investido em renda fixa           │   │
│   │  = Ganhos com investimentos                         │   │
│   └─────────────────────────────────────────────────────┘   │
│                                                              │
│   LUCRO = Resultado Operacional + Resultado Financeiro       │
│                                                              │
└─────────────────────────────────────────────────────────────┘

import requests

def analisar_bbse3(token: str) -> dict:
    """
    Analisa indicadores da BB Seguridade
    """
    url = "https://brapi.dev/api/quote/BBSE3"
    params = {"modules": "defaultKeyStatistics,summaryDetail"}
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()["results"][0]
    
    return {
        "ticker": data["symbol"],
        "nome": data["shortName"],
        "preco": data["regularMarketPrice"],
        "variacao": data.get("regularMarketChangePercent", 0),
        "market_cap": data.get("marketCap", 0),
        "dividend_yield": data.get("dividendYield", 0),
        "p_l": data.get("priceEarnings", 0),
        "min_52": data.get("fiftyTwoWeekLow", 0),
        "max_52": data.get("fiftyTwoWeekHigh", 0),
    }

bbse = analisar_bbse3("SEU_TOKEN")
print(f"{bbse['ticker']} - {bbse['nome']}")
print(f"Preço: R$ {bbse['preco']:.2f}")
print(f"Dividend Yield: {bbse['dividend_yield']:.2f}%")
print(f"P/L: {bbse['p_l']:.2f}")

┌─────────────────────────────────────────────────────────────┐
│                    ECOSSISTEMA PORTO                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   SEGUROS              SAÚDE              SERVIÇOS           │
│   ┌─────────┐         ┌─────────┐        ┌─────────┐        │
│   │ Auto    │         │ Saúde   │        │ Porto   │        │
│   │ Casa    │         │ Dental  │        │ Bank    │        │
│   │ Vida    │         │ Ocupac. │        │ Consórc.│        │
│   └─────────┘         └─────────┘        └─────────┘        │
│        │                   │                  │              │
│        └───────────────────┼──────────────────┘              │
│                            ▼                                 │
│                   ┌───────────────┐                          │
│                   │ Porto Seguro  │                          │
│                   │     Faz       │  → Reparos, manutenção   │
│                   └───────────────┘                          │
│                                                              │
└─────────────────────────────────────────────────────────────┘

import requests
import pandas as pd

def comparar_seguradoras(token: str) -> pd.DataFrame:
    """
    Compara principais seguradoras usando brapi.dev
    """
    tickers = ["BBSE3", "PSSA3", "CXSE3", "IRBR3"]
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    comparativo = []
    for empresa in data["results"]:
        comparativo.append({
            "Ticker": empresa["symbol"],
            "Preço": f"R$ {empresa['regularMarketPrice']:.2f}",
            "Var. Dia": f"{empresa.get('regularMarketChangePercent', 0):.2f}%",
            "Mín 52s": f"R$ {empresa.get('fiftyTwoWeekLow', 0):.2f}",
            "Máx 52s": f"R$ {empresa.get('fiftyTwoWeekHigh', 0):.2f}",
        })
    
    return pd.DataFrame(comparativo)

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

Índice Combinado = (Sinistros + Despesas) / Prêmios

< 100% → Lucro operacional
= 100% → Breakeven operacional
> 100% → Prejuízo operacional (depende de resultado financeiro)

Loss Ratio = Sinistros / Prêmios Ganhos

import requests

def simular_impacto_selic(
    reservas: float,
    selic_atual: float,
    selic_anterior: float
) -> dict:
    """
    Simula impacto da variação da Selic no resultado financeiro
    """
    # Resultado financeiro estimado (reservas * taxa)
    resultado_atual = reservas * (selic_atual / 100)
    resultado_anterior = reservas * (selic_anterior / 100)
    
    diferenca = resultado_atual - resultado_anterior
    impacto_percentual = ((resultado_atual / resultado_anterior) - 1) * 100
    
    return {
        "reservas": reservas,
        "selic_anterior": selic_anterior,
        "selic_atual": selic_atual,
        "resultado_anterior": resultado_anterior,
        "resultado_atual": resultado_atual,
        "diferenca": diferenca,
        "impacto_percentual": impacto_percentual
    }

# Exemplo: BBSE3 com R$ 300 bilhões em reservas
impacto = simular_impacto_selic(300_000_000_000, 13.75, 10.75)

print("IMPACTO DA SELIC NO RESULTADO FINANCEIRO")
print("=" * 50)
print(f"Reservas: R$ {impacto['reservas']:,.0f}")
print(f"Selic anterior: {impacto['selic_anterior']}%")
print(f"Selic atual: {impacto['selic_atual']}%")
print(f"\nResultado anterior: R$ {impacto['resultado_anterior']:,.0f}")
print(f"Resultado atual: R$ {impacto['resultado_atual']:,.0f}")
print(f"Diferença: R$ {impacto['diferenca']:,.0f}")
print(f"Impacto: +{impacto['impacto_percentual']:.1f}%")

def carteira_seguradoras(
    valor_total: float,
    token: str
) -> dict:
    """
    Monta carteira focada em dividendos do setor de seguros
    """
    import requests
    
    # Alocação sugerida
    alocacao = {
        "BBSE3": 0.50,   # 50% - maior DY
        "PSSA3": 0.30,   # 30% - diversificação
        "CXSE3": 0.20,   # 20% - crescimento
    }
    
    tickers = list(alocacao.keys())
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    precos = {r["symbol"]: r["regularMarketPrice"] for r in data["results"]}
    
    carteira = []
    total = 0
    
    for ticker, peso in alocacao.items():
        valor = valor_total * peso
        preco = precos[ticker]
        cotas = int(valor // preco)
        subtotal = cotas * preco
        total += subtotal
        
        carteira.append({
            "ticker": ticker,
            "peso": peso,
            "cotas": cotas,
            "valor": subtotal
        })
    
    # Estimar dividendos
    dys = {"BBSE3": 0.09, "PSSA3": 0.06, "CXSE3": 0.07}
    dividendo_anual = sum(c["valor"] * dys[c["ticker"]] for c in carteira)
    
    return {
        "carteira": carteira,
        "total_investido": total,
        "dividendo_anual": dividendo_anual,
        "dividendo_mensal": dividendo_anual / 12,
        "dy_medio": (dividendo_anual / total) * 100
    }

# R$ 100.000 em seguradoras
resultado = carteira_seguradoras(100000, "SEU_TOKEN")

print("CARTEIRA SEGURADORAS")
print("=" * 50)
for ativo in resultado["carteira"]:
    print(f"{ativo['ticker']}: {ativo['cotas']} cotas = R$ {ativo['valor']:,.2f}")

print(f"\nTotal: R$ {resultado['total_investido']:,.2f}")
print(f"DY médio: {resultado['dy_medio']:.2f}%")
print(f"Dividendo anual: R$ {resultado['dividendo_anual']:,.2f}")
print(f"Dividendo mensal: R$ {resultado['dividendo_mensal']:,.2f}")

import requests
from datetime import datetime

def monitorar_seguradoras(token: str) -> None:
    """
    Dashboard de monitoramento do setor de seguros
    """
    tickers = ["BBSE3", "PSSA3", "CXSE3"]
    url = f"https://brapi.dev/api/quote/{','.join(tickers)}"
    headers = {"Authorization": f"Bearer {token}"}
    
    response = requests.get(url, headers=headers)
    data = response.json()
    
    print("\n" + "=" * 60)
    print(f"MONITOR SETOR SEGUROS - {datetime.now().strftime('%d/%m/%Y %H:%M')}")
    print("=" * 60)
    
    for empresa in data["results"]:
        symbol = empresa["symbol"]
        preco = empresa["regularMarketPrice"]
        variacao = empresa.get("regularMarketChangePercent", 0)
        
        # Indicador visual
        if variacao > 1:
            status = "ALTA"
        elif variacao < -1:
            status = "BAIXA"
        else:
            status = "ESTÁVEL"
        
        print(f"{symbol}: R$ {preco:.2f} ({variacao:+.2f}%) - {status}")
    
    # Buscar Selic
    try:
        url_selic = "https://brapi.dev/api/v2/prime-rate"
        response_selic = requests.get(url_selic, headers=headers)
        selic = response_selic.json()["prime-rate"][0]["value"]
        print(f"\nSelic atual: {selic}% (impacta resultado financeiro)")
    except:
        pass

# Executar
monitorar_seguradoras("SEU_TOKEN")