O Que É CDI em 2026: Guia Completo do Indicador Mais Importante da Renda Fixa

Banco A tem dinheiro sobrando hoje
         ↓
Empresta para Banco B que precisa
         ↓
Banco B paga juros (taxa CDI)
         ↓
Média de todas essas operações = Taxa CDI do dia

import requests

def consultar_selic_atual():
    """
    Consulta a taxa Selic atual via API brapi.dev
    CDI fica aproximadamente 0,10% abaixo da Selic
    """
    url = "https://brapi.dev/api/v2/prime-rate"
    
    response = requests.get(url)
    data = response.json()
    
    if 'prime-rate' in data:
        selic_info = data['prime-rate'][0]
        selic = float(selic_info['value'])
        cdi_estimado = selic - 0.10
        
        print("=" * 50)
        print("TAXA SELIC E CDI ATUAIS")
        print("=" * 50)
        print(f"Selic Meta: {selic:.2f}% ao ano")
        print(f"CDI Estimado: {cdi_estimado:.2f}% ao ano")
        print(f"CDI Mensal: {((1 + cdi_estimado/100)**(1/12) - 1) * 100:.4f}%")
        print(f"CDI Diário: {((1 + cdi_estimado/100)**(1/252) - 1) * 100:.6f}%")
        
        return {
            'selic': selic,
            'cdi': cdi_estimado,
            'cdi_mensal': ((1 + cdi_estimado/100)**(1/12) - 1) * 100,
            'cdi_diario': ((1 + cdi_estimado/100)**(1/252) - 1) * 100
        }
    
    return None

# Exemplo de uso
taxas = consultar_selic_atual()

def converter_taxas():
    """
    Relação entre Selic e CDI
    """
    # Selic Meta atual (exemplo)
    selic_meta = 13.25  # % ao ano
    
    # CDI fica muito próximo
    cdi = selic_meta - 0.10  # aproximadamente
    
    # Conversões úteis
    conversoes = {
        'selic_meta_anual': selic_meta,
        'cdi_anual': cdi,
        'cdi_mensal': ((1 + cdi/100)**(1/12) - 1) * 100,
        'cdi_diario': ((1 + cdi/100)**(1/252) - 1) * 100,
        '100_cdi_mensal': ((1 + cdi/100)**(1/12) - 1) * 100,
        '110_cdi_mensal': ((1 + cdi/100)**(1/12) - 1) * 100 * 1.10,
        '120_cdi_mensal': ((1 + cdi/100)**(1/12) - 1) * 100 * 1.20,
    }
    
    print("CONVERSÕES DE TAXAS")
    print("-" * 40)
    for nome, valor in conversoes.items():
        print(f"{nome}: {valor:.4f}%")
    
    return conversoes

converter_taxas()

def calculadora_cdi(
    valor_inicial: float,
    percentual_cdi: float,
    cdi_anual: float,
    prazo_meses: int,
    tipo_investimento: str = "CDB"
):
    """
    Calculadora de rendimento atrelado ao CDI
    
    Args:
        valor_inicial: Valor investido
        percentual_cdi: Ex: 100 para 100% do CDI, 110 para 110%
        cdi_anual: Taxa CDI anual em %
        prazo_meses: Prazo em meses
        tipo_investimento: CDB, LCI, LCA, Fundo DI
    """
    
    # Taxa efetiva do investimento
    taxa_anual = (cdi_anual * percentual_cdi) / 100
    taxa_mensal = ((1 + taxa_anual/100)**(1/12) - 1)
    
    # Rendimento bruto
    montante_bruto = valor_inicial * ((1 + taxa_mensal) ** prazo_meses)
    rendimento_bruto = montante_bruto - valor_inicial
    
    # Tabela regressiva do IR (CDB, fundos)
    if tipo_investimento in ["CDB", "Fundo DI"]:
        if prazo_meses <= 6:
            aliquota_ir = 0.225  # 22,5%
        elif prazo_meses <= 12:
            aliquota_ir = 0.20   # 20%
        elif prazo_meses <= 24:
            aliquota_ir = 0.175  # 17,5%
        else:
            aliquota_ir = 0.15   # 15%
        
        ir = rendimento_bruto * aliquota_ir
        rendimento_liquido = rendimento_bruto - ir
    else:
        # LCI, LCA são isentos de IR
        ir = 0
        rendimento_liquido = rendimento_bruto
        aliquota_ir = 0
    
    montante_liquido = valor_inicial + rendimento_liquido
    
    # Resultado
    resultado = {
        'valor_inicial': valor_inicial,
        'percentual_cdi': percentual_cdi,
        'taxa_anual_efetiva': taxa_anual,
        'prazo_meses': prazo_meses,
        'tipo': tipo_investimento,
        'montante_bruto': montante_bruto,
        'rendimento_bruto': rendimento_bruto,
        'aliquota_ir': aliquota_ir * 100,
        'imposto_renda': ir,
        'rendimento_liquido': rendimento_liquido,
        'montante_liquido': montante_liquido,
        'rentabilidade_liquida': (montante_liquido / valor_inicial - 1) * 100
    }
    
    print("=" * 60)
    print("SIMULAÇÃO DE INVESTIMENTO CDI")
    print("=" * 60)
    print(f"Valor Inicial: R$ {valor_inicial:,.2f}")
    print(f"Investimento: {tipo_investimento} a {percentual_cdi}% do CDI")
    print(f"CDI Anual: {cdi_anual}%")
    print(f"Taxa Efetiva: {taxa_anual:.2f}% ao ano")
    print(f"Prazo: {prazo_meses} meses")
    print("-" * 60)
    print(f"Montante Bruto: R$ {montante_bruto:,.2f}")
    print(f"Rendimento Bruto: R$ {rendimento_bruto:,.2f}")
    if ir > 0:
        print(f"IR ({aliquota_ir*100:.1f}%): R$ {ir:,.2f}")
    else:
        print(f"IR: Isento ({tipo_investimento})")
    print("-" * 60)
    print(f"RENDIMENTO LÍQUIDO: R$ {rendimento_liquido:,.2f}")
    print(f"MONTANTE LÍQUIDO: R$ {montante_liquido:,.2f}")
    print(f"RENTABILIDADE LÍQUIDA: {(montante_liquido/valor_inicial - 1)*100:.2f}%")
    
    return resultado

# Exemplos
print("\n--- CDB 100% CDI por 12 meses ---")
calculadora_cdi(10000, 100, 13.15, 12, "CDB")

print("\n--- CDB 120% CDI por 24 meses ---")
calculadora_cdi(10000, 120, 13.15, 24, "CDB")

print("\n--- LCI 90% CDI por 12 meses ---")
calculadora_cdi(10000, 90, 13.15, 12, "LCI")

def comparar_cdb_vs_lci():
    """
    Compara CDB tributado vs LCI isenta
    """
    valor = 10000
    cdi = 13.15
    prazo_meses = 12
    
    # CDB 100% CDI com IR de 20% (12 meses)
    taxa_cdb = cdi / 100
    rendimento_cdb_bruto = valor * ((1 + taxa_cdb)**(prazo_meses/12) - 1)
    ir_cdb = rendimento_cdb_bruto * 0.20
    rendimento_cdb_liquido = rendimento_cdb_bruto - ir_cdb
    
    # LCI 85% CDI isenta de IR
    taxa_lci = (cdi * 0.85) / 100
    rendimento_lci = valor * ((1 + taxa_lci)**(prazo_meses/12) - 1)
    
    # Encontrar LCI equivalente ao CDB
    percentual_equivalente = (rendimento_cdb_liquido / valor) / ((1 + cdi/100)**(prazo_meses/12) - 1) * 100
    
    print("COMPARAÇÃO CDB vs LCI")
    print("=" * 50)
    print(f"Valor: R$ {valor:,.2f} | Prazo: {prazo_meses} meses | CDI: {cdi}%")
    print("-" * 50)
    print(f"CDB 100% CDI:")
    print(f"  Rendimento Bruto: R$ {rendimento_cdb_bruto:,.2f}")
    print(f"  IR (20%): R$ {ir_cdb:,.2f}")
    print(f"  Rendimento Líquido: R$ {rendimento_cdb_liquido:,.2f}")
    print("-" * 50)
    print(f"LCI 85% CDI (isenta):")
    print(f"  Rendimento: R$ {rendimento_lci:,.2f}")
    print("-" * 50)
    
    if rendimento_lci > rendimento_cdb_liquido:
        print(f"MELHOR: LCI (ganho extra de R$ {rendimento_lci - rendimento_cdb_liquido:,.2f})")
    else:
        print(f"MELHOR: CDB (ganho extra de R$ {rendimento_cdb_liquido - rendimento_lci:,.2f})")
    
    print(f"\nLCI equivalente a CDB 100%: {percentual_equivalente:.1f}% do CDI")

comparar_cdb_vs_lci()

def comparar_tesouro_selic_vs_cdb():
    """
    Compara Tesouro Selic vs CDB
    """
    print("TESOURO SELIC vs CDB")
    print("=" * 60)
    
    comparativo = {
        'Característica': ['Rendimento', 'Tributação', 'Liquidez', 'Garantia', 'Investimento Mín.', 'Risco'],
        'Tesouro Selic': [
            'Selic + 0,0X%',
            'IR regressivo',
            'D+1',
            'Governo Federal',
            'R$ 30',
            'Soberano (menor)'
        ],
        'CDB 100% CDI': [
            '100% CDI',
            'IR regressivo',
            'Varia (diária ou venc.)',
            'FGC até R$ 250 mil',
            'Varia (R$ 1 a R$ 1.000)',
            'Crédito do banco'
        ]
    }
    
    import pandas as pd
    df = pd.DataFrame(comparativo)
    print(df.to_string(index=False))

comparar_tesouro_selic_vs_cdb()

def listar_cdbs_acima_100_cdi():
    """
    Exemplos de CDBs que pagam acima de 100% do CDI
    (valores ilustrativos - consulte as corretoras)
    """
    
    cdbs = [
        {"banco": "Banco Master", "rentabilidade": 130, "prazo": 36, "fgc": True},
        {"banco": "Banco Pine", "rentabilidade": 120, "prazo": 24, "fgc": True},
        {"banco": "Banco BMG", "rentabilidade": 115, "prazo": 24, "fgc": True},
        {"banco": "Banco Daycoval", "rentabilidade": 112, "prazo": 12, "fgc": True},
        {"banco": "Banco Inter", "rentabilidade": 100, "prazo": 12, "fgc": True},
        {"banco": "Nubank", "rentabilidade": 100, "prazo": 0, "fgc": True},
    ]
    
    cdi_atual = 13.15
    
    print("CDBs ACIMA DE 100% DO CDI")
    print("=" * 70)
    print(f"{'Banco':<20} {'% CDI':<10} {'Taxa Efetiva':<15} {'Prazo':<10} {'FGC'}")
    print("-" * 70)
    
    for cdb in cdbs:
        taxa_efetiva = cdi_atual * cdb['rentabilidade'] / 100
        prazo_str = f"{cdb['prazo']}m" if cdb['prazo'] > 0 else "Diária"
        fgc_str = "Sim" if cdb['fgc'] else "Não"
        print(f"{cdb['banco']:<20} {cdb['rentabilidade']}%{'':<6} {taxa_efetiva:.2f}%{'':<10} {prazo_str:<10} {fgc_str}")
    
    print("-" * 70)
    print("Importante: Verifique sempre se o banco é coberto pelo FGC!")
    print("Limite FGC: R$ 250.000 por CPF por instituição")

listar_cdbs_acima_100_cdi()

def calcular_lci_equivalente(percentual_cdb: float, prazo_meses: int) -> float:
    """
    Calcula qual % do CDI uma LCI precisa pagar para 
    equivaler a um CDB tributado
    
    Args:
        percentual_cdb: % do CDI do CDB (ex: 100)
        prazo_meses: prazo em meses
    
    Returns:
        Percentual do CDI equivalente para LCI isenta
    """
    # Alíquota de IR conforme prazo
    if prazo_meses <= 6:
        aliquota = 0.225
    elif prazo_meses <= 12:
        aliquota = 0.20
    elif prazo_meses <= 24:
        aliquota = 0.175
    else:
        aliquota = 0.15
    
    # LCI equivalente = CDB * (1 - alíquota IR)
    lci_equivalente = percentual_cdb * (1 - aliquota)
    
    return lci_equivalente

print("TABELA DE EQUIVALÊNCIA CDB vs LCI/LCA")
print("=" * 50)
print(f"{'Prazo':<12} {'CDB':<15} {'LCI Equivalente':<20}")
print("-" * 50)

for prazo in [6, 12, 18, 24, 36]:
    lci_eq = calcular_lci_equivalente(100, prazo)
    print(f"{prazo} meses{'':<5} 100% CDI{'':<8} {lci_eq:.1f}% CDI isento")

print("-" * 50)
print("Se a LCI pagar MAIS que o equivalente, ela é melhor!")

import requests

def historico_selic_cdi():
    """
    Consulta histórico da Selic (proxy para CDI) via brapi.dev
    """
    url = "https://brapi.dev/api/v2/prime-rate"
    
    response = requests.get(url)
    data = response.json()
    
    if 'prime-rate' in data:
        print("HISTÓRICO DA TAXA SELIC (CDI ≈ Selic - 0,10%)")
        print("=" * 60)
        print(f"{'Data':<15} {'Selic':<10} {'CDI Estimado':<15} {'CDI Mensal'}")
        print("-" * 60)
        
        for taxa in data['prime-rate'][:12]:  # Últimas 12 reuniões
            selic = float(taxa['value'])
            cdi = selic - 0.10
            cdi_mensal = ((1 + cdi/100)**(1/12) - 1) * 100
            
            print(f"{taxa['date'][:10]:<15} {selic:.2f}%{'':<5} {cdi:.2f}%{'':<10} {cdi_mensal:.4f}%")
        
        return data['prime-rate']
    
    return None

historico = historico_selic_cdi()

def calcular_rendimento_real(cdi_anual: float, ipca_anual: float):
    """
    Calcula o rendimento real (acima da inflação)
    """
    # Fórmula: (1 + nominal) / (1 + inflação) - 1
    rendimento_real = ((1 + cdi_anual/100) / (1 + ipca_anual/100) - 1) * 100
    
    print("RENDIMENTO REAL (CDI - INFLAÇÃO)")
    print("=" * 50)
    print(f"CDI: {cdi_anual:.2f}% ao ano")
    print(f"IPCA: {ipca_anual:.2f}% ao ano")
    print(f"Rendimento Real: {rendimento_real:.2f}% ao ano")
    
    if rendimento_real > 0:
        print(f"\nSeu dinheiro está GANHANDO poder de compra!")
    else:
        print(f"\nSeu dinheiro está PERDENDO poder de compra!")
    
    return rendimento_real

# Exemplo atual
calcular_rendimento_real(13.15, 4.5)

# Histórico problemático (2015)
print("\n--- Comparativo 2015 vs 2026 ---")
calcular_rendimento_real(13.24, 10.67)  # 2015

def calcular_patrimonio_para_renda(
    renda_mensal_desejada: float,
    cdi_anual: float,
    percentual_cdi: float = 100,
    tipo_investimento: str = "CDB"
):
    """
    Calcula quanto precisa ter investido para viver de renda CDI
    """
    # Taxa líquida anual
    taxa_bruta = cdi_anual * (percentual_cdi / 100)
    
    # Considera IR de 15% (longo prazo)
    if tipo_investimento in ["CDB", "Fundo DI"]:
        taxa_liquida = taxa_bruta * 0.85
    else:  # LCI, LCA
        taxa_liquida = taxa_bruta
    
    # Taxa mensal líquida
    taxa_mensal = ((1 + taxa_liquida/100)**(1/12) - 1)
    
    # Patrimônio necessário
    patrimonio = renda_mensal_desejada / taxa_mensal
    
    print("=" * 60)
    print("QUANTO INVESTIR PARA VIVER DE RENDA")
    print("=" * 60)
    print(f"Renda Mensal Desejada: R$ {renda_mensal_desejada:,.2f}")
    print(f"Investimento: {tipo_investimento} a {percentual_cdi}% do CDI")
    print(f"CDI Anual: {cdi_anual}%")
    print(f"Taxa Líquida Anual: {taxa_liquida:.2f}%")
    print(f"Taxa Líquida Mensal: {taxa_mensal*100:.4f}%")
    print("-" * 60)
    print(f"PATRIMÔNIO NECESSÁRIO: R$ {patrimonio:,.2f}")
    print("=" * 60)
    
    return patrimonio

# Simulações
print("\n--- Renda de R$ 5.000/mês ---")
calcular_patrimonio_para_renda(5000, 13.15, 100, "CDB")

print("\n--- Renda de R$ 10.000/mês ---")
calcular_patrimonio_para_renda(10000, 13.15, 110, "CDB")

print("\n--- Renda de R$ 10.000/mês com LCI ---")
calcular_patrimonio_para_renda(10000, 13.15, 90, "LCI")

def poupanca_vs_cdi(valor: float, meses: int, cdi_anual: float):
    """
    Compara poupança vs CDI
    """
    # Poupança: 70% Selic quando Selic > 8,5%
    taxa_poupanca_anual = cdi_anual * 0.70
    
    # CDB 100% CDI com IR
    taxa_cdb = cdi_anual
    
    # Rendimentos
    rend_poupanca = valor * ((1 + taxa_poupanca_anual/100)**(meses/12) - 1)
    rend_cdb_bruto = valor * ((1 + taxa_cdb/100)**(meses/12) - 1)
    
    # IR do CDB (considera 20% para 12 meses)
    if meses <= 6:
        ir = 0.225
    elif meses <= 12:
        ir = 0.20
    elif meses <= 24:
        ir = 0.175
    else:
        ir = 0.15
    
    rend_cdb_liquido = rend_cdb_bruto * (1 - ir)
    
    diferenca = rend_cdb_liquido - rend_poupanca
    
    print(f"POUPANÇA vs CDB ({meses} meses)")
    print("=" * 50)
    print(f"Valor: R$ {valor:,.2f} | CDI: {cdi_anual}%")
    print(f"Poupança (~70% CDI): R$ {rend_poupanca:,.2f}")
    print(f"CDB 100% CDI (líq.): R$ {rend_cdb_liquido:,.2f}")
    print(f"DIFERENÇA: R$ {diferenca:,.2f} a mais no CDB")
    print(f"Você perde {(diferenca/valor)*100:.2f}% na poupança!")

poupanca_vs_cdi(10000, 12, 13.15)
poupanca_vs_cdi(100000, 24, 13.15)

import requests

def monitorar_taxas_basicas():
    """
    Script para monitorar taxas básicas da economia brasileira
    usando a API brapi.dev
    """
    
    # Taxa Selic (CDI ≈ Selic - 0,10%)
    selic_url = "https://brapi.dev/api/v2/prime-rate"
    selic_response = requests.get(selic_url)
    selic_data = selic_response.json()
    
    # Inflação (IPCA)
    ipca_url = "https://brapi.dev/api/v2/inflation?country=brazil&historical=true"
    ipca_response = requests.get(ipca_url)
    ipca_data = ipca_response.json()
    
    if selic_data.get('prime-rate') and ipca_data.get('inflation'):
        selic = float(selic_data['prime-rate'][0]['value'])
        cdi = selic - 0.10
        
        # IPCA acumulado 12 meses
        ipca_valores = ipca_data['inflation'][:12]
        ipca_12m = sum(float(m['value']) for m in ipca_valores)
        
        # Rendimento real
        rendimento_real = ((1 + cdi/100) / (1 + ipca_12m/100) - 1) * 100
        
        print("=" * 60)
        print("MONITOR DE TAXAS - ECONOMIA BRASILEIRA")
        print("=" * 60)
        print(f"Selic Meta: {selic:.2f}% ao ano")
        print(f"CDI Estimado: {cdi:.2f}% ao ano")
        print(f"IPCA 12 meses: {ipca_12m:.2f}%")
        print(f"Rendimento Real: {rendimento_real:.2f}% ao ano")
        print("=" * 60)
        
        # Simulação rápida
        valor = 10000
        rend_12m = valor * (cdi/100)
        rend_real_12m = valor * (rendimento_real/100)
        
        print(f"\nSimulação R$ {valor:,.2f} por 12 meses:")
        print(f"  Rendimento Nominal (bruto): R$ {rend_12m:,.2f}")
        print(f"  Ganho Real (acima inflação): R$ {rend_real_12m:,.2f}")
        
        return {
            'selic': selic,
            'cdi': cdi,
            'ipca_12m': ipca_12m,
            'rendimento_real': rendimento_real
        }
    
    return None

# Executar monitoramento
dados = monitorar_taxas_basicas()