LCI e LCA em 2026: Guia Completo de Investimentos Isentos de IR

Você empresta para o banco
        ↓
Banco financia imóveis
        ↓
Você recebe juros (sem IR!)

Você empresta para o banco
        ↓
Banco financia agricultura/pecuária
        ↓
Você recebe juros (sem IR!)

def comparar_cdb_lci(valor: float, cdi_anual: float, prazo_meses: int):
    """
    Compara CDB (com IR) vs LCI (isento) com mesmo % do CDI
    
    Args:
        valor: Valor investido
        cdi_anual: Taxa CDI anual em %
        prazo_meses: Prazo em meses
    """
    # Taxa mensal
    taxa_mensal = ((1 + cdi_anual/100)**(1/12) - 1)
    
    # CDB 100% CDI
    montante_cdb_bruto = valor * ((1 + taxa_mensal) ** prazo_meses)
    rendimento_cdb_bruto = montante_cdb_bruto - valor
    
    # Alíquota 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
    
    ir_cdb = rendimento_cdb_bruto * aliquota
    rendimento_cdb_liquido = rendimento_cdb_bruto - ir_cdb
    
    # LCI 100% CDI (isento)
    montante_lci = valor * ((1 + taxa_mensal) ** prazo_meses)
    rendimento_lci = montante_lci - valor
    
    # Diferença
    vantagem_lci = rendimento_lci - rendimento_cdb_liquido
    
    print("COMPARAÇÃO: CDB 100% CDI vs LCI 100% CDI")
    print("=" * 60)
    print(f"Valor: R$ {valor:,.2f} | Prazo: {prazo_meses} meses | CDI: {cdi_anual}%")
    print("-" * 60)
    print(f"CDB 100% CDI:")
    print(f"  Rendimento Bruto: R$ {rendimento_cdb_bruto:,.2f}")
    print(f"  IR ({aliquota*100:.1f}%): R$ {ir_cdb:,.2f}")
    print(f"  Rendimento Líquido: R$ {rendimento_cdb_liquido:,.2f}")
    print("-" * 60)
    print(f"LCI 100% CDI:")
    print(f"  Rendimento: R$ {rendimento_lci:,.2f} (ISENTO)")
    print("-" * 60)
    print(f"VANTAGEM LCI: R$ {vantagem_lci:,.2f} ({(vantagem_lci/valor)*100:.2f}%)")
    
    return {
        'cdb_liquido': rendimento_cdb_liquido,
        'lci': rendimento_lci,
        'vantagem': vantagem_lci
    }

# Exemplos por prazo
print("\n--- 6 meses ---")
comparar_cdb_lci(10000, 13.15, 6)

print("\n--- 12 meses ---")
comparar_cdb_lci(10000, 13.15, 12)

print("\n--- 24 meses ---")
comparar_cdb_lci(10000, 13.15, 24)

import requests

def simular_lci_pos_fixado(valor: float, percentual_cdi: float, prazo_meses: int):
    """
    Simula investimento em LCI/LCA pós-fixado
    """
    # Consultar CDI 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'])
        cdi = selic - 0.10
    else:
        cdi = 13.15  # Valor padrão
    
    # Calcular rendimento
    taxa_efetiva = cdi * (percentual_cdi / 100)
    taxa_mensal = ((1 + taxa_efetiva/100)**(1/12) - 1)
    
    montante = valor * ((1 + taxa_mensal) ** prazo_meses)
    rendimento = montante - valor
    
    print("SIMULAÇÃO LCI/LCA PÓS-FIXADO")
    print("=" * 60)
    print(f"Valor Investido: R$ {valor:,.2f}")
    print(f"Rentabilidade: {percentual_cdi}% do CDI")
    print(f"CDI Atual: {cdi:.2f}% ao ano")
    print(f"Taxa Efetiva: {taxa_efetiva:.2f}% ao ano")
    print(f"Prazo: {prazo_meses} meses")
    print("-" * 60)
    print(f"Rendimento: R$ {rendimento:,.2f}")
    print(f"Montante Final: R$ {montante:,.2f}")
    print(f"Imposto de Renda: R$ 0,00 (ISENTO)")
    print("-" * 60)
    print(f"RENTABILIDADE TOTAL: {(rendimento/valor)*100:.2f}%")
    
    return montante

# Simulações
simular_lci_pos_fixado(50000, 90, 12)

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
    """
    # 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

def tabela_equivalencia():
    """
    Gera tabela de equivalência CDB vs LCI
    """
    print("TABELA DE EQUIVALÊNCIA: CDB (com IR) vs LCI (isento)")
    print("=" * 70)
    print(f"{'Prazo':<12} {'IR':<10} {'CDB 100%':<12} {'CDB 110%':<12} {'CDB 120%':<12}")
    print("-" * 70)
    
    prazos = [(6, "6 meses"), (12, "12 meses"), (18, "18 meses"), (24, "24 meses"), (36, "36 meses")]
    
    for meses, label in prazos:
        if meses <= 6:
            ir = "22,5%"
        elif meses <= 12:
            ir = "20%"
        elif meses <= 24:
            ir = "17,5%"
        else:
            ir = "15%"
        
        eq_100 = calcular_lci_equivalente(100, meses)
        eq_110 = calcular_lci_equivalente(110, meses)
        eq_120 = calcular_lci_equivalente(120, meses)
        
        print(f"{label:<12} {ir:<10} {eq_100:.1f}%{'':<7} {eq_110:.1f}%{'':<7} {eq_120:.1f}%")
    
    print("-" * 70)
    print("Se LCI pagar MAIS que o equivalente, ela é melhor!")
    print("Exemplo: LCI 85% CDI é melhor que CDB 100% CDI (prazo 12 meses)")

tabela_equivalencia()

REGRA SIMPLES:

LCI de 85% CDI ≈ CDB de 100% CDI (12 meses)
LCI de 93% CDI ≈ CDB de 110% CDI (12 meses)
LCI de 102% CDI ≈ CDB de 120% CDI (12 meses)

Quanto maior o prazo, menor a vantagem da LCI
(porque IR do CDB diminui para 15%)

def simular_protecao_fgc(investimentos: list):
    """
    Verifica cobertura do FGC para múltiplos investimentos
    
    Args:
        investimentos: Lista de dicts {'banco': str, 'valor': float}
    """
    print("ANÁLISE DE COBERTURA FGC")
    print("=" * 60)
    
    total_investido = 0
    total_protegido = 0
    total_descoberto = 0
    
    print(f"{'Banco':<20} {'Investido':<15} {'Protegido':<15} {'Descoberto'}")
    print("-" * 60)
    
    for inv in investimentos:
        banco = inv['banco']
        valor = inv['valor']
        
        protegido = min(valor, 250000)
        descoberto = max(0, valor - 250000)
        
        total_investido += valor
        total_protegido += protegido
        total_descoberto += descoberto
        
        status = "⚠️" if descoberto > 0 else "✅"
        
        print(f"{banco:<20} R$ {valor:<12,.2f} R$ {protegido:<12,.2f} R$ {descoberto:,.2f} {status}")
    
    print("-" * 60)
    print(f"{'TOTAL':<20} R$ {total_investido:<12,.2f} R$ {total_protegido:<12,.2f} R$ {total_descoberto:,.2f}")
    
    if total_descoberto > 0:
        print(f"\n⚠️ ATENÇÃO: R$ {total_descoberto:,.2f} sem proteção FGC!")
        print("   Considere diversificar entre mais bancos")
    else:
        print("\n✅ 100% do seu investimento está protegido pelo FGC")

# Exemplo
meus_investimentos = [
    {'banco': 'Banco A', 'valor': 200000},
    {'banco': 'Banco B', 'valor': 150000},
    {'banco': 'Banco C', 'valor': 300000},  # Excede limite!
]

simular_protecao_fgc(meus_investimentos)

1. ABRIR CONTA EM CORRETORA
   XP, Rico, BTG, Inter, etc.
           ↓
2. TRANSFERIR DINHEIRO
   TED ou PIX para a corretora
           ↓
3. BUSCAR LCI/LCA
   Área de Renda Fixa > Filtrar por LCI ou LCA
           ↓
4. ANALISAR OPÇÕES
   Comparar: rentabilidade, prazo, banco emissor
           ↓
5. INVESTIR
   Aplicar valor mínimo ou mais
           ↓
6. AGUARDAR VENCIMENTO
   Rendimento cai na conta automaticamente

def checklist_lci_lca():
    """
    Checklist para análise de LCI/LCA
    """
    checklist = {
        'Rentabilidade': [
            'Qual % do CDI ou taxa fixa?',
            'É competitivo vs outras opções?',
            'Compense a falta de liquidez?'
        ],
        'Prazo': [
            'Carência mínima (geralmente 90 dias)',
            'Data de vencimento',
            'Posso esperar até o fim?'
        ],
        'Emissor': [
            'Banco é conhecido?',
            'Qual rating de crédito?',
            'Está coberto pelo FGC?'
        ],
        'Liquidez': [
            'Tem liquidez diária? (raro)',
            'Posso vender antes no secundário?',
            'Qual a carência?'
        ],
        'Valor Mínimo': [
            'Qual o aporte mínimo?',
            'Cabe no meu orçamento?',
            'Respeita limite FGC?'
        ]
    }
    
    print("CHECKLIST: ANTES DE INVESTIR EM LCI/LCA")
    print("=" * 60)
    
    for categoria, itens in checklist.items():
        print(f"\n📋 {categoria.upper()}")
        for item in itens:
            print(f"   ☐ {item}")

checklist_lci_lca()

def comparar_ofertas_lci():
    """
    Exemplo de comparação de ofertas de LCI/LCA
    """
    ofertas = [
        {"tipo": "LCI", "banco": "Banco Inter", "rentab": 92, "prazo": 12, "minimo": 1000},
        {"tipo": "LCA", "banco": "BTG Pactual", "rentab": 95, "prazo": 12, "minimo": 5000},
        {"tipo": "LCI", "banco": "Banco Pan", "rentab": 100, "prazo": 24, "minimo": 1000},
        {"tipo": "LCA", "banco": "Banco do Brasil", "rentab": 88, "prazo": 6, "minimo": 500},
        {"tipo": "LCI", "banco": "XP (diversos)", "rentab": 93, "prazo": 12, "minimo": 1000},
    ]
    
    cdi = 13.15  # CDI atual aproximado
    valor = 10000
    
    print("COMPARATIVO DE OFERTAS LCI/LCA (valores ilustrativos)")
    print("=" * 80)
    print(f"Base: CDI {cdi}% | Investimento: R$ {valor:,.2f}")
    print("-" * 80)
    print(f"{'Tipo':<6} {'Banco':<18} {'% CDI':<8} {'Taxa Ef.':<10} {'Prazo':<8} {'Mínimo':<10} {'Rend. Est.'}")
    print("-" * 80)
    
    for oferta in ofertas:
        taxa_efetiva = cdi * oferta['rentab'] / 100
        taxa_mensal = ((1 + taxa_efetiva/100)**(1/12) - 1)
        rendimento = valor * ((1 + taxa_mensal) ** oferta['prazo']) - valor
        
        print(f"{oferta['tipo']:<6} {oferta['banco']:<18} {oferta['rentab']}%{'':<4} {taxa_efetiva:.2f}%{'':<5} {oferta['prazo']}m{'':<5} R$ {oferta['minimo']:<7} R$ {rendimento:,.2f}")
    
    print("-" * 80)
    print("⚠️ Valores ilustrativos. Consulte sua corretora para ofertas atuais.")

comparar_ofertas_lci()

def estrategia_escada(valor_total: float, cdi: float = 13.15):
    """
    Monta estratégia de escada com LCI/LCA
    """
    escada = [
        {"prazo": 3, "perc_cdi": 85, "perc_carteira": 20},
        {"prazo": 6, "perc_cdi": 90, "perc_carteira": 25},
        {"prazo": 12, "perc_cdi": 93, "perc_carteira": 30},
        {"prazo": 24, "perc_cdi": 97, "perc_carteira": 25},
    ]
    
    print("ESTRATÉGIA: ESCADA DE LCI/LCA")
    print("=" * 70)
    print(f"Valor Total: R$ {valor_total:,.2f} | CDI: {cdi}%")
    print("-" * 70)
    
    total_rendimento = 0
    
    for degrau in escada:
        valor = valor_total * (degrau['perc_carteira'] / 100)
        taxa = cdi * degrau['perc_cdi'] / 100
        taxa_mensal = ((1 + taxa/100)**(1/12) - 1)
        rendimento = valor * ((1 + taxa_mensal) ** degrau['prazo']) - valor
        total_rendimento += rendimento
        
        print(f"  {degrau['prazo']:>2} meses | {degrau['perc_cdi']}% CDI | R$ {valor:>12,.2f} | Rend: R$ {rendimento:>10,.2f}")
    
    print("-" * 70)
    print(f"  Rendimento Total Estimado: R$ {total_rendimento:,.2f}")
    print("\nVantagens:")
    print("  ✓ Liquidez escalonada (dinheiro liberado a cada vencimento)")
    print("  ✓ Captura taxas maiores em prazos maiores")
    print("  ✓ Flexibilidade para reinvestir")

estrategia_escada(100000)

RESERVA DE EMERGÊNCIA (6 meses de gastos):

├── 50% Tesouro Selic (liquidez D+1)
│   → Para emergências imediatas
│
└── 50% LCI/LCA 3-6 meses
    → Rende mais, isento de IR
    → Para emergências não urgentes

def maximizar_isencao(valor_disponivel: float, prazo_meses: int, cdi: float):
    """
    Compara estratégias para maximizar rendimento líquido
    """
    print("MAXIMIZANDO RENDIMENTO LÍQUIDO")
    print("=" * 60)
    print(f"Valor: R$ {valor_disponivel:,.2f} | Prazo: {prazo_meses} meses")
    print("-" * 60)
    
    estrategias = [
        {"nome": "100% CDB 100% CDI", "composicao": [(1.0, 100, True)]},
        {"nome": "100% LCI 90% CDI", "composicao": [(1.0, 90, False)]},
        {"nome": "50% CDB 110% + 50% LCI 90%", "composicao": [(0.5, 110, True), (0.5, 90, False)]},
        {"nome": "100% CDB 120% CDI (banco menor)", "composicao": [(1.0, 120, True)]},
    ]
    
    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
    
    resultados = []
    
    for est in estrategias:
        rendimento_total = 0
        
        for perc_valor, perc_cdi, tem_ir in est['composicao']:
            valor = valor_disponivel * perc_valor
            taxa = cdi * perc_cdi / 100
            taxa_mensal = ((1 + taxa/100)**(1/12) - 1)
            rend_bruto = valor * ((1 + taxa_mensal) ** prazo_meses) - valor
            
            if tem_ir:
                rend_liquido = rend_bruto * (1 - aliquota)
            else:
                rend_liquido = rend_bruto
            
            rendimento_total += rend_liquido
        
        resultados.append((est['nome'], rendimento_total))
    
    # Ordenar por rendimento
    resultados.sort(key=lambda x: x[1], reverse=True)
    
    print(f"{'Estratégia':<40} {'Rendimento Líquido'}")
    print("-" * 60)
    
    for nome, rend in resultados:
        destaque = "👑" if rend == resultados[0][1] else ""
        print(f"{nome:<40} R$ {rend:>12,.2f} {destaque}")

maximizar_isencao(50000, 12, 13.15)

BENS E DIREITOS:
Grupo: 04 - Aplicações e Investimentos
Código: 02 - Títulos públicos e privados

Discriminação:
LCI do Banco Inter, aplicado em 15/03/2024,
vencimento 15/03/2026, 92% do CDI.
Quantidade: 1 título. CNPJ: XX.XXX.XXX/0001-XX

Situação em 31/12/2023: R$ 0,00
Situação em 31/12/2024: R$ 50.000,00

RENDIMENTOS ISENTOS:
Linha 12: R$ 4.250,00 (rendimentos LCI/LCA)

LCI e LCA em poucas palavras:
• Isentos de IR para pessoa física
• Protegidos pelo FGC (até R$ 250k)
• Carência mínima de 90 dias
• Comparar com CDB equivalente (tabela)
• Ótimos para objetivos de médio prazo
• Diversificar bancos para proteção