Small Caps Brasil 2026: Como Investir em Empresas Menores com Alto Potencial

Composição do SMLL:
- Empresas não incluídas no IBOV
- Critérios de liquidez específicos
- Rebalanceamento quadrimestral

┌─────────────────────────────────────────────────────────────┐
│            FRAMEWORK DE ANÁLISE - SMALL CAPS                 │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. QUALITATIVA                                              │
│     ├── Modelo de negócio                                    │
│     ├── Vantagens competitivas                               │
│     ├── Qualidade da gestão                                  │
│     └── Potencial de crescimento                             │
│                                                              │
│  2. QUANTITATIVA                                             │
│     ├── Crescimento de receita                               │
│     ├── Margens e lucratividade                              │
│     ├── Endividamento                                        │
│     └── Valuation (P/L, EV/EBITDA)                          │
│                                                              │
│  3. TÉCNICA                                                  │
│     ├── Liquidez diária                                      │
│     ├── Free float                                           │
│     └── Tendência de preço                                   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def calculate_revenue_cagr(revenues: list, years: int) -> float:
    """
    Calcula CAGR (taxa de crescimento anual composta) da receita
    """
    if len(revenues) < 2:
        return 0
    
    initial = revenues[0]
    final = revenues[-1]
    
    cagr = ((final / initial) ** (1 / years) - 1) * 100
    return cagr

# Exemplo
revenues = [100, 130, 175, 240, 320]  # 5 anos de receita (milhões)
cagr = calculate_revenue_cagr(revenues, 4)
print(f"CAGR de Receita: {cagr:.1f}%")

# Interpretação
# CAGR > 20%: Crescimento acelerado (excelente para Small Cap)
# CAGR 10-20%: Crescimento sólido
# CAGR < 10%: Crescimento lento (risco para Small Cap)

def analyze_margins(receita: float, ebitda: float, lucro_liquido: float) -> dict:
    """
    Analisa margens de uma Small Cap
    """
    margem_ebitda = (ebitda / receita) * 100
    margem_liquida = (lucro_liquido / receita) * 100
    
    return {
        "margem_ebitda": margem_ebitda,
        "margem_liquida": margem_liquida,
        "qualidade": "Alta" if margem_ebitda > 20 else "Média" if margem_ebitda > 10 else "Baixa"
    }

def analyze_leverage(divida_liquida: float, ebitda: float) -> dict:
    """
    Analisa alavancagem de uma Small Cap
    """
    ratio = divida_liquida / ebitda if ebitda > 0 else float('inf')
    
    if ratio < 1:
        risco = "Baixo"
        status = "✅ Empresa pouco alavancada"
    elif ratio < 2.5:
        risco = "Moderado"
        status = "✓ Alavancagem aceitável"
    elif ratio < 4:
        risco = "Alto"
        status = "⚠️ Alavancagem elevada"
    else:
        risco = "Muito Alto"
        status = "❌ Alavancagem perigosa"
    
    return {
        "divida_ebitda": ratio,
        "risco": risco,
        "status": status
    }

def analyze_returns(lucro_liquido: float, patrimonio_liquido: float, capital_investido: float) -> dict:
    """
    Analisa retornos de uma Small Cap
    """
    roe = (lucro_liquido / patrimonio_liquido) * 100 if patrimonio_liquido > 0 else 0
    roic = (lucro_liquido / capital_investido) * 100 if capital_investido > 0 else 0
    
    return {
        "roe": roe,
        "roic": roic,
        "qualidade_roe": "Excelente" if roe > 20 else "Bom" if roe > 15 else "Regular",
        "qualidade_roic": "Excelente" if roic > 15 else "Bom" if roic > 10 else "Regular"
    }

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 is_small_cap(data: dict) -> bool:
    """
    Verifica se a empresa é uma Small Cap
    """
    market_cap = data.get("marketCap", 0)
    
    # Small Cap: Market Cap entre 300M e 5B
    return 300_000_000 <= market_cap <= 5_000_000_000

def analyze_small_cap(ticker: str) -> dict:
    """
    Análise completa de uma Small Cap
    """
    data = get_stock_data(ticker)
    
    market_cap = data.get("marketCap", 0)
    
    analysis = {
        "ticker": ticker,
        "nome": data.get("longName", "N/A"),
        "setor": data.get("sector", "N/A"),
        "preco": data.get("regularMarketPrice", 0),
        "market_cap": market_cap,
        "market_cap_bilhoes": market_cap / 1_000_000_000,
        "is_small_cap": is_small_cap(data),
        
        # Valuation
        "p_l": data.get("priceToEarnings", 0),
        "p_vp": data.get("priceToBook", 0),
        "ev_ebitda": data.get("enterpriseToEbitda", 0),
        
        # Rentabilidade
        "roe": data.get("returnOnEquity", 0),
        "margem_liquida": data.get("profitMargin", 0),
        
        # Dividendos
        "dividend_yield": data.get("dividendYield", 0),
        
        # Liquidez
        "volume_diario": data.get("regularMarketVolume", 0),
    }
    
    return analysis

def screen_small_caps(tickers: List[str]) -> pd.DataFrame:
    """
    Filtra e analisa múltiplas Small Caps
    """
    results = []
    
    for ticker in tickers:
        try:
            analysis = analyze_small_cap(ticker)
            if analysis["is_small_cap"]:
                results.append(analysis)
        except Exception as e:
            print(f"Erro ao analisar {ticker}: {e}")
    
    df = pd.DataFrame(results)
    return df.sort_values("market_cap_bilhoes")

# Exemplo: Screening de Small Caps
potenciais_small_caps = [
    "POSI3",  # Positivo Tecnologia
    "MDIA3",  # M. Dias Branco
    "AERI3",  # Aeris
    "SIMH3",  # Simpar
    "MOVI3",  # Movida
    "INTB3",  # Intelbras
    "LWSA3",  # Locaweb
    "CASH3",  # Méliuz
    "PETZ3",  # Petz
    "ENJU3",  # Enjoei
]

print("SCREENING DE SMALL CAPS BRASILEIRAS")
print("=" * 60)

df = screen_small_caps(potenciais_small_caps)

if not df.empty:
    print("\nSmall Caps Identificadas:")
    print(df[["ticker", "nome", "market_cap_bilhoes", "p_l", "roe"]].to_string(index=False))

def advanced_small_cap_screener(min_roe: float = 10, max_pl: float = 20, min_volume: int = 500000) -> pd.DataFrame:
    """
    Screener avançado para encontrar Small Caps de qualidade
    """
    # Lista de potenciais Small Caps para análise
    candidates = [
        "POSI3", "MDIA3", "AERI3", "INTB3", "LWSA3",
        "CASH3", "PETZ3", "ENJU3", "TFCO4", "BRIT3",
        "ESPA3", "BLAU3", "AESB3", "EVEN3", "CURY3"
    ]
    
    qualified = []
    
    for ticker in candidates:
        try:
            data = analyze_small_cap(ticker)
            
            # Filtros de qualidade
            if not data["is_small_cap"]:
                continue
            
            if data["roe"] < min_roe:
                continue
            
            if data["p_l"] > max_pl or data["p_l"] <= 0:
                continue
            
            if data["volume_diario"] < min_volume:
                continue
            
            # Pontuação
            score = 0
            score += 20 if data["roe"] > 20 else 10 if data["roe"] > 15 else 0
            score += 20 if 5 < data["p_l"] < 12 else 10 if data["p_l"] < 15 else 0
            score += 20 if data["ev_ebitda"] < 8 else 10 if data["ev_ebitda"] < 12 else 0
            score += 20 if data["margem_liquida"] > 10 else 10 if data["margem_liquida"] > 5 else 0
            score += 20 if data["dividend_yield"] > 3 else 10 if data["dividend_yield"] > 1 else 0
            
            data["score"] = score
            qualified.append(data)
            
        except Exception as e:
            continue
    
    df = pd.DataFrame(qualified)
    
    if not df.empty:
        df = df.sort_values("score", ascending=False)
    
    return df

# Executa screener
print("\n" + "=" * 60)
print("SCREENER AVANÇADO DE SMALL CAPS")
print("=" * 60)

df_screened = advanced_small_cap_screener(min_roe=10, max_pl=20)

if not df_screened.empty:
    print("\nTop Small Caps por Score:")
    cols = ["ticker", "nome", "score", "roe", "p_l", "market_cap_bilhoes"]
    print(df_screened[cols].head(10).to_string(index=False))

def compare_growth_rates(tickers: List[str]) -> None:
    """
    Compara taxas de crescimento entre Small Caps
    """
    print("\nCOMPARATIVO DE CRESCIMENTO")
    print("=" * 50)
    
    for ticker in tickers:
        try:
            # Busca dados históricos
            url = f"{BASE_URL}/quote/{ticker}"
            params = {
                "range": "5y",
                "interval": "1mo",
                "fundamental": "true"
            }
            headers = {"Authorization": f"Bearer {API_TOKEN}"}
            
            response = requests.get(url, params=params, headers=headers)
            data = response.json()["results"][0]
            
            historical = data.get("historicalDataPrice", [])
            
            if len(historical) > 12:
                # Calcula retorno
                preco_inicial = historical[0]["close"]
                preco_atual = historical[-1]["close"]
                retorno = ((preco_atual / preco_inicial) - 1) * 100
                
                print(f"\n{ticker}")
                print(f"  Preço inicial (5 anos): R$ {preco_inicial:.2f}")
                print(f"  Preço atual: R$ {preco_atual:.2f}")
                print(f"  Retorno total: {retorno:.1f}%")
                print(f"  CAGR: {((preco_atual/preco_inicial)**(1/5) - 1) * 100:.1f}%")
                
        except Exception as e:
            print(f"Erro ao analisar {ticker}: {e}")

# Compara Small Caps
compare_growth_rates(["POSI3", "INTB3", "LWSA3"])

def garp_screen(tickers: List[str]) -> pd.DataFrame:
    """
    Estratégia GARP para Small Caps
    Busca: Crescimento + Valuation razoável
    """
    garp_candidates = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            if not is_small_cap(data):
                continue
            
            roe = data.get("returnOnEquity", 0) * 100
            pl = data.get("priceToEarnings", 0)
            
            # PEG Ratio aproximado (P/L dividido pelo crescimento)
            # Usamos ROE como proxy de crescimento
            peg = pl / roe if roe > 0 else float('inf')
            
            # GARP: PEG < 1.5 é atrativo
            if peg < 1.5 and pl > 0 and roe > 10:
                garp_candidates.append({
                    "ticker": ticker,
                    "roe": roe,
                    "pl": pl,
                    "peg_ratio": peg,
                    "atratividade": "Alta" if peg < 1 else "Média"
                })
                
        except:
            continue
    
    return pd.DataFrame(garp_candidates).sort_values("peg_ratio")

print("ESTRATÉGIA GARP - SMALL CAPS")
print("=" * 50)
df_garp = garp_screen(potenciais_small_caps)
if not df_garp.empty:
    print(df_garp.to_string(index=False))

def turnaround_screen(tickers: List[str]) -> List[dict]:
    """
    Identifica candidatos a turnaround
    """
    turnarounds = []
    
    for ticker in tickers:
        try:
            data = get_stock_data(ticker)
            
            if not is_small_cap(data):
                continue
            
            # Sinais de turnaround
            p_vp = data.get("priceToBook", 0)
            variacao_52s = data.get("fiftyTwoWeekLowChangePercent", 0) * 100
            
            # Empresa negociando perto das mínimas de 52 semanas
            # mas com P/VP baixo (potencial valor escondido)
            if p_vp < 1 and variacao_52s < 30:
                turnarounds.append({
                    "ticker": ticker,
                    "p_vp": p_vp,
                    "distancia_minima_52s": variacao_52s,
                    "potencial": "Alto" if p_vp < 0.7 else "Médio"
                })
                
        except:
            continue
    
    return turnarounds

def niche_leaders():
    """
    Small Caps líderes em nichos específicos
    """
    niche_leaders = {
        "Tecnologia Educacional": {
            "ticker": "POSI3",
            "posicao": "Líder em computadores educacionais"
        },
        "Intelbras": {
            "ticker": "INTB3", 
            "posicao": "Líder em segurança eletrônica"
        },
        "Alimentos (Biscoitos)": {
            "ticker": "MDIA3",
            "posicao": "Líder em biscoitos e massas"
        },
        "Pet Shop": {
            "ticker": "PETZ3",
            "posicao": "Maior rede de pet shops"
        }
    }
    
    print("LÍDERES DE NICHO - SMALL CAPS")
    print("=" * 50)
    
    for nicho, info in niche_leaders.items():
        try:
            data = analyze_small_cap(info["ticker"])
            print(f"\n{nicho}")
            print(f"  {info['ticker']}: {info['posicao']}")
            print(f"  Market Cap: R$ {data['market_cap_bilhoes']:.2f}B")
            print(f"  P/L: {data['p_l']:.1f}")
            print(f"  ROE: {data['roe']:.1f}%")
        except:
            continue

niche_leaders()

┌─────────────────────────────────────────────────────────────┐
│           REGRAS DE ALOCAÇÃO - SMALL CAPS                    │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. DIVERSIFICAÇÃO                                           │
│     ├── Mínimo 8-12 Small Caps na carteira                  │
│     ├── Máximo 5-8% por posição individual                  │
│     └── Diversifique por setores                             │
│                                                              │
│  2. LIQUIDEZ                                                 │
│     ├── Volume diário > R$ 500k (ideal > R$ 1M)             │
│     └── Free float > 25%                                     │
│                                                              │
│  3. PROPORÇÃO NA CARTEIRA TOTAL                             │
│     ├── Conservador: 5-10% em Small Caps                    │
│     ├── Moderado: 15-25% em Small Caps                      │
│     └── Arrojado: 30-40% em Small Caps                      │
│                                                              │
│  4. REBALANCEAMENTO                                          │
│     ├── Trimestral ou semestral                             │
│     └── Realize lucros quando posição >10%                  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def build_small_cap_portfolio(capital: float) -> dict:
    """
    Constrói uma carteira diversificada de Small Caps
    """
    portfolio = [
        # Tecnologia
        {"ticker": "POSI3", "peso": 10, "setor": "Tecnologia"},
        {"ticker": "INTB3", "peso": 10, "setor": "Tecnologia"},
        {"ticker": "LWSA3", "peso": 8, "setor": "Tecnologia"},
        
        # Consumo
        {"ticker": "MDIA3", "peso": 10, "setor": "Consumo"},
        {"ticker": "PETZ3", "peso": 8, "setor": "Consumo"},
        
        # Indústria
        {"ticker": "AERI3", "peso": 8, "setor": "Indústria"},
        
        # Financeiro
        {"ticker": "CASH3", "peso": 8, "setor": "Financeiro"},
        
        # Construção
        {"ticker": "CURY3", "peso": 10, "setor": "Construção"},
        {"ticker": "EVEN3", "peso": 8, "setor": "Construção"},
        
        # Saúde
        {"ticker": "BLAU3", "peso": 10, "setor": "Saúde"},
        
        # Caixa/Reserva
        {"ticker": "CAIXA", "peso": 10, "setor": "Reserva"}
    ]
    
    print(f"\nCARTEIRA SMALL CAP - Capital: R$ {capital:,.0f}")
    print("=" * 60)
    
    total_alocado = 0
    for position in portfolio:
        if position["ticker"] == "CAIXA":
            continue
            
        valor = capital * (position["peso"] / 100)
        total_alocado += valor
        
        try:
            data = get_stock_data(position["ticker"])
            preco = data.get("regularMarketPrice", 0)
            quantidade = int(valor / preco) if preco > 0 else 0
            
            print(f"{position['ticker']} ({position['setor']})")
            print(f"  Peso: {position['peso']}% | Valor: R$ {valor:,.0f}")
            print(f"  Preço: R$ {preco:.2f} | Quantidade: {quantidade}")
        except:
            print(f"{position['ticker']}: Erro ao buscar dados")
    
    print(f"\n{'='*60}")
    print(f"Total Alocado: R$ {total_alocado:,.0f}")
    print(f"Reserva (10%): R$ {capital * 0.1:,.0f}")
    
    return portfolio

# Exemplo
build_small_cap_portfolio(50000)

def check_liquidity_risk(ticker: str, position_size: float) -> dict:
    """
    Avalia risco de liquidez de uma posição
    """
    data = get_stock_data(ticker)
    volume_diario = data.get("regularMarketVolume", 0)
    preco = data.get("regularMarketPrice", 1)
    volume_financeiro = volume_diario * preco
    
    # Dias para sair da posição (sem impactar mais que 10% do volume)
    dias_para_sair = position_size / (volume_financeiro * 0.1)
    
    if dias_para_sair <= 1:
        risco = "Baixo"
        status = "✅"
    elif dias_para_sair <= 5:
        risco = "Moderado"
        status = "⚠️"
    else:
        risco = "Alto"
        status = "❌"
    
    return {
        "ticker": ticker,
        "volume_diario": volume_financeiro,
        "posicao": position_size,
        "dias_para_sair": dias_para_sair,
        "risco_liquidez": risco,
        "status": status
    }

# Exemplo
result = check_liquidity_risk("POSI3", 50000)
print(f"Risco de liquidez {result['ticker']}: {result['status']} {result['risco_liquidez']}")
print(f"Dias para sair: {result['dias_para_sair']:.1f}")

def check_concentration_risk(portfolio: List[dict]) -> dict:
    """
    Avalia concentração da carteira por setor
    """
    sector_weights = {}
    
    for position in portfolio:
        setor = position.get("setor", "Outros")
        peso = position.get("peso", 0)
        
        if setor in sector_weights:
            sector_weights[setor] += peso
        else:
            sector_weights[setor] = peso
    
    max_sector = max(sector_weights.items(), key=lambda x: x[1])
    
    warnings = []
    for setor, peso in sector_weights.items():
        if peso > 30:
            warnings.append(f"⚠️ {setor} representa {peso}% (>30%)")
    
    return {
        "setores": sector_weights,
        "maior_concentracao": max_sector,
        "avisos": warnings,
        "diversificado": len(warnings) == 0
    }

def compare_smll_ibov():
    """
    Compara desempenho histórico SMLL vs Ibovespa
    """
    # Dados históricos aproximados (para ilustração)
    # Em produção, use dados reais da B3 ou APIs
    
    historical = {
        "2019": {"smll": 49.7, "ibov": 31.6},
        "2020": {"smll": 0.5, "ibov": 2.9},
        "2021": {"smll": -16.2, "ibov": -11.9},
        "2022": {"smll": -0.8, "ibov": 4.7},
        "2023": {"smll": 17.1, "ibov": 22.3},
        "2024": {"smll": -6.5, "ibov": -10.4}  # Até data
    }
    
    print("SMLL vs IBOVESPA - RETORNOS ANUAIS")
    print("=" * 45)
    print(f"{'Ano':<8} {'SMLL':>12} {'IBOV':>12} {'Diferença':>12}")
    print("-" * 45)
    
    smll_acum = 100
    ibov_acum = 100
    
    for ano, retornos in historical.items():
        smll_acum *= (1 + retornos["smll"]/100)
        ibov_acum *= (1 + retornos["ibov"]/100)
        diff = retornos["smll"] - retornos["ibov"]
        
        print(f"{ano:<8} {retornos['smll']:>11.1f}% {retornos['ibov']:>11.1f}% {diff:>+11.1f}%")
    
    print("-" * 45)
    print(f"{'Acumulado':<8} {smll_acum:>11.1f} {ibov_acum:>11.1f}")

compare_smll_ibov()

┌─────────────────────────────────────────────────────────────┐
│               SINAIS DE VENDA - SMALL CAPS                   │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  VENDA OBRIGATÓRIA:                                          │
│  ❌ Fraude contábil ou problemas de governança               │
│  ❌ Perda permanente de vantagem competitiva                 │
│  ❌ Deterioração estrutural do setor                         │
│                                                              │
│  CONSIDERE VENDER:                                           │
│  ⚠️ Valuation muito esticado (P/L > 30 sem justificativa)   │
│  ⚠️ Crescimento desacelerando significativamente            │
│  ⚠️ Endividamento aumentando perigosamente                  │
│  ⚠️ Gestão vendendo ações massivamente                      │
│                                                              │
│  REALIZE LUCROS PARCIAIS:                                    │
│  💰 Ação valorizou > 100% em 12 meses                       │
│  💰 Posição passou de 10% da carteira                       │
│  💰 Empresa virou Mid/Large Cap                              │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def monitor_small_cap_portfolio(portfolio: List[str]) -> None:
    """
    Monitora carteira de Small Caps para sinais de alerta
    """
    print("\nMONITORAMENTO DE SMALL CAPS")
    print("=" * 60)
    
    for ticker in portfolio:
        try:
            data = get_stock_data(ticker)
            
            alerts = []
            
            # Verifica P/L alto
            pl = data.get("priceToEarnings", 0)
            if pl > 30:
                alerts.append(f"⚠️ P/L muito alto ({pl:.1f})")
            
            # Verifica endividamento
            debt_equity = data.get("debtToEquity", 0)
            if debt_equity > 2:
                alerts.append(f"⚠️ Endividamento alto (D/E: {debt_equity:.1f})")
            
            # Verifica queda de 52 semanas
            low_change = data.get("fiftyTwoWeekLowChangePercent", 0) * 100
            if low_change < 5:
                alerts.append(f"⚠️ Perto da mínima de 52 sem ({low_change:.1f}%)")
            
            # Verifica alta de 52 semanas
            high_change = data.get("fiftyTwoWeekHighChangePercent", 0) * 100
            if high_change > -5:
                alerts.append(f"💰 Perto da máxima de 52 sem")
            
            print(f"\n{ticker}")
            if alerts:
                for alert in alerts:
                    print(f"  {alert}")
            else:
                print("  ✅ Sem alertas")
                
        except Exception as e:
            print(f"\n{ticker}: Erro - {e}")

# Exemplo
monitor_small_cap_portfolio(["POSI3", "INTB3", "MDIA3", "LWSA3", "PETZ3"])