Fluxo de Caixa Descontado (DCF) 2026: Como Calcular o Valor Justo de Ações

┌─────────────────────────────────────────────────────────────┐
│                    CONCEITO DCF                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Valor Hoje = Soma dos Fluxos de Caixa Futuros              │
│               ────────────────────────────────              │
│               (1 + taxa de desconto)^n                      │
│                                                             │
│  Exemplo:                                                   │
│  ├─ FCF Ano 1: R$ 100 / (1.12)¹ = R$ 89.29                  │
│  ├─ FCF Ano 2: R$ 110 / (1.12)² = R$ 87.69                  │
│  ├─ FCF Ano 3: R$ 121 / (1.12)³ = R$ 86.13                  │
│  └─ ...                                                     │
│                                                             │
│  Valor Total = Soma de todos os valores presentes           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

                  n     FCFₜ           TV
Valor Empresa = Σ    ────────── + ──────────
                t=1  (1 + WACC)ᵗ   (1 + WACC)ⁿ

Onde:
- FCFₜ = Free Cash Flow no ano t
- WACC = Custo Médio Ponderado de Capital
- TV = Terminal Value (Valor Terminal)
- n = Número de anos projetados

def calcular_fcf(ebit, taxa_imposto, depreciacao, capex, variacao_capital_giro):
    """
    Calcula o Free Cash Flow to Firm (FCFF).
    
    FCF = EBIT × (1 - t) + D&A - CAPEX - Δ Capital de Giro
    
    Onde:
    - EBIT = Lucro operacional
    - t = Taxa de imposto
    - D&A = Depreciação e Amortização
    - CAPEX = Investimentos em ativos fixos
    - Δ Capital de Giro = Variação no capital de giro
    """
    nopat = ebit * (1 - taxa_imposto)  # Lucro operacional após impostos
    fcf = nopat + depreciacao - capex - variacao_capital_giro
    return fcf

ebit = 5_000_000_000  # R$ 5 bilhões
taxa_imposto = 0.34   # 34%
depreciacao = 800_000_000
capex = 1_200_000_000
delta_cg = 200_000_000

fcf = calcular_fcf(ebit, taxa_imposto, depreciacao, capex, delta_cg)
print(f"FCF: R$ {fcf/1e9:.2f} bilhões")  # R$ 2.70 bilhões

import requests

def obter_fcf_brapi(ticker):
    """
    Obtém dados para cálculo do FCF via brapi.dev.
    """
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}?modules=incomeStatementHistory,cashflowStatementHistory,balanceSheetHistory",
        headers={"Authorization": "Bearer SEU_TOKEN"}
    )
    data = response.json()["results"][0]
    
    # Extrair dados do Income Statement
    income = data.get("incomeStatementHistory", {}).get("incomeStatementHistory", [{}])[0]
    ebit = income.get("ebit", 0)
    
    # Extrair dados do Cash Flow Statement
    cashflow = data.get("cashflowStatementHistory", {}).get("cashflowStatements", [{}])[0]
    depreciacao = cashflow.get("depreciation", 0)
    capex = abs(cashflow.get("capitalExpenditures", 0))
    variacao_cg = cashflow.get("changeInWorkingCapital", 0)
    
    return {
        "ticker": ticker,
        "ebit": ebit,
        "depreciacao": depreciacao,
        "capex": capex,
        "variacao_cg": variacao_cg,
    }

# Exemplo
dados = obter_fcf_brapi("WEGE3")
print(dados)

┌─────────────────────────────────────────────────────────────┐
│           FCF HISTÓRICO E PROJETADO (R$ milhões)            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  HISTÓRICO          │  PROJETADO                            │
│  ──────────         │  ──────────                           │
│  2022: R$ 2.100     │  2026: R$ 3.200 (+10%)                │
│  2023: R$ 2.450     │  2026: R$ 3.520 (+10%)                │
│  2024: R$ 2.900     │  2027: R$ 3.872 (+10%)                │
│                     │  2028: R$ 4.065 (+5%)                 │
│  Cresc. médio: 17%  │  2029: R$ 4.268 (+5%)                 │
│                     │  Após: 3% perpetuidade                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

def calcular_wacc(custo_equity, custo_divida, taxa_imposto, peso_equity, peso_divida):
    """
    Calcula o WACC.
    
    WACC = Ke × We + Kd × (1 - t) × Wd
    
    Onde:
    - Ke = Custo do Equity
    - Kd = Custo da Dívida
    - t = Taxa de imposto
    - We = Peso do Equity
    - Wd = Peso da Dívida
    """
    wacc = custo_equity * peso_equity + custo_divida * (1 - taxa_imposto) * peso_divida
    return wacc

# Exemplo
custo_equity = 0.14   # 14% (calculado via CAPM)
custo_divida = 0.10   # 10% (taxa média da dívida)
taxa_imposto = 0.34   # 34%
peso_equity = 0.70    # 70% equity
peso_divida = 0.30    # 30% dívida

wacc = calcular_wacc(custo_equity, custo_divida, taxa_imposto, peso_equity, peso_divida)
print(f"WACC: {wacc*100:.2f}%")  # 11.78%

def calcular_capm(taxa_livre_risco, beta, premio_mercado, risco_pais=0):
    """
    Calcula o custo do equity via CAPM.
    
    Ke = Rf + β × (Rm - Rf) + CRP
    
    Onde:
    - Rf = Taxa livre de risco
    - β = Beta da ação
    - Rm - Rf = Prêmio de risco do mercado
    - CRP = Country Risk Premium (risco país)
    """
    custo_equity = taxa_livre_risco + beta * premio_mercado + risco_pais
    return custo_equity

# Parâmetros para Brasil (2026)
taxa_selic = 0.1175   # SELIC 11.75%
beta_wege = 0.85      # Beta WEGE3
premio_mercado = 0.05 # 5% histórico Brasil
risco_pais = 0.02     # CDS Brasil ~200bps

custo_equity = calcular_capm(taxa_selic, beta_wege, premio_mercado, risco_pais)
print(f"Custo do Equity: {custo_equity*100:.2f}%")  # 18.00%

def obter_beta(ticker):
    """
    Obtém o beta de uma ação.
    """
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}?fundamental=true",
        headers={"Authorization": "Bearer SEU_TOKEN"}
    )
    data = response.json()["results"][0]
    return data.get("beta", 1.0)

beta = obter_beta("WEGE3")
print(f"Beta WEGE3: {beta:.2f}")

def calcular_valor_terminal_perpetuidade(fcf_final, wacc, crescimento_perpetuo):
    """
    Calcula o valor terminal usando modelo de Gordon.
    
    TV = FCF(n+1) / (WACC - g)
    
    Onde:
    - FCF(n+1) = FCF do primeiro ano após projeção
    - g = Taxa de crescimento na perpetuidade
    """
    if wacc <= crescimento_perpetuo:
        raise ValueError("WACC deve ser maior que crescimento")
    
    fcf_perpetuo = fcf_final * (1 + crescimento_perpetuo)
    valor_terminal = fcf_perpetuo / (wacc - crescimento_perpetuo)
    return valor_terminal

# Exemplo
fcf_ano_5 = 4_268_000_000  # R$ 4.27 bi
wacc = 0.12               # 12%
crescimento_perpetuo = 0.03  # 3%

tv = calcular_valor_terminal_perpetuidade(fcf_ano_5, wacc, crescimento_perpetuo)
print(f"Valor Terminal: R$ {tv/1e9:.2f} bilhões")  # R$ 48.85 bi

def calcular_valor_terminal_multiplo(ebitda_final, multiplo_saida):
    """
    Calcula o valor terminal usando múltiplo EV/EBITDA.
    
    TV = EBITDA(n) × Múltiplo
    """
    return ebitda_final * multiplo_saida

# Exemplo
ebitda_ano_5 = 6_000_000_000  # R$ 6 bi
multiplo_saida = 8  # 8x EV/EBITDA

tv_multiplo = calcular_valor_terminal_multiplo(ebitda_ano_5, multiplo_saida)
print(f"Valor Terminal (Múltiplo): R$ {tv_multiplo/1e9:.2f} bilhões")  # R$ 48 bi

import numpy as np
import requests

class DCFModel:
    """Modelo de Fluxo de Caixa Descontado"""
    
    def __init__(self, token):
        self.token = token
        self.base_url = "https://brapi.dev/api"
    
    def obter_dados(self, ticker):
        """Obtém dados fundamentalistas"""
        response = requests.get(
            f"{self.base_url}/quote/{ticker}?fundamental=true&modules=cashflowStatementHistory",
            headers={"Authorization": f"Bearer {self.token}"}
        )
        return response.json()["results"][0]
    
    def projetar_fcf(self, fcf_atual, anos_projecao, taxas_crescimento):
        """
        Projeta FCF para os próximos anos.
        
        taxas_crescimento: lista de taxas por ano ou taxa única
        """
        if isinstance(taxas_crescimento, (int, float)):
            taxas_crescimento = [taxas_crescimento] * anos_projecao
        
        fcfs = []
        fcf = fcf_atual
        for taxa in taxas_crescimento:
            fcf = fcf * (1 + taxa)
            fcfs.append(fcf)
        
        return fcfs
    
    def descontar_fluxos(self, fcfs, wacc):
        """Desconta os fluxos de caixa a valor presente"""
        vp_fcfs = []
        for i, fcf in enumerate(fcfs, 1):
            vp = fcf / ((1 + wacc) ** i)
            vp_fcfs.append(vp)
        return vp_fcfs
    
    def calcular_valor_terminal(self, fcf_final, wacc, crescimento_perpetuo):
        """Calcula valor terminal usando perpetuidade"""
        fcf_perpetuo = fcf_final * (1 + crescimento_perpetuo)
        return fcf_perpetuo / (wacc - crescimento_perpetuo)
    
    def calcular_valor_empresa(self, fcfs_vp, tv_vp):
        """Soma todos os valores presentes"""
        return sum(fcfs_vp) + tv_vp
    
    def calcular_valor_equity(self, valor_empresa, divida_liquida):
        """Calcula valor do equity"""
        return valor_empresa - divida_liquida
    
    def calcular_preco_justo(self, valor_equity, acoes_outstanding):
        """Calcula preço justo por ação"""
        return valor_equity / acoes_outstanding
    
    def run_dcf(self, ticker, params):
        """
        Executa o modelo DCF completo.
        
        params = {
            'fcf_atual': float,
            'anos_projecao': int,
            'taxas_crescimento': list or float,
            'wacc': float,
            'crescimento_perpetuo': float,
            'divida_liquida': float,
            'acoes_outstanding': float
        }
        """
        # 1. Projetar FCFs
        fcfs = self.projetar_fcf(
            params['fcf_atual'],
            params['anos_projecao'],
            params['taxas_crescimento']
        )
        
        # 2. Descontar FCFs
        fcfs_vp = self.descontar_fluxos(fcfs, params['wacc'])
        
        # 3. Calcular Valor Terminal
        tv = self.calcular_valor_terminal(
            fcfs[-1],
            params['wacc'],
            params['crescimento_perpetuo']
        )
        
        # 4. Descontar Valor Terminal
        tv_vp = tv / ((1 + params['wacc']) ** params['anos_projecao'])
        
        # 5. Valor da Empresa
        valor_empresa = self.calcular_valor_empresa(fcfs_vp, tv_vp)
        
        # 6. Valor do Equity
        valor_equity = self.calcular_valor_equity(
            valor_empresa,
            params['divida_liquida']
        )
        
        # 7. Preço Justo
        preco_justo = self.calcular_preco_justo(
            valor_equity,
            params['acoes_outstanding']
        )
        
        return {
            'ticker': ticker,
            'fcfs_projetados': fcfs,
            'fcfs_valor_presente': fcfs_vp,
            'valor_terminal': tv,
            'valor_terminal_vp': tv_vp,
            'valor_empresa': valor_empresa,
            'valor_equity': valor_equity,
            'preco_justo': preco_justo,
            'detalhes': {
                'soma_fcfs_vp': sum(fcfs_vp),
                'proporcao_tv': tv_vp / valor_empresa * 100
            }
        }

# Parâmetros WEGE3 (valores ilustrativos)
params_wege = {
    'fcf_atual': 2_500_000_000,      # R$ 2.5 bi
    'anos_projecao': 5,
    'taxas_crescimento': [0.12, 0.12, 0.10, 0.08, 0.06],  # Desaceleração
    'wacc': 0.12,                     # 12%
    'crescimento_perpetuo': 0.03,     # 3%
    'divida_liquida': 2_000_000_000,  # R$ 2 bi
    'acoes_outstanding': 2_100_000_000  # 2.1 bi ações
}

# Executar DCF
dcf = DCFModel("SEU_TOKEN")
resultado = dcf.run_dcf("WEGE3", params_wege)

# Exibir resultados
print(f"""
╔══════════════════════════════════════════════════════════════╗
║                    DCF VALUATION - WEGE3                     ║
╠══════════════════════════════════════════════════════════════╣
║                                                              ║
║  FCFs Projetados (R$ bi):                                    ║
║  Ano 1: {resultado['fcfs_projetados'][0]/1e9:.2f}                                           ║
║  Ano 2: {resultado['fcfs_projetados'][1]/1e9:.2f}                                           ║
║  Ano 3: {resultado['fcfs_projetados'][2]/1e9:.2f}                                           ║
║  Ano 4: {resultado['fcfs_projetados'][3]/1e9:.2f}                                           ║
║  Ano 5: {resultado['fcfs_projetados'][4]/1e9:.2f}                                           ║
║                                                              ║
║  Valor Terminal: R$ {resultado['valor_terminal']/1e9:.2f} bi                              ║
║  Valor Terminal VP: R$ {resultado['valor_terminal_vp']/1e9:.2f} bi                        ║
║                                                              ║
║  Valor da Empresa: R$ {resultado['valor_empresa']/1e9:.2f} bi                             ║
║  (-) Dívida Líquida: R$ 2.00 bi                              ║
║  (=) Valor do Equity: R$ {resultado['valor_equity']/1e9:.2f} bi                           ║
║                                                              ║
║  ═══════════════════════════════════════════════════════     ║
║  PREÇO JUSTO: R$ {resultado['preco_justo']:.2f}                                       ║
║  ═══════════════════════════════════════════════════════     ║
║                                                              ║
║  % Valor no Terminal: {resultado['detalhes']['proporcao_tv']:.1f}%                            ║
║                                                              ║
╚══════════════════════════════════════════════════════════════╝
""")

import numpy as np

def analise_sensibilidade(dcf_model, ticker, params_base, 
                          wacc_range, crescimento_range):
    """
    Cria tabela de sensibilidade WACC vs Crescimento Perpétuo.
    """
    resultados = []
    
    for wacc in wacc_range:
        linha = []
        for g in crescimento_range:
            params = params_base.copy()
            params['wacc'] = wacc
            params['crescimento_perpetuo'] = g
            
            try:
                resultado = dcf_model.run_dcf(ticker, params)
                preco = resultado['preco_justo']
            except:
                preco = float('nan')
            
            linha.append(preco)
        resultados.append(linha)
    
    return np.array(resultados)

# Ranges de sensibilidade
wacc_range = [0.10, 0.11, 0.12, 0.13, 0.14]
crescimento_range = [0.02, 0.025, 0.03, 0.035, 0.04]

# Executar
sensibilidade = analise_sensibilidade(
    dcf, "WEGE3", params_wege, 
    wacc_range, crescimento_range
)

# Exibir tabela
print("\n📊 ANÁLISE DE SENSIBILIDADE - PREÇO JUSTO (R$)")
print("       g→    2.0%   2.5%   3.0%   3.5%   4.0%")
print("WACC↓")
for i, wacc in enumerate(wacc_range):
    linha = f"{wacc*100:.0f}%     "
    for j in range(len(crescimento_range)):
        linha += f"{sensibilidade[i,j]:6.2f} "
    print(linha)

📊 ANÁLISE DE SENSIBILIDADE - PREÇO JUSTO (R$)
       g→    2.0%   2.5%   3.0%   3.5%   4.0%
WACC↓
10%      38.50  42.30  47.20  53.80  63.50
11%      32.10  34.80  38.20  42.50  48.20
12%      27.30  29.30  31.80  34.90  38.90
13%      23.60  25.10  27.00  29.30  32.20
14%      20.70  21.80  23.30  25.00  27.10

❌ ERRADO: g = 5% (acima do PIB de longo prazo)
✅ CORRETO: g = 2-3% (linha com inflação + PIB real)

Regra: Crescimento perpétuo não deve exceder crescimento do PIB

⚠️ Se >70% do valor vem do Terminal Value, as projeções 
   de curto prazo importam pouco.
   
Solução: Aumente o período de projeção ou seja mais 
         conservador no TV.

# ❌ ERRADO: Usar FCF de um único ano
fcf = 2024_fcf  # Pode ser atípico

# ✅ CORRETO: Normalizar FCF
fcf_normalizado = np.mean([fcf_2022, fcf_2023, fcf_2024])

Componentes frequentemente esquecidos:
- Risco país (Brasil: 200-400 bps)
- Prêmio por iliquidez (small caps: 200-400 bps)
- Prêmio de tamanho

def dcf_rapido(ticker, token):
    """
    DCF simplificado usando dados da brapi.dev.
    """
    # Obter dados
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}?fundamental=true",
        headers={"Authorization": f"Bearer {token}"}
    )
    acao = response.json()["results"][0]
    
    # Parâmetros simplificados
    eps = acao.get("earningsPerShare", 0)
    crescimento = min(acao.get("earningsGrowth", 0.05), 0.15)  # Max 15%
    
    # Premissas conservadoras
    anos = 5
    wacc = 0.12
    g_perpetuo = 0.03
    
    # Projetar lucros como proxy de FCF
    fcf_atual = eps * 0.7  # 70% do lucro vira caixa
    
    # Valor presente dos FCFs
    vp_total = 0
    fcf = fcf_atual
    for ano in range(1, anos + 1):
        fcf = fcf * (1 + crescimento * (1 - ano/10))  # Desaceleração
        vp = fcf / ((1 + wacc) ** ano)
        vp_total += vp
    
    # Valor terminal
    tv = fcf * (1 + g_perpetuo) / (wacc - g_perpetuo)
    tv_vp = tv / ((1 + wacc) ** anos)
    
    # Preço justo
    preco_justo = vp_total + tv_vp
    preco_atual = acao["regularMarketPrice"]
    
    # Margem de segurança
    margem = (preco_justo - preco_atual) / preco_justo * 100
    
    return {
        "ticker": ticker,
        "preco_atual": preco_atual,
        "preco_justo": preco_justo,
        "margem_seguranca": margem,
        "recomendacao": "COMPRA" if margem > 25 else "NEUTRO" if margem > 0 else "EVITAR"
    }

# Exemplo
resultado = dcf_rapido("WEGE3", "SEU_TOKEN")
print(f"""
{resultado['ticker']}
Preço Atual: R$ {resultado['preco_atual']:.2f}
Preço Justo: R$ {resultado['preco_justo']:.2f}
Margem: {resultado['margem_seguranca']:.1f}%
Recomendação: {resultado['recomendacao']}
""")

┌─────────────────────────────────────────────────────────────┐
│                   CHECKLIST DCF                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  INPUTS                                                     │
│  ☐ FCF histórico (3-5 anos)                                 │
│  ☐ Taxa de crescimento realista                             │
│  ☐ WACC com todos os componentes                            │
│  ☐ Crescimento perpétuo ≤ PIB                               │
│                                                             │
│  VALIDAÇÃO                                                  │
│  ☐ TV < 70% do valor total                                  │
│  ☐ Análise de sensibilidade                                 │
│  ☐ Comparar com múltiplos                                   │
│  ☐ Sanity check vs preço de mercado                         │
│                                                             │
│  MARGEM DE SEGURANÇA                                        │
│  ☐ Aplicar desconto de 20-40%                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘