Conheça também nossa calculadora de investimentos.

Como usar o simulador de amortização

A interface foi projetada para ser simples, quer você esteja apenas pesquisando para comprar uma casa ou já tenha um contrato rodando.

1. Escolha o Cenário: No topo da calculadora, alterne entre “Novo Financiamento” ou “Em Andamento”. Se o seu contrato já iniciou, você informará o seu Saldo Devedor Atual e quantas parcelas restam.
2. Preencha os Parâmetros: Digite o valor, o prazo, a taxa de juros anual (aquela que aparece na capa do seu contrato) e escolha o sistema (PRICE para parcelas fixas, SAC para decrescentes).
3. O Aporte Extra: Aqui acontece a mágica. Digite o valor que você planeja pagar a mais todos os meses.
4. Analise os Dados: Clique em simular. O algoritmo vai gerar uma tabela completa mês a mês, mostrando exatamente quantas parcelas futuras aquele seu aporte extra “matou” instantaneamente.

A data de vencimento

A calculadora assume que você está fazendo o aporte extra exatamente no dia do vencimento da sua parcela normal. Por que isso importa?

Os bancos cobram juros diários. Se você paga sua parcela no dia 10, sua fila de juros zera. Se você faz o aporte extra no dia 11, 100% desse dinheiro ataca e destrói o seu saldo devedor. Se você demorar e fizer o aporte no dia 25, o banco vai usar parte do seu dinheiro extra só para pagar os juros que acumularam nesses 15 dias, diminuindo o seu poder de amortização. Por isso, sempre amortize no dia do vencimento.

Descomplicando o algoritmo: A lógica por trás da calculadora

Se você é da área de tecnologia e gosta de ver as engrenagens girando, o verdadeiro motor desta calculadora não está na interface, mas nos laços de repetição (loops) que processam a dívida.

Originalmente, modelei este cálculo usando a linguagem Python. O desafio lógico de uma amortização extra é descobrir em que ponto do futuro o seu aporte se encaixa. Veja o trecho principal do código.

    def amortizacao_com_eliminadas(valor_financiado, taxa_juros, num_parcelas, tipo="PRICE", pagamento_extra=0):
    taxa = taxa_juros

    saldo_original = valor_financiado
    saldos_originais = []
    if tipo.upper() == "PRICE":
        parcela_fixa = valor_financiado * ((taxa * ((1 + taxa)**num_parcelas)) / (((1 + taxa)**num_parcelas) - 1))
    elif tipo.upper() == "SAC":
        parcela_fixa = None
    else:
        raise ValueError("Tipo de amortização deve ser 'PRICE' ou 'SAC'")

    for _ in range(1, num_parcelas + 1):
        juros = saldo_original * taxa
        if tipo.upper() == "PRICE":
            amortizacao = parcela_fixa - juros
        else:
            amortizacao = valor_financiado / num_parcelas
        saldo_original -= amortizacao
        saldos_originais.append(max(saldo_original, 0))

    saldo_devedor = valor_financiado
    parcelas = []
    mes = 0

    while saldo_devedor > 0 and mes < num_parcelas:
        mes += 1
        juros = saldo_devedor * taxa

        if tipo.upper() == "PRICE":
            amortizacao_mes = parcela_fixa - juros
            parcela_total = parcela_fixa
        else:
            amortizacao_mes = valor_financiado / num_parcelas
            parcela_total = amortizacao_mes + juros

        amortizacao_total = amortizacao_mes + pagamento_extra
        saldo_devedor -= amortizacao_total
        saldo_devedor = max(saldo_devedor, 0)

        parcelas_eliminadas = 0
        for i, saldo_ref in enumerate(saldos_originais):
            if saldo_ref <= saldo_devedor:
                parcelas_eliminadas = num_parcelas - (i + 1)
                break
        else:
            parcelas_eliminadas = num_parcelas - mes

        parcelas.append((mes, parcela_total, juros, amortizacao_mes, pagamento_extra, saldo_devedor, parcelas_eliminadas))

        if saldo_devedor <= 0:
            break
    
    soma = 0
    print(f"{'Mês':<5} {'Parcela':<12} {'Juros':<12} {'Amortização':<15} {'Extra':<10} {'Saldo Devedor':<15} {'Parcelas Eliminadas':<20}")
    for i, (mes, parcela, juros, amort, extra, saldo, eliminadas) in enumerate(parcelas):
        if i == 0:
            print(f"{mes:<5} {parcela:<12,.2f} {juros:<12,.2f} {amort:<15,.2f} {extra:<10,.2f} {saldo:<15,.2f} {num_parcelas - parcelas[i][6]:<20}")
        else:
            print(f"{mes:<5} {parcela:<12,.2f} {juros:<12,.2f} {amort:<15,.2f} {extra:<10,.2f} {saldo:<15,.2f} {parcelas[i-1][6] - parcelas[i][6]:<20}")


    
  

Analisando código, podemos entender que o primeiro passo é rodar um loop simulando o financiamento inteiro sem nenhuma ajuda, gravando o saldo devedor mês a mês numa lista chamada saldos_originais.

Quando o loop while começa a rodar é injetado o pagamento_extra, logo o seu Saldo Devedor cai drasticamente. Nesse momento, o algoritmo percorre a lista saldos_originais procurando o ponto exato onde aquele novo saldo se encaixaria no cenário original. A diferença de posições entre o cenário real e o cenário base é exatamente o número de "Meses Eliminados" que você vê na última coluna da nossa tabela.