Como Calcular Rendimento de Investimentos em 2026: Guia Completo com Calculadora

Investidor que não calcula:
"Meu CDB rendeu 12%! Estou rico!"

Investidor que calcula:
"12% nominal - 5% inflação - 2,7% IR = 4,3% real líquido"

Fórmula: M = C × (1 + i × t)

Onde:
M = Montante final
C = Capital inicial
i = Taxa de juros (decimal)
t = Tempo

M = 10.000 × (1 + 0,10 × 3)
M = 10.000 × 1,30
M = R$ 13.000

Rendimento: R$ 3.000

Fórmula: M = C × (1 + i)^t

Onde:
M = Montante final
C = Capital inicial
i = Taxa de juros (decimal)
t = Tempo (períodos)

M = 10.000 × (1 + 0,10)^3
M = 10.000 × 1,331
M = R$ 13.310

Rendimento: R$ 3.310

Rentabilidade (%) = ((Valor Final - Valor Inicial) / Valor Inicial) × 100

VF = PMT × [((1 + i)^n - 1) / i]

Onde:
VF = Valor Futuro
PMT = Aporte mensal
i = Taxa mensal
n = Número de meses

VF = 500 × [((1,01)^12 - 1) / 0,01]
VF = 500 × [0,1268 / 0,01]
VF = 500 × 12,68
VF = R$ 6.340

Total aportado: R$ 6.000
Rendimento: R$ 340

Rentabilidade Real = ((1 + Rentabilidade Nominal) / (1 + Inflação)) - 1

Real = ((1 + 0,12) / (1 + 0,05)) - 1
Real = (1,12 / 1,05) - 1
Real = 1,0667 - 1
Real = 6,67%

Seu ganho de poder de compra foi 6,67%, não 12%!

❌ ERRADO: Real = Nominal - Inflação
   12% - 5% = 7%

✅ CORRETO: Real = ((1 + Nominal) / (1 + Inflação)) - 1
   ((1,12) / (1,05)) - 1 = 6,67%

Rendimento Líquido = Rendimento Bruto × (1 - Alíquota IR)

IR = 15% (acima de 720 dias)
IR a pagar = R$ 1.200 × 0,15 = R$ 180
Rendimento Líquido = R$ 1.200 - R$ 180 = R$ 1.020

def calcular_rentabilidade_liquida_real(
    rentabilidade_bruta: float,  # Ex: 0.12 para 12%
    aliquota_ir: float,          # Ex: 0.15 para 15%
    inflacao: float              # Ex: 0.05 para 5%
) -> float:
    """
    Calcula rentabilidade líquida real
    """
    # Passo 1: Desconta IR
    rentabilidade_liquida = rentabilidade_bruta * (1 - aliquota_ir)
    
    # Passo 2: Desconta inflação
    rentabilidade_real = ((1 + rentabilidade_liquida) / (1 + inflacao)) - 1
    
    return rentabilidade_real

# Exemplo: CDB 12% a.a., IR 15%, inflação 5%
resultado = calcular_rentabilidade_liquida_real(0.12, 0.15, 0.05)
print(f"Rentabilidade líquida real: {resultado:.2%}")
# Saída: Rentabilidade líquida real: 2.86%

Taxa Mensal = (1 + Taxa Anual)^(1/12) - 1

Mensal = (1 + 0,12)^(1/12) - 1
Mensal = 1,12^0,0833 - 1
Mensal = 1,00949 - 1
Mensal = 0,949% ao mês

Taxa Anual = (1 + Taxa Mensal)^12 - 1

Anual = (1 + 0,01)^12 - 1
Anual = 1,01^12 - 1
Anual = 1,1268 - 1
Anual = 12,68% ao ano

❌ ERRADO: 1% ao mês = 12% ao ano (multiplicar por 12)
✅ CORRETO: 1% ao mês = 12,68% ao ano (juros compostos)

import requests
from dataclasses import dataclass
from typing import Optional

@dataclass
class ResultadoCalculo:
    montante_bruto: float
    rendimento_bruto: float
    rentabilidade_bruta: float
    imposto_renda: float
    montante_liquido: float
    rendimento_liquido: float
    rentabilidade_liquida: float
    rentabilidade_real: float
    inflacao_periodo: float

def obter_taxa_selic() -> float:
    """
    Obtém a taxa Selic atual via brapi.dev
    """
    try:
        response = requests.get("https://brapi.dev/api/v2/prime-rate")
        data = response.json()
        return data['prime-rate'][0]['value'] / 100  # Converte para decimal
    except:
        return 0.1375  # Fallback: 13,75%

def obter_inflacao() -> float:
    """
    Obtém a inflação (IPCA) acumulada via brapi.dev
    """
    try:
        response = requests.get("https://brapi.dev/api/v2/inflation")
        data = response.json()
        # Soma os últimos 12 meses para IPCA anualizado
        ipca_12m = sum([item['value'] for item in data['inflation'][:12]])
        return ipca_12m / 100
    except:
        return 0.05  # Fallback: 5%

def calcular_aliquota_ir(dias: int) -> float:
    """
    Retorna a alíquota de IR baseada no prazo
    """
    if dias <= 180:
        return 0.225
    elif dias <= 360:
        return 0.20
    elif dias <= 720:
        return 0.175
    else:
        return 0.15

def calcular_rendimento_completo(
    capital_inicial: float,
    taxa_anual: float,
    anos: int,
    aporte_mensal: float = 0,
    isento_ir: bool = False,
    inflacao: Optional[float] = None
) -> ResultadoCalculo:
    """
    Calcula rendimento completo de um investimento
    
    Parâmetros:
    - capital_inicial: Valor inicial investido
    - taxa_anual: Taxa de juros anual (decimal, ex: 0.12 para 12%)
    - anos: Período em anos
    - aporte_mensal: Valor aportado mensalmente
    - isento_ir: Se True, não desconta IR (LCI, LCA, etc.)
    - inflacao: Taxa de inflação (se None, busca automático)
    """
    # Busca inflação se não informada
    if inflacao is None:
        inflacao = obter_inflacao()
    
    # Converte taxa anual para mensal
    meses = anos * 12
    taxa_mensal = (1 + taxa_anual) ** (1/12) - 1
    
    # Calcula montante com juros compostos + aportes
    montante = capital_inicial * ((1 + taxa_mensal) ** meses)
    
    if aporte_mensal > 0:
        # Valor futuro de anuidade
        montante += aporte_mensal * (((1 + taxa_mensal) ** meses - 1) / taxa_mensal)
    
    # Total investido
    total_investido = capital_inicial + (aporte_mensal * meses)
    
    # Rendimento bruto
    rendimento_bruto = montante - total_investido
    rentabilidade_bruta = rendimento_bruto / total_investido
    
    # Calcula IR
    dias = anos * 365
    aliquota_ir = 0 if isento_ir else calcular_aliquota_ir(dias)
    imposto = rendimento_bruto * aliquota_ir
    
    # Rendimento líquido
    rendimento_liquido = rendimento_bruto - imposto
    montante_liquido = total_investido + rendimento_liquido
    rentabilidade_liquida = rendimento_liquido / total_investido
    
    # Inflação no período (composta)
    inflacao_periodo = (1 + inflacao) ** anos - 1
    
    # Rentabilidade real (após inflação)
    rentabilidade_real = ((1 + rentabilidade_liquida) / (1 + inflacao_periodo)) - 1
    
    return ResultadoCalculo(
        montante_bruto=round(montante, 2),
        rendimento_bruto=round(rendimento_bruto, 2),
        rentabilidade_bruta=round(rentabilidade_bruta * 100, 2),
        imposto_renda=round(imposto, 2),
        montante_liquido=round(montante_liquido, 2),
        rendimento_liquido=round(rendimento_liquido, 2),
        rentabilidade_liquida=round(rentabilidade_liquida * 100, 2),
        rentabilidade_real=round(rentabilidade_real * 100, 2),
        inflacao_periodo=round(inflacao_periodo * 100, 2)
    )

# ===== EXEMPLOS DE USO =====

# Exemplo 1: CDB 100% CDI por 2 anos
print("=" * 50)
print("EXEMPLO 1: CDB 100% CDI")
print("=" * 50)

selic = obter_taxa_selic()
resultado = calcular_rendimento_completo(
    capital_inicial=10000,
    taxa_anual=selic,
    anos=2,
    aporte_mensal=500
)

print(f"Taxa Selic atual: {selic:.2%}")
print(f"Capital inicial: R$ 10.000")
print(f"Aporte mensal: R$ 500")
print(f"Período: 2 anos")
print(f"\nResultados:")
print(f"  Montante bruto: R$ {resultado.montante_bruto:,.2f}")
print(f"  Rendimento bruto: R$ {resultado.rendimento_bruto:,.2f}")
print(f"  Rentabilidade bruta: {resultado.rentabilidade_bruta}%")
print(f"  Imposto de Renda: R$ {resultado.imposto_renda:,.2f}")
print(f"  Montante líquido: R$ {resultado.montante_liquido:,.2f}")
print(f"  Rendimento líquido: R$ {resultado.rendimento_liquido:,.2f}")
print(f"  Rentabilidade líquida: {resultado.rentabilidade_liquida}%")
print(f"  Inflação no período: {resultado.inflacao_periodo}%")
print(f"  Rentabilidade REAL: {resultado.rentabilidade_real}%")

# Exemplo 2: LCI (isenta de IR)
print("\n" + "=" * 50)
print("EXEMPLO 2: LCI 90% CDI (isenta de IR)")
print("=" * 50)

resultado_lci = calcular_rendimento_completo(
    capital_inicial=10000,
    taxa_anual=selic * 0.90,  # 90% do CDI
    anos=2,
    aporte_mensal=0,
    isento_ir=True
)

print(f"Montante líquido LCI: R$ {resultado_lci.montante_liquido:,.2f}")
print(f"Rentabilidade real: {resultado_lci.rentabilidade_real}%")

Rentabilidade Total = Valorização + Dividend Yield

Valorização = (Preço Final - Preço Inicial) / Preço Inicial
Dividend Yield = Dividendos Recebidos / Preço Inicial

import requests

def calcular_retorno_acao(ticker: str, token: str) -> dict:
    """
    Calcula métricas de retorno de uma ação
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "token": token,
        "range": "1y",
        "interval": "1d",
        "modules": "dividendsData,defaultKeyStatistics"
    }
    
    response = requests.get(url, params=params)
    data = response.json()['results'][0]
    
    # Preços
    preco_atual = data['regularMarketPrice']
    historico = data.get('historicalDataPrice', [])
    
    if historico:
        preco_inicial = historico[0]['close']
    else:
        preco_inicial = preco_atual
    
    # Cálculos
    valorizacao = (preco_atual - preco_inicial) / preco_inicial
    
    # Dividendos (últimos 12 meses)
    dividendos = data.get('dividendsData', {})
    dy = dividendos.get('yield', 0) or 0
    
    retorno_total = valorizacao + dy
    
    return {
        "ticker": ticker,
        "preco_inicial": round(preco_inicial, 2),
        "preco_atual": round(preco_atual, 2),
        "valorizacao": round(valorizacao * 100, 2),
        "dividend_yield": round(dy * 100, 2),
        "retorno_total": round(retorno_total * 100, 2)
    }

# Exemplo
token = "SEU_TOKEN_AQUI"
resultado = calcular_retorno_acao("PETR4", token)

print(f"Ação: {resultado['ticker']}")
print(f"Preço há 1 ano: R$ {resultado['preco_inicial']}")
print(f"Preço atual: R$ {resultado['preco_atual']}")
print(f"Valorização: {resultado['valorizacao']}%")
print(f"Dividend Yield: {resultado['dividend_yield']}%")
print(f"Retorno Total: {resultado['retorno_total']}%")

import requests
from dataclasses import dataclass
from typing import List

@dataclass
class Investimento:
    nome: str
    taxa_anual: float
    isento_ir: bool = False
    risco: str = "baixo"

def comparar_investimentos(
    capital: float,
    anos: int,
    investimentos: List[Investimento],
    inflacao: float = 0.05
) -> None:
    """
    Compara múltiplos investimentos
    """
    print(f"\n{'='*70}")
    print(f"COMPARATIVO DE INVESTIMENTOS")
    print(f"Capital: R$ {capital:,.2f} | Período: {anos} anos | Inflação: {inflacao:.1%}")
    print(f"{'='*70}")
    print(f"{'Investimento':<20} {'Taxa':<8} {'Bruto':<12} {'Líquido':<12} {'Real':<8} {'Risco':<8}")
    print(f"{'-'*70}")
    
    resultados = []
    
    for inv in investimentos:
        resultado = calcular_rendimento_completo(
            capital_inicial=capital,
            taxa_anual=inv.taxa_anual,
            anos=anos,
            isento_ir=inv.isento_ir,
            inflacao=inflacao
        )
        
        print(f"{inv.nome:<20} {inv.taxa_anual*100:<7.1f}% "
              f"R$ {resultado.montante_bruto:<10,.0f} "
              f"R$ {resultado.montante_liquido:<10,.0f} "
              f"{resultado.rentabilidade_real:<7.1f}% "
              f"{inv.risco:<8}")
        
        resultados.append((inv.nome, resultado))
    
    # Identifica o melhor
    melhor = max(resultados, key=lambda x: x[1].rentabilidade_real)
    print(f"\n✅ Melhor opção (maior rentabilidade real): {melhor[0]}")
    print(f"   Ganho real de {melhor[1].rentabilidade_real}% em {anos} anos")

# Obtém taxa Selic atual
selic = obter_taxa_selic()

# Define investimentos para comparar
investimentos = [
    Investimento("Poupança", 0.065, isento_ir=True, risco="baixo"),
    Investimento("CDB 100% CDI", selic, isento_ir=False, risco="baixo"),
    Investimento("CDB 120% CDI", selic * 1.20, isento_ir=False, risco="médio"),
    Investimento("LCI 90% CDI", selic * 0.90, isento_ir=True, risco="baixo"),
    Investimento("Tesouro IPCA+6%", 0.11, isento_ir=False, risco="baixo"),
    Investimento("CRI/CRA IPCA+7%", 0.12, isento_ir=True, risco="médio"),
]

# Compara
comparar_investimentos(
    capital=50000,
    anos=3,
    investimentos=investimentos,
    inflacao=0.05
)

======================================================================
COMPARATIVO DE INVESTIMENTOS
Capital: R$ 50,000.00 | Período: 3 anos | Inflação: 5.0%
======================================================================
Investimento         Taxa     Bruto        Líquido      Real     Risco   
----------------------------------------------------------------------
Poupança             6.5%    R$ 60,397    R$ 60,397    4.9%     baixo   
CDB 100% CDI         13.5%   R$ 73,070    R$ 69,610    6.9%     baixo   
CDB 120% CDI         16.2%   R$ 78,540    R$ 73,259    8.3%     médio   
LCI 90% CDI          12.2%   R$ 70,501    R$ 70,501    8.7%     baixo   
Tesouro IPCA+6%      11.0%   R$ 68,468    R$ 65,698    4.6%     baixo   
CRI/CRA IPCA+7%      12.0%   R$ 70,246    R$ 70,246    8.6%     médio   

✅ Melhor opção (maior rentabilidade real): LCI 90% CDI
   Ganho real de 8.7% em 3 anos

VF = C × (1 + i)^n + PMT × [((1 + i)^n - 1) / i]

Onde:
VF = Valor Futuro
C = Capital inicial
i = Taxa mensal
n = Número de meses
PMT = Aporte mensal

PMT = VF × i / ((1 + i)^n - 1)

def quanto_investir_por_mes(objetivo: float, taxa_mensal: float, meses: int) -> float:
    """
    Calcula aporte mensal necessário para atingir objetivo
    """
    return objetivo * taxa_mensal / ((1 + taxa_mensal) ** meses - 1)

# Exemplo: R$ 1 milhão em 20 anos, 1% ao mês
aporte = quanto_investir_por_mes(1_000_000, 0.01, 240)
print(f"Aporte mensal necessário: R$ {aporte:,.2f}")
# Saída: Aporte mensal necessário: R$ 1.010,86

n = log(VF × i / PMT + 1) / log(1 + i)

import math

def tempo_para_objetivo(objetivo: float, aporte: float, taxa_mensal: float) -> int:
    """
    Calcula tempo em meses para atingir objetivo
    """
    n = math.log(objetivo * taxa_mensal / aporte + 1) / math.log(1 + taxa_mensal)
    return int(n)

# Exemplo: R$ 1 milhão aportando R$ 2.000/mês a 1% ao mês
meses = tempo_para_objetivo(1_000_000, 2000, 0.01)
anos = meses / 12
print(f"Tempo necessário: {meses} meses ({anos:.1f} anos)")
# Saída: Tempo necessário: 181 meses (15.1 anos)

"Meu investimento rendeu 10%!"
Mas a inflação foi 5%...
Rendimento real: 4,76% (não 5%)

❌ 1% ao mês × 12 = 12% ao ano
✅ (1,01)^12 - 1 = 12,68% ao ano

CDB 100% CDI parece igual a LCI 100% CDI
Mas CDB paga IR (15% a 22,5%)
LCI é isenta

CDB resgatado em 6 meses: IR de 22,5%
CDB resgatado em 2 anos: IR de 15%
Diferença de 7,5% no imposto!

❌ "FII X rendeu 15% em 2 anos, FII Y rendeu 10% em 1 ano"
   Comparação injusta!

✅ Anualize os rendimentos para comparar:
   FII X: (1,15)^(1/2) - 1 = 7,24% a.a.
   FII Y: 10% a.a.
   FII Y é melhor!

# Taxa Selic atual
GET https://brapi.dev/api/v2/prime-rate

# Inflação (IPCA)
GET https://brapi.dev/api/v2/inflation

# Cotação de ações com histórico
GET https://brapi.dev/api/quote/PETR4?range=1y&interval=1d

# Dados de dividendos
GET https://brapi.dev/api/quote/PETR4?modules=dividendsData

# Múltiplas ações
GET https://brapi.dev/api/quote/PETR4,VALE3,ITUB4

import requests

def calculadora_automatizada(ticker: str, capital: float, token: str):
    """
    Calcula rendimento automaticamente usando dados da brapi.dev
    """
    # Busca dados do ativo
    quote_url = f"https://brapi.dev/api/quote/{ticker}"
    params = {"token": token, "range": "1y", "modules": "dividendsData"}
    quote = requests.get(quote_url, params=params).json()['results'][0]
    
    # Busca inflação
    inflacao = requests.get("https://brapi.dev/api/v2/inflation").json()
    ipca_12m = sum([m['value'] for m in inflacao['inflation'][:12]]) / 100
    
    # Calcula rendimento
    preco_atual = quote['regularMarketPrice']
    historico = quote.get('historicalDataPrice', [])
    preco_1y = historico[0]['close'] if historico else preco_atual
    
    valorizacao = (preco_atual - preco_1y) / preco_1y
    dy = quote.get('dividendsData', {}).get('yield', 0) or 0
    retorno_total = valorizacao + dy
    retorno_real = ((1 + retorno_total) / (1 + ipca_12m)) - 1
    
    lucro = capital * retorno_total
    
    print(f"\n{'='*50}")
    print(f"ANÁLISE: {ticker}")
    print(f"{'='*50}")
    print(f"Capital investido: R$ {capital:,.2f}")
    print(f"Preço há 1 ano: R$ {preco_1y:.2f}")
    print(f"Preço atual: R$ {preco_atual:.2f}")
    print(f"Valorização: {valorizacao*100:.2f}%")
    print(f"Dividend Yield: {dy*100:.2f}%")
    print(f"Retorno Total (bruto): {retorno_total*100:.2f}%")
    print(f"Inflação (IPCA 12m): {ipca_12m*100:.2f}%")
    print(f"Retorno Real: {retorno_real*100:.2f}%")
    print(f"Lucro bruto: R$ {lucro:,.2f}")

# Uso
calculadora_automatizada("PETR4", 10000, "SEU_TOKEN")

✅ ANTES DE INVESTIR
□ Calculei a rentabilidade líquida (após IR)?
□ Calculei a rentabilidade real (após inflação)?
□ Comparei com alternativas equivalentes?
□ Considerei o prazo para menor IR?

✅ DURANTE O INVESTIMENTO
□ Acompanho rentabilidade mensal/anual?
□ Comparo com benchmark (CDI, IBOV)?
□ Registro todos os aportes e resgates?

✅ NO RESGATE
□ Calculei o IR devido?
□ Comparei rentabilidade com objetivo inicial?
□ Analisei se valeu a pena vs alternativas?