CDB vs Tesouro Direto em 2026: Qual É Melhor Para Você?

Você empresta dinheiro para o banco
          ↓
Banco usa para emprestar a clientes
          ↓
Você recebe juros no vencimento

Você empresta dinheiro para o governo
          ↓
Governo financia suas atividades
          ↓
Você recebe juros + principal

def comparar_seguranca():
    """
    Compara garantias de CDB vs Tesouro Direto
    """
    print("COMPARATIVO DE SEGURANÇA")
    print("=" * 70)
    
    comparativo = {
        'Quem garante': ['FGC (Fundo Garantidor)', 'Governo Federal'],
        'Limite garantia': ['R$ 250.000 por CPF/banco', 'Ilimitado'],
        'Risco de calote': ['Existe (banco quebrar)', 'Praticamente zero'],
        'Histórico': ['Alguns bancos já quebraram', 'Brasil nunca deu calote'],
        'Nível de risco': ['Baixo a Médio', 'Soberano (menor possível)']
    }
    
    print(f"{'Característica':<25} {'CDB':<25} {'Tesouro Direto'}")
    print("-" * 70)
    
    for carac, valores in comparativo.items():
        print(f"{carac:<25} {valores[0]:<25} {valores[1]}")
    
    print("-" * 70)
    print("\n🏆 VENCEDOR em Segurança: TESOURO DIRETO")
    print("   (Garantia do governo é considerada a mais segura do país)")

comparar_seguranca()

import requests

def comparar_rentabilidade(valor: float, prazo_meses: int):
    """
    Compara rentabilidade de CDB vs Tesouro Selic
    """
    # Consultar Selic atual
    url = "https://brapi.dev/api/v2/prime-rate"
    response = requests.get(url)
    data = response.json()
    
    if 'prime-rate' in data:
        selic = float(data['prime-rate'][0]['value'])
    else:
        selic = 13.25
    
    cdi = selic - 0.10
    
    # Cenários de CDB
    cdbs = [
        ("CDB 100% CDI (banco grande)", 100),
        ("CDB 110% CDI (banco médio)", 110),
        ("CDB 120% CDI (banco pequeno)", 120),
    ]
    
    # Tesouro Selic
    tesouro_taxa = selic + 0.05  # Tesouro Selic rende Selic + pequeno prêmio
    
    # Taxa de custódia Tesouro (0.20% ao ano sobre valor)
    taxa_custodia = 0.20
    
    # Alíquota IR
    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
    
    print("COMPARATIVO DE RENTABILIDADE")
    print("=" * 70)
    print(f"Valor: R$ {valor:,.2f} | Prazo: {prazo_meses} meses | Selic: {selic}% | CDI: {cdi:.2f}%")
    print("-" * 70)
    
    resultados = []
    
    # Calcular CDBs
    for nome, perc_cdi in cdbs:
        taxa = cdi * perc_cdi / 100
        taxa_mensal = ((1 + taxa/100)**(1/12) - 1)
        montante_bruto = valor * ((1 + taxa_mensal) ** prazo_meses)
        rendimento_bruto = montante_bruto - valor
        ir = rendimento_bruto * aliquota
        rendimento_liquido = rendimento_bruto - ir
        
        resultados.append((nome, rendimento_liquido))
    
    # Calcular Tesouro Selic
    taxa_tesouro = tesouro_taxa - taxa_custodia  # Líquido de custódia
    taxa_mensal_tesouro = ((1 + taxa_tesouro/100)**(1/12) - 1)
    montante_tesouro_bruto = valor * ((1 + taxa_mensal_tesouro) ** prazo_meses)
    rend_tesouro_bruto = montante_tesouro_bruto - valor
    ir_tesouro = rend_tesouro_bruto * aliquota
    rend_tesouro_liquido = rend_tesouro_bruto - ir_tesouro
    
    resultados.append(("Tesouro Selic", rend_tesouro_liquido))
    
    # Ordenar por rendimento
    resultados.sort(key=lambda x: x[1], reverse=True)
    
    print(f"{'Investimento':<35} {'Rendimento Líquido':<20} {'Rent. %'}")
    print("-" * 70)
    
    for i, (nome, rend) in enumerate(resultados):
        rent_perc = (rend / valor) * 100
        destaque = "👑" if i == 0 else ""
        print(f"{nome:<35} R$ {rend:>12,.2f}{'':<5} {rent_perc:.2f}% {destaque}")
    
    print("-" * 70)
    print(f"IR aplicado: {aliquota*100:.1f}%")

# Comparar em diferentes prazos
print("\n--- 6 meses ---")
comparar_rentabilidade(10000, 6)

print("\n--- 12 meses ---")
comparar_rentabilidade(10000, 12)

print("\n--- 24 meses ---")
comparar_rentabilidade(10000, 24)

def comparar_liquidez():
    """
    Compara opções de liquidez
    """
    print("COMPARATIVO DE LIQUIDEZ")
    print("=" * 70)
    
    opcoes = [
        {
            'nome': 'CDB Liquidez Diária',
            'resgate': 'A qualquer momento',
            'prazo_receber': 'D+0',
            'penalidade': 'Nenhuma',
            'rentabilidade': 'Geralmente 100% CDI ou menos'
        },
        {
            'nome': 'CDB com Vencimento',
            'resgate': 'Só no vencimento',
            'prazo_receber': 'No vencimento',
            'penalidade': 'Não pode resgatar',
            'rentabilidade': '100% a 140% CDI'
        },
        {
            'nome': 'Tesouro Selic',
            'resgate': 'A qualquer momento',
            'prazo_receber': 'D+1',
            'penalidade': 'Mínima (marcação mercado)',
            'rentabilidade': 'Selic'
        },
        {
            'nome': 'Tesouro IPCA+',
            'resgate': 'A qualquer momento',
            'prazo_receber': 'D+1',
            'penalidade': 'Pode ter prejuízo!',
            'rentabilidade': 'IPCA + taxa (se levar até vencimento)'
        }
    ]
    
    for op in opcoes:
        print(f"\n📌 {op['nome']}")
        print(f"   Resgate: {op['resgate']}")
        print(f"   Prazo receber: {op['prazo_receber']}")
        print(f"   Penalidade: {op['penalidade']}")
        print(f"   Rentabilidade: {op['rentabilidade']}")

comparar_liquidez()

def calcular_custos(valor: float, prazo_meses: int, tipo: str):
    """
    Calcula custos totais de cada investimento
    """
    selic = 13.25
    cdi = selic - 0.10
    
    # Alíquota IR
    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
    
    if tipo == "CDB":
        taxa = cdi
        custos_extras = 0
        taxa_mensal = ((1 + taxa/100)**(1/12) - 1)
        montante = valor * ((1 + taxa_mensal) ** prazo_meses)
        rendimento = montante - valor
        ir = rendimento * aliquota
        custos = ir
        
    else:  # Tesouro Selic
        taxa = selic
        taxa_custodia_anual = 0.20 / 100
        taxa_custodia_periodo = (taxa_custodia_anual * prazo_meses / 12) * valor
        
        taxa_mensal = ((1 + taxa/100)**(1/12) - 1)
        montante = valor * ((1 + taxa_mensal) ** prazo_meses)
        rendimento = montante - valor
        ir = rendimento * aliquota
        custos = ir + taxa_custodia_periodo
    
    rendimento_liquido = rendimento - custos
    
    print(f"\n{tipo}")
    print("-" * 40)
    print(f"Rendimento Bruto: R$ {rendimento:,.2f}")
    print(f"IR ({aliquota*100:.1f}%): R$ {ir:,.2f}")
    if tipo == "Tesouro Selic":
        print(f"Taxa Custódia: R$ {taxa_custodia_periodo:,.2f}")
    print(f"Custos Totais: R$ {custos:,.2f}")
    print(f"Rendimento Líquido: R$ {rendimento_liquido:,.2f}")
    
    return rendimento_liquido

print("ANÁLISE DE CUSTOS")
print("=" * 50)
print("Valor: R$ 10.000 | Prazo: 12 meses")

rend_cdb = calcular_custos(10000, 12, "CDB")
rend_tesouro = calcular_custos(10000, 12, "Tesouro Selic")

print("\n" + "=" * 50)
if rend_cdb > rend_tesouro:
    print(f"CDB rende R$ {rend_cdb - rend_tesouro:.2f} a mais")
else:
    print(f"Tesouro Selic rende R$ {rend_tesouro - rend_cdb:.2f} a mais")

def ranking_cdbs():
    """
    Exemplo de ranking de CDBs disponíveis
    (valores ilustrativos - consulte sua corretora)
    """
    cdbs = [
        {"banco": "Banco Master", "tipo": "Vencimento", "rentab": 130, "prazo": 36, "minimo": 1000},
        {"banco": "Banco Pine", "tipo": "Vencimento", "rentab": 120, "prazo": 24, "minimo": 1000},
        {"banco": "Banco Daycoval", "tipo": "Vencimento", "rentab": 115, "prazo": 12, "minimo": 5000},
        {"banco": "Banco Inter", "tipo": "Liq. Diária", "rentab": 100, "prazo": 0, "minimo": 1},
        {"banco": "Nubank", "tipo": "Liq. Diária", "rentab": 100, "prazo": 0, "minimo": 1},
        {"banco": "C6 Bank", "tipo": "Vencimento", "rentab": 110, "prazo": 12, "minimo": 1000},
    ]
    
    print("RANKING DE CDBs (valores ilustrativos)")
    print("=" * 80)
    print(f"{'Banco':<18} {'Tipo':<15} {'% CDI':<10} {'Prazo':<10} {'Mínimo':<12} {'FGC'}")
    print("-" * 80)
    
    for cdb in sorted(cdbs, key=lambda x: x['rentab'], reverse=True):
        prazo_str = f"{cdb['prazo']}m" if cdb['prazo'] > 0 else "Diária"
        print(f"{cdb['banco']:<18} {cdb['tipo']:<15} {cdb['rentab']}%{'':<6} {prazo_str:<10} R$ {cdb['minimo']:<9} ✅")
    
    print("-" * 80)
    print("⚠️ Sempre verifique se o banco é coberto pelo FGC")

ranking_cdbs()

def guia_tesouro():
    """
    Guia de escolha do Tesouro Direto
    """
    titulos = {
        'Tesouro Selic': {
            'rentab': 'Selic (~13% ao ano)',
            'ideal_para': 'Reserva de emergência, curto prazo',
            'risco': 'Mínimo',
            'prazo': 'Qualquer (liquidez D+1)',
            'volatilidade': 'Quase nenhuma'
        },
        'Tesouro IPCA+': {
            'rentab': 'IPCA + 6-7% ao ano',
            'ideal_para': 'Aposentadoria, objetivos de longo prazo',
            'risco': 'Baixo se levar até vencimento',
            'prazo': '5 a 30+ anos',
            'volatilidade': 'Alta se vender antes'
        },
        'Tesouro Prefixado': {
            'rentab': '12-14% ao ano fixo',
            'ideal_para': 'Quando acredita que juros vão cair',
            'risco': 'Médio (marcação a mercado)',
            'prazo': '2 a 10 anos',
            'volatilidade': 'Média a alta'
        },
        'Tesouro Renda+': {
            'rentab': 'IPCA + taxa (pagamentos mensais)',
            'ideal_para': 'Complementar aposentadoria',
            'risco': 'Baixo se levar até vencimento',
            'prazo': 'Definido por idade',
            'volatilidade': 'Alta se vender antes'
        }
    }
    
    print("GUIA DO TESOURO DIRETO")
    print("=" * 70)
    
    for titulo, info in titulos.items():
        print(f"\n📌 {titulo}")
        print(f"   Rentabilidade: {info['rentab']}")
        print(f"   Ideal para: {info['ideal_para']}")
        print(f"   Risco: {info['risco']}")
        print(f"   Prazo: {info['prazo']}")
        print(f"   Volatilidade: {info['volatilidade']}")

guia_tesouro()

import requests

def simulador_completo(valor: float, prazo_meses: int, objetivo: str):
    """
    Simulador que recomenda melhor opção
    
    Args:
        valor: Valor a investir
        prazo_meses: Prazo em meses
        objetivo: 'reserva', 'curto', 'medio', 'longo'
    """
    # Consultar taxas atuais
    url = "https://brapi.dev/api/v2/prime-rate"
    response = requests.get(url)
    data = response.json()
    
    if 'prime-rate' in data:
        selic = float(data['prime-rate'][0]['value'])
    else:
        selic = 13.25
    
    cdi = selic - 0.10
    
    # Consultar inflação
    url_ipca = "https://brapi.dev/api/v2/inflation?country=brazil"
    response_ipca = requests.get(url_ipca)
    data_ipca = response_ipca.json()
    
    if 'inflation' in data_ipca:
        ipca_12m = sum(float(m['value']) for m in data_ipca['inflation'][:12])
    else:
        ipca_12m = 4.5
    
    print("=" * 70)
    print("SIMULADOR: CDB vs TESOURO DIRETO")
    print("=" * 70)
    print(f"Valor: R$ {valor:,.2f}")
    print(f"Prazo: {prazo_meses} meses")
    print(f"Objetivo: {objetivo}")
    print(f"Selic: {selic}% | CDI: {cdi:.2f}% | IPCA 12m: {ipca_12m:.2f}%")
    print("-" * 70)
    
    # Alíquota IR
    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
    
    opcoes = []
    
    # CDB Liquidez Diária
    taxa_cdb_liq = cdi
    rend_cdb_liq = calcular_rendimento(valor, taxa_cdb_liq, prazo_meses, aliquota, 0)
    opcoes.append(("CDB Liq. Diária (100% CDI)", rend_cdb_liq, "Alta", "FGC"))
    
    # CDB 110% CDI
    taxa_cdb_110 = cdi * 1.10
    rend_cdb_110 = calcular_rendimento(valor, taxa_cdb_110, prazo_meses, aliquota, 0)
    opcoes.append(("CDB 110% CDI", rend_cdb_110, "Baixa", "FGC"))
    
    # Tesouro Selic
    taxa_tesouro = selic
    custodia = 0.20 * (prazo_meses / 12) * valor / 100
    rend_tesouro = calcular_rendimento(valor, taxa_tesouro, prazo_meses, aliquota, custodia)
    opcoes.append(("Tesouro Selic", rend_tesouro, "Alta (D+1)", "Governo"))
    
    # Tesouro IPCA+ (simplificado)
    if prazo_meses >= 24:
        taxa_ipca = ipca_12m + 6  # IPCA + 6%
        rend_ipca = calcular_rendimento(valor, taxa_ipca, prazo_meses, aliquota, custodia)
        opcoes.append(("Tesouro IPCA+", rend_ipca, "Baixa", "Governo"))
    
    # Ordenar
    opcoes.sort(key=lambda x: x[1], reverse=True)
    
    print(f"\n{'Opção':<30} {'Rend. Líquido':<18} {'Liquidez':<15} {'Garantia'}")
    print("-" * 70)
    
    for i, (nome, rend, liq, gar) in enumerate(opcoes):
        destaque = "👑 MELHOR" if i == 0 else ""
        print(f"{nome:<30} R$ {rend:>12,.2f}    {liq:<15} {gar:<10} {destaque}")
    
    # Recomendação baseada no objetivo
    print("\n" + "=" * 70)
    print("📌 RECOMENDAÇÃO PERSONALIZADA:")
    
    if objetivo == 'reserva':
        print("   Para RESERVA DE EMERGÊNCIA:")
        print("   → Tesouro Selic (máxima segurança, liquidez D+1)")
        print("   → OU CDB Liquidez Diária (se FGC for suficiente)")
    elif objetivo == 'curto':
        print("   Para CURTO PRAZO (até 2 anos):")
        print("   → CDB 110%+ CDI se puder esperar vencimento")
        print("   → Tesouro Selic se precisar de flexibilidade")
    elif objetivo == 'longo':
        print("   Para LONGO PRAZO (5+ anos):")
        print("   → Tesouro IPCA+ (proteção inflação)")
        print("   → CDBs IPCA+ de bancos sólidos")

def calcular_rendimento(valor, taxa_anual, prazo_meses, aliquota_ir, custos):
    taxa_mensal = ((1 + taxa_anual/100)**(1/12) - 1)
    montante = valor * ((1 + taxa_mensal) ** prazo_meses)
    rendimento = montante - valor
    ir = rendimento * aliquota_ir
    return rendimento - ir - custos

# Simulações
print("\n--- Reserva de Emergência ---")
simulador_completo(10000, 12, 'reserva')

print("\n--- Objetivo de Curto Prazo ---")
simulador_completo(50000, 18, 'curto')

print("\n--- Aposentadoria (longo prazo) ---")
simulador_completo(100000, 60, 'longo')

def estrategia_combinada(valor_total: float):
    """
    Sugere estratégia combinando CDB e Tesouro
    """
    print("ESTRATÉGIA COMBINADA: CDB + TESOURO")
    print("=" * 70)
    print(f"Valor Total: R$ {valor_total:,.2f}")
    print("-" * 70)
    
    # Alocação sugerida
    alocacao = [
        ("Tesouro Selic (reserva emergência)", 0.20, "Liquidez D+1, máxima segurança"),
        ("CDB Liquidez Diária", 0.15, "Rendimento + liquidez imediata"),
        ("CDB 110-120% CDI (12-24m)", 0.25, "Melhor rentabilidade curto/médio prazo"),
        ("Tesouro IPCA+ (2035+)", 0.40, "Proteção inflação, aposentadoria"),
    ]
    
    print(f"\n{'Investimento':<40} {'%':<8} {'Valor':<15} {'Objetivo'}")
    print("-" * 70)
    
    for nome, perc, objetivo in alocacao:
        valor = valor_total * perc
        print(f"{nome:<40} {perc*100:.0f}%{'':<4} R$ {valor:>12,.2f}")
    
    print("-" * 70)
    print(f"{'TOTAL':<40} {'100%':<8} R$ {valor_total:>12,.2f}")
    
    print("\n📌 BENEFÍCIOS DESTA ESTRATÉGIA:")
    print("   ✓ Liquidez para emergências (35%)")
    print("   ✓ Rentabilidade acima do CDI (CDBs)")
    print("   ✓ Proteção contra inflação (IPCA+)")
    print("   ✓ Diversificação de riscos")
    print("   ✓ Cobertura FGC + Garantia Governo")

estrategia_combinada(100000)

🎯 REGRA PRÁTICA:

1. RESERVA DE EMERGÊNCIA → Tesouro Selic
   (Máxima segurança, liquidez D+1)

2. CURTO/MÉDIO PRAZO → CDB >105% CDI
   (Melhor rentabilidade se puder esperar)

3. LONGO PRAZO → Tesouro IPCA+
   (Proteção contra inflação garantida)

4. VALORES GRANDES (>R$ 250k) → Tesouro
   (Garantia ilimitada do governo)