SAC vs PRICE: O Guia Estratégico de Amortização

Como economizar milhares de reais e construir patrimônio com as decisões certas.

Autor

Estrategista Imobiliário

Data de Publicação

28 de março de 2026

A Escolha que Define seu Patrimônio

Ao financiar um imóvel, a maioria das pessoas foca apenas na parcela que cabe no orçamento mensal. No entanto, para quem busca eficiência de capital, a verdadeira pergunta é: Quanto desse dinheiro ficará comigo se eu precisar vender o imóvel em 5 anos?

Neste guia, analisamos o cenário de um financiamento de R$ 500.000,00 e como aportes estratégicos de R$ 20.000,00/ano transformam sua dívida.

1. Contexto das Taxas (Março de 2026)

Para que esta simulação seja fiel à realidade, utilizamos os indicadores médios vigentes:

  • CET (Custo Efetivo Total): 11,5% a.a. O CET é a sigla fundamental. Diferente da “Taxa Nominal”, o CET inclui seguros obrigatórios (MIP/DFH) e taxas administrativas. É o valor real que sai do seu bolso.
  • CDI (Benchmark de Investimento): 11,25% a.a. Referenciado pela Taxa Selic atual.

Insight de Investidor: Se o seu CET (custo do banco) é de 11,5% e o seu investimento rende CDI (11,25%), amortizar é matematicamente superior a investir, pois o rendimento líquido do investimento (após Imposto de Renda) será significativamente menor que o custo da dívida.

2. O Simulador Estratégico

Utilize a ferramenta interativa abaixo para comparar os sistemas. Ajuste os sliders para ver o valor das Parcelas Mensais, a evolução do Saldo Devedor (Dívida), Custo Total Acumulado (Acumulado), Custo de Oportunidade (Invest.) e Patrimônio Líquido (Equity).

#| '!! shinylive warning !!': |
#|   shinylive does not work in self-contained HTML documents.
#|   Please set `embed-resources: false` in your metadata.
#| standalone: true
#| viewerHeight: 820

## file: app.py
#| standalone: true
#| viewerHeight: 820

## file: app.py
from shiny import App, render, ui, reactive
import pandas as pd
import plotly.graph_objs as go
from shinywidgets import output_widget, render_widget

# --- MOTOR FINANCEIRO ---
def calcular_tabelas(valor_fin, cet_anual, prazo_anos):
    prazo_meses = prazo_anos * 12
    taxa_mensal = (1 + cet_anual)**(1/12) - 1
    
    dados_sac = []
    saldo_sac = valor_fin
    amort_sac = valor_fin / prazo_meses
    pago_acum_sac = 0
    for m in range(1, prazo_meses + 1):
        juros = saldo_sac * taxa_mensal
        parcela = amort_sac + juros
        saldo_sac -= amort_sac
        pago_acum_sac += parcela
        dados_sac.append({"Mes": m, "Ano": m/12, "Parcela": parcela, "Saldo": max(0, saldo_sac), "Total_Pago": pago_acum_sac})
        
    dados_price = []
    saldo_price = valor_fin
    parcela_price = valor_fin * (taxa_mensal * (1 + taxa_mensal)**prazo_meses) / ((1 + taxa_mensal)**prazo_meses - 1)
    pago_acum_price = 0
    for m in range(1, prazo_meses + 1):
        juros = saldo_price * taxa_mensal
        amort = parcela_price - juros
        saldo_price -= amort
        pago_acum_price += parcela_price
        dados_price.append({"Mes": m, "Ano": m/12, "Parcela": parcela_price, "Saldo": max(0, saldo_price), "Total_Pago": pago_acum_price})
        
    return pd.DataFrame(dados_sac), pd.DataFrame(dados_price)

# --- CONFIGURACAO VISUAL ---
ESTILO_LAYOUT_BASE = dict(
    template="plotly_white",
    font=dict(family="Arial, sans-serif", size=11), # Reduzi um pouco o padrão para mobile
    margin=dict(l=50, r=20, t=40, b=50), # Margens mais enxutas
    hovermode="x unified",
    legend=dict(orientation="h", yanchor="bottom", y=-0.3, xanchor="center", x=0.5), # Legenda embaixo ajuda no mobile
    xaxis=dict(title="Anos", showline=True, linewidth=1, dtick=5),
    yaxis=dict(showline=True, linewidth=1, tickformat=",.0f")
)

app_ui = ui.page_fluid(
    ui.head_content(
        # Meta tag para garantir que o mobile entenda o redimensionamento
        ui.tags.meta(name="viewport", content="width=device-width, initial-scale=0.8, maximum-scale=1.0, user-scalable=yes"),
        ui.tags.style("""
            body { background-color: #f8f9fa; }
            .insight-card { 
                background: white; 
                border-left: 5px solid #27ae60; 
                padding: 12px; 
                border-radius: 8px; 
                margin-bottom: 15px; 
                border: 1px solid #eee;
                font-size: 0.9rem;
            }
            /* Ajuste para telas pequenas */
            @media (max-width: 768px) {
                h2 { font-size: 1.4rem !important; }
                .insight-card { font-size: 0.8rem; padding: 8px; }
                .control-panel .shiny-input-container { margin-bottom: 5px !important; }
            }
        """)
    ),
    ui.markdown("## Estrategista Imobiliário: SAC vs PRICE"),
    
    # Layout responsivo: 1 coluna no mobile, 4 no desktop
    ui.layout_column_wrap(
        ui.input_numeric("valor", "Valor (R$)", 500000, step=10000),
        ui.input_slider("taxa", "CET (%)", 5.0, 15.0, 11.5, step=0.1),
        ui.input_slider("selic", "Selic (%)", 2.0, 20.0, 11.25, step=0.25),
        ui.input_slider("prazo", "Prazo (Anos)", 5, 35, 35),
        width=1/2, # No mobile o Shiny tenta ajustar, mas o 'width' aqui define a base
        widths_sm=1, 
        class_="control-panel"
    ),
    
    ui.div(ui.output_ui("texto_insights"), class_="insight-card"),
    
    ui.navset_tab(
        ui.nav_panel("Parcelas", output_widget("grafico_parcelas")),
        ui.nav_panel("Dívida", output_widget("grafico_saldo")),
        ui.nav_panel("Acumulado", output_widget("grafico_acumulado")),
        ui.nav_panel("Invest.", output_widget("grafico_investimento")),
        ui.nav_panel("Equity", output_widget("grafico_equity"))
    )
)

def server(input, output, session):
    @reactive.calc
    def dados():
        return calcular_tabelas(input.valor(), input.taxa()/100, input.prazo())

    @output
    @render.ui
    def texto_insights():
        df_sac, df_price = dados()
        try:
            idx_p = df_sac[df_sac['Parcela'] <= df_price['Parcela'].iloc[0]].index[0]
            anos_p, meses_p = int(df_sac.iloc[idx_p]['Mes'] // 12), int(df_sac.iloc[idx_p]['Mes'] % 12)
            ponto_c = df_price[df_price['Total_Pago'] > df_sac['Total_Pago']].iloc[0]
            anos_c, meses_c = int(ponto_c['Mes'] // 12), int(ponto_c['Mes'] % 12)
            economia = df_price['Total_Pago'].iloc[-1] - df_sac['Total_Pago'].iloc[-1]
            return ui.markdown(f"""
                * **Inversão de parcelas:** As parcelas SAC tornam-se mais econômicas que a PRICE após **{anos_p} anos e {meses_p} meses**.
                * **Custo Total:** O sistema SAC torna-se mais vantajoso no valor acumulado após **{anos_c} anos e {meses_c} meses**.
                * **Resultado Final:** A economia real do SAC ao quitar o contrato será de **R$ {economia:,.2f}**.
                """)
        except: return ui.markdown("Ajuste os filtros.")

    @render_widget
    def grafico_parcelas():
        df_sac, df_price = dados()
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=df_sac['Ano'], y=df_sac['Parcela'], name="SAC", line=dict(color='#0984e3', width=2)))
        fig.add_trace(go.Scatter(x=df_price['Ano'], y=df_price['Parcela'], name="PRICE", line=dict(color='#d63031', width=2)))
        fig.update_layout(**ESTILO_LAYOUT_BASE, title="Parcela Mensal")
        return fig

    @render_widget
    def grafico_saldo():
        df_sac, df_price = dados()
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=df_sac['Ano'], y=df_sac['Saldo'], name="SAC", line=dict(color='#0984e3', width=2)))
        fig.add_trace(go.Scatter(x=df_price['Ano'], y=df_price['Saldo'], name="PRICE", line=dict(color='#d63031', width=2)))
        fig.update_layout(**ESTILO_LAYOUT_BASE, title="Saldo Devedor")
        return fig

    @render_widget
    def grafico_acumulado():
        df_sac, df_price = dados()
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=df_sac['Ano'], y=df_sac['Total_Pago'], name="Total SAC", line=dict(color='#0984e3')))
        fig.add_trace(go.Scatter(x=df_price['Ano'], y=df_price['Total_Pago'], name="Total PRICE", line=dict(color='#d63031')))
        fig.update_layout(**ESTILO_LAYOUT_BASE, title="Custo Total Pago")
        return fig

    @render_widget
    def grafico_investimento():
        df_sac, df_price = dados()
        cdi_base, ir = input.selic() / 100, 0.15
        percentuais = [1.0, 1.1, 1.2] # Reduzi para 3 curvas no mobile para não poluir
        cores = ['#e74c3c', '#f1c40f', '#27ae60']
        
        fig = go.Figure()
        for pct, cor in zip(percentuais, cores):
            taxa_anual = cdi_base * pct
            taxa_m = (1 + taxa_anual)**(1/12) - 1
            invest = [0]
            for i in range(len(df_sac)):
                diff = df_sac['Parcela'].iloc[i] - df_price['Parcela'].iloc[i]
                saldo = invest[-1] * (1 + taxa_m * (1 - ir)) + diff
                invest.append(max(0, saldo))
            invest.pop(0)
            fig.add_trace(go.Scatter(x=df_sac['Ano'], y=invest, name=f"{int(pct*100)}% CDI", line=dict(color=cor, width=2)))

        fig.update_layout(**ESTILO_LAYOUT_BASE, title="Diferencial Investido")
        return fig

    @render_widget
    def grafico_equity():
        df_sac, df_price = dados()
        v_fin = input.valor()
        cdi_base, ir = input.selic() / 100, 0.15
        
        equity_sac = v_fin - df_sac['Saldo']
        equity_price_puro = v_fin - df_price['Saldo']
        
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=df_sac['Ano'], y=equity_sac, name="Equity SAC", line=dict(color='#0984e3', width=2)))
        fig.add_trace(go.Scatter(x=df_price['Ano'], y=equity_price_puro, name="Equity PRICE", line=dict(color='#d63031', width=2)))
        
        # Apenas 100% CDI para limpar o gráfico mobile
        taxa_m = (1 + cdi_base)**(1/12) - 1
        invest = [0]
        for i in range(len(df_sac)):
            diff = df_sac['Parcela'].iloc[i] - df_price['Parcela'].iloc[i]
            saldo = invest[-1] * (1 + taxa_m * (1 - ir)) + diff
            invest.append(max(0, saldo))
        invest.pop(0)
        
        fig.add_trace(go.Scatter(x=df_sac['Ano'], y=equity_price_puro + invest, name="PRICE + 100% CDI", line=dict(color='#f1c40f', dash='dash')))

        fig.update_layout(**ESTILO_LAYOUT_BASE, title="Evolução do Patrimônio")
        return fig

app = App(app_ui, server)


## file: requirements.txt
pandas
plotly
shinywidgets
shiny
exceptiongroup; python_version < "3.11"

3. Quando a Tabela PRICE vale a pena?

Embora o sistema SAC seja matematicamente mais barato ao final do contrato, a Tabela PRICE pode ser uma ferramenta estratégica para quem possui disciplina financeira e capacidade de investimento. A vantagem da PRICE não está no custo do juro, mas no Custo de Oportunidade.

O Conceito do Investimento da Diferença

Nos primeiros anos, a parcela da PRICE é consideravelmente menor que a do SAC. Se você optar pela PRICE e investir a diferença em uma aplicação de Renda Fixa (como o CDI), o rendimento acumulado pode superar o custo extra de juros pago ao banco.

A Regra do Equilíbrio (Break-even)

Para que a comparação entre investir ou amortizar seja precisa, não olhe apenas para a taxa de juros nominal do contrato. O valor que realmente importa é o CET (Custo Efetivo Total). Ele representa o custo real anualizado, incluindo seguros obrigatórios e taxas administrativas.

Para que essa estratégia faça sentido, o rendimento líquido do seu investimento precisa render, no mínimo, o equivalente ao CET do financiamento após o pagamento de impostos. Considerando a alíquota de 15% de Imposto de Renda sobre os ganhos de capital, utilizamos a seguinte fórmula:

\[Taxa\ Alvo\ Bruta = \frac{CET\ do\ Financiamento}{0,85}\]

Tabela de Referência (CDI a 11,25%)

CET do Banco (a.a.) Taxa Alvo Líquida Retorno Necessário (% do CDI)
10,5% 12,35% 109,8% do CDI
11,5% 13,53% 120,2% do CDI
12,5% 14,71% 130,7% do CDI

Nota: Se o seu investimento rende apenas 100% do CDI, qualquer financiamento com CET acima de 9,56% a.a. já torna o sistema SAC (amortização acelerada) matematicamente superior ao investimento da diferença.

4. Estratégias de Amortização: Acelerando a Quitação

A amortização extraordinária (como o uso do FGTS ou bônus anuais) segue a mesma lógica do custo de oportunidade. Se você possui um capital extra, a decisão entre “Amortizar a Dívida” ou “Investir o Dinheiro” depende da comparação entre o CET do seu contrato e o rendimento líquido do seu investimento.

Regra de Ouro: Se o seu investimento não rende pelo menos CET / 0,85, o melhor “investimento” que você pode fazer é amortizar. Amortizar é, na prática, garantir um retorno livre de risco igual ao custo do seu financiamento.

Ao decidir amortizar, você deve escolher entre duas estratégias com objetivos distintos:

A. Redução de Parcela (Foco: Fôlego no Caixa)

Nesta modalidade, você mantém o prazo original do contrato, mas o valor da sua mensalidade cai proporcionalmente ao aporte.

  • Na Tabela SAC: Como a amortização mensal é fixa, ao reduzir o saldo devedor, o componente de juros da próxima parcela cai imediatamente. É a estratégia ideal para quem busca reduzir o peso do financiamento no orçamento mensal.
  • Na Tabela PRICE: A redução também ocorre, mas como as parcelas são originalmente fixas, o alívio pode parecer mais sutil no início, embora ajude a manter a previsibilidade do caixa.

B. Redução de Prazo (Foco: Quitação Rápida e Economia de Juros)

Aqui, você mantém o valor da parcela que já paga hoje, mas o banco recalcula o tempo restante. Esta é, matematicamente, a estratégia mais eficiente para economizar juros.

  • Na Tabela PRICE: É onde o efeito é mais impactante. Como a PRICE amortiza muito pouco no início da dívida, um aporte extra de valor modesto pode “limpar” vários meses de juros puros do final do contrato.
  • Na Tabela SAC: Também é extremamente eficaz, pois ao reduzir o prazo, você elimina anos de taxas administrativas e seguros obrigatórios (MIP/DFI) que incidiriam sobre o saldo devedor.

Simulador de Amortização Extraordinária

Abaixo, você pode simular o impacto de aportes únicos ou anuais no seu saldo devedor.

#| '!! shinylive warning !!': |
#|   shinylive does not work in self-contained HTML documents.
#|   Please set `embed-resources: false` in your metadata.
#| standalone: true
#| viewerHeight: 600

## file: app.py
from shiny import App, render, ui, reactive
import pandas as pd

def simular_vida_real(saldo_atual, cet_anual, prazo_restante_meses, aporte_extra):
    taxa_m = (1 + cet_anual)**(1/12) - 1
    
    # --- CENARIO PRICE ---
    # 1. Prestacao que o usuario ja paga hoje (fixa)
    if saldo_atual > 0:
        pmt_original = saldo_atual * (taxa_m * (1 + taxa_m)**prazo_restante_meses) / ((1 + taxa_m)**prazo_restante_meses - 1)
        # 2. Novo saldo apos o aporte
        saldo_p = saldo_atual - aporte_extra
        meses_p = 0
        while saldo_p > 0 and meses_p < 600:
            j_m = saldo_p * taxa_m
            am = pmt_original - j_m
            saldo_p -= am
            meses_p += 1
    else:
        meses_p = 0

    # --- CENARIO SAC ---
    # Na SAC, a amortizacao mensal e fixa (Saldo / Prazo). 
    # Reduzir prazo mantendo a prestacao inicial significa manter essa cota de amortizacao.
    if saldo_atual > 0:
        amort_fixa_sac = saldo_atual / prazo_restante_meses
        saldo_s = saldo_atual - aporte_extra
        meses_s = saldo_s / amort_fixa_sac
    else:
        meses_s = 0
    
    return meses_s, meses_p

app_ui = ui.page_fluid(
    ui.head_content(ui.tags.style("""
        .insight-card { background: #f8f9fa; border-left: 5px solid #27ae60; padding: 15px; border-radius: 8px; margin-bottom: 15px; border: 1px solid #dee2e6; }
        .table { font-size: 14px; }
    """)),
    ui.markdown("### Simulador de Amortizacao Extraordinaria"),
    ui.layout_column_wrap(
        ui.input_numeric("valor_2", "Saldo Devedor Atual", 500000, step=10000),
        ui.input_slider("taxa_2", "CET Anual (%)", 5.0, 15.0, 11.5, step=0.1),
        ui.input_numeric("prazo_2", "Prazo Restante (Anos)", 35),
        ui.input_numeric("aporte", "Valor do Aporte (R$)", 20000, step=5000),
        width=1/4, fill=False
    ),
    ui.navset_tab(
        ui.nav_panel("Reducao de Valor", 
            ui.div(ui.output_ui("insight_valor"), class_="insight-card"),
            ui.output_table("tabela_valor")
        ),
        ui.nav_panel("Reducao de Prazo", 
            ui.div(ui.output_ui("insight_prazo"), class_="insight-card"),
            ui.output_table("tabela_prazo")
        )
    )
)

def server(input, output, session):
    @reactive.calc
    def gerar_dados():
        p_orig_m = input.prazo_2() * 12
        taxa_m = (1 + (input.taxa_2()/100))**(1/12) - 1
        res = []
        for i in range(6):
            ap_total = i * input.aporte()
            saldo_v = max(0, input.valor_2() - ap_total)
            
            # Reducao Valor
            p_sac = (saldo_v / p_orig_m) + (saldo_v * taxa_m) if saldo_v > 0 else 0
            p_price = saldo_v * (taxa_m * (1 + taxa_m)**p_orig_m) / ((1 + taxa_m)**p_orig_m - 1) if saldo_v > 0 else 0
            
            # Reducao Prazo
            m_sac, m_price = simular_vida_real(input.valor_2(), input.taxa_2()/100, p_orig_m, ap_total)
            
            res.append({
                "Aporte Acumulado": f"R$ {ap_total:,.2f}",
                "Parcela SAC": p_sac,
                "Parcela PRICE": p_price,
                "Red_SAC": int(max(0, p_orig_m - m_sac)),
                "Red_PRICE": int(max(0, p_orig_m - m_price))
            })
        return pd.DataFrame(res)

    @output
    @render.ui
    def insight_valor():
        df = gerar_dados()
        diff_sac = df["Parcela SAC"].iloc[0] - df["Parcela SAC"].iloc[1]
        diff_price = df["Parcela PRICE"].iloc[0] - df["Parcela PRICE"].iloc[1]
        return ui.markdown(f"**Insight:** Cada aporte de R$ {input.aporte():,.2f} reduz sua próxima parcela em **R$ {diff_sac:,.2f}** no SAC e **R$ {diff_price:,.2f}** na PRICE (mantendo o prazo original).")

    @output
    @render.ui
    def insight_prazo():
        df = gerar_dados()
        red_sac_1 = df["Red_SAC"].iloc[1]
        red_price_1 = df["Red_PRICE"].iloc[1]
        return ui.markdown(f"""
        **Insight:** 
        * No **SAC**, a redução é linear: cada aporte reduz o prazo em exatos **{red_sac_1:.1f} meses**.
        * Na **PRICE**, o primeiro aporte elimina **{red_price_1:.1f} meses**. Note que essa potência diminui conforme a dívida reduz, pois você tem menos 'juros futuros' para economizar.
        """)

    @output
    @render.table
    def tabela_valor():
        df = gerar_dados()[["Aporte Acumulado", "Parcela SAC", "Parcela PRICE"]].copy()
        df["Parcela SAC"] = df["Parcela SAC"].map("R$ {:,.2f}".format)
        df["Parcela PRICE"] = df["Parcela PRICE"].map("R$ {:,.2f}".format)
        return df

    @output
    @render.table
    def tabela_prazo():
        df = gerar_dados()[["Aporte Acumulado", "Red_SAC", "Red_PRICE"]].copy()
        df.columns = ["Aporte Acumulado", "Reducao Prazo SAC", "Reducao Prazo PRICE"]
        df["Reducao Prazo SAC"] = df["Reducao Prazo SAC"].map("{:.1f} meses".format)
        df["Reducao Prazo PRICE"] = df["Reducao Prazo PRICE"].map("{:.1f} meses".format)
        return df

app = App(app_ui, server)


## file: requirements.txt
pandas
plotly
shinywidgets
shiny
exceptiongroup; python_version < "3.11"

Comparativo Estratégico: SAC vs. PRICE

Objetivo Melhor Sistema Por que?
Reduzir Parcela SAC Gera um alívio de caixa imediato e decrescente, aumentando sua segurança financeira mensal.
Reduzir Prazo PRICE Ataca o ponto fraco da Price (juros altos no início), reduzindo o custo total de forma exponencial.

Conclusão: O “Pulo do Gato” do Investidor

Se você é um investidor disciplinado, a estratégia ideal é:

  1. Invista enquanto o seu rendimento líquido for maior que o CET do banco.
  2. Amortize (Reduzindo Prazo) no momento em que as taxas de juros do mercado caírem e ficarem abaixo do custo do seu financiamento.

Dessa forma, você faz o banco trabalhar com o seu dinheiro enquanto os juros estão altos e quita a dívida rapidamente quando o cenário de investimentos deixar de ser tão atrativo.

5. Estratégia de Saída: Venda ou Upgrade antes do Prazo Final

A vida é dinâmica: uma promoção, um novo emprego em outra cidade ou o crescimento da família podem exigir a venda do imóvel muito antes dos 35 anos previstos, ou do prazo total contratado. Quando o futuro é incerto, a escolha do sistema de amortização define a velocidade de construção do seu Patrimônio Líquido (Equity).

O que é o Patrimônio Líquido Imobiliário?

Ao morar em um imóvel financiado, o seu capital real (riqueza acumulada) não é o valor total de mercado da casa, mas sim a soma de dois fatores: o quanto do imóvel já é seu e o quanto você acumulou de capital investido por fora. A fórmula da riqueza no financiamento é:

\[Patrimônio\ Líquido = (Valor\ de\ Mercado - Saldo\ Devedor) + Saldo\ dos\ Investimentos\]

Dois Caminhos para a Formação de Patrimônio

O sistema SAC atua como um acelerador de patrimônio físico. Como a amortização é constante e significativamente maior desde a primeira parcela, você “compra” fatias reais do imóvel todos os meses de forma forçada. É a escolha de quem prioriza reduzir a dívida rapidamente e ter a segurança de um saldo devedor baixo em caso de venda.

Já o sistema PRICE permite uma estratégia de patrimônio financeiro. Como a prestação inicial da PRICE é menor que a da SAC, o “sucesso” deste modelo depende exclusivamente do Custo de Oportunidade:

  1. A Armadilha: Na PRICE, a estrutura de juros faz com que, nas primeiras décadas, você pague quase exclusivamente juros, mantendo o saldo devedor (a dívida com o banco) praticamente estagnado.
  2. A Solução: Para não ficar para trás na formação de patrimônio, o comprador deve investir religiosamente a diferença entre a parcela da SAC e a da PRICE.

Neste cenário, o seu patrimônio não cresce dentro da parede da casa (amortização), mas sim em uma conta de investimentos. Se o rendimento desse investimento superar o custo do financiamento (CET), o investidor pode chegar ao final do período com um patrimônio líquido superior ao de quem escolheu a SAC. No entanto, se essa diferença for gasta em consumo, o comprador da PRICE chegará aos 15 ou 20 anos de contrato com quase nenhuma evolução patrimonial real.

Comparativo de Acúmulo de Patrimônio (%)

A tabela abaixo projeta quanto do valor original do financiamento você já efetivamente quitou (gerou de Equity) em um horizonte de 35 anos, comparando a amortização direta com o potencial de investimento da diferença.

Prazo Decorrido Patrimônio Acumulado (SAC) Patrimônio Acumulado (PRICE) Patrimônio (PRICE + Invest¹*) Patrimônio (PRICE + Invest²*)
5 anos ~14% ~2% ~14% ~14%
10 anos ~28% ~4% ~25% ~28%
15 anos ~43% ~9% ~35% ~42%
20 anos ~57% ~18% ~40% ~56%
25 anos ~71% ~32% ~40% ~69%
30 anos ~85% ~57% ~57% ~81%
35 anos 100% 100% 100% 100%

*Cálculo base: Diferença entre parcelas SAC e PRICE investida mensalmente a 100%¹* e 120%²* do CDI (11,25% a.a.), descontando IR de 15% sobre o rendimento.

O Saldo Devedor como “Âncora”

Note que, no cenário de 20 anos, enquanto no SAC você já é dono de mais da metade do imóvel (57%), na PRICE você ainda deve mais de 80% do valor original ao banco. Mesmo que você tenha investido a diferença, o seu patrimônio imobiliário está “preso” em uma dívida que custa a baixar.

Conclusão Estratégica: Se você pretende fazer um upgrade de imóvel em 10 ou 15 anos, o SAC garante que você terá um valor de entrada robusto (fruto da dívida baixa) para o próximo passo. Na PRICE, a sua liquidez dependerá totalmente da sua experiência e disciplina em não mexer nos investimentos acumulados ao longo do tempo.

💡 Dica de Visualização:

Para ver esses números aplicados ao seu cenário exato, utilize o simulador acima na aba “Dívida” para ver seu Saldo Devedor. Observe como a linha da PRICE (vermelha) demora a se distanciar do topo do gráfico, agindo como uma âncora no seu progresso patrimonial durante os primeiros 20 anos.