# Rent vs Buy Calculator

Should you rent or buy a home? Run the invest-the-difference net-worth race over your time horizon and get a break-even year and a buy/rent verdict.

## Run it

- **CLI:** `gizza tool rent-vs-buy 'home_price=400000'`
- **Web:** https://gizza.ai/tools/rent-vs-buy/
- **Agents:** machine-readable descriptor (parameters JSON Schema) at https://gizza.ai/tools/rent-vs-buy/tool.json

## Inputs

- `home_price` — Home price _(field)_
- `down_payment_percent` — Down payment (%) _(field)_
- `mortgage_rate_percent` — Mortgage rate (%) _(field)_
- `loan_term_years` — Loan term (years) _(field)_
- `monthly_rent` — Monthly rent _(field)_
- `years` — Years you'll stay _(field)_
- `home_appreciation_percent` — Home appreciation (%/yr) _(field)_
- `rent_growth_percent` — Rent growth (%/yr) _(field)_
- `investment_return_percent` — Investment return (%/yr) _(field)_
- `property_tax_percent` — Property tax (%/yr of value) _(field)_
- `home_insurance_percent` — Home insurance (%/yr of value) _(field)_
- `maintenance_percent` — Maintenance (%/yr of value) _(field)_
- `hoa_monthly` — HOA / condo dues (monthly) _(field)_
- `buying_closing_percent` — Buying closing costs (%) _(field)_
- `selling_cost_percent` — Selling costs (%) _(field)_
- `currency` — Currency symbol _(field)_
- `decimals` — Decimal places _(field)_

## Output

- Rent vs buy breakdown (text)

## Query parameters

Open the tool pre-filled and auto-run via URL:

- `home_price` — Home price
- `down_payment_percent` — Down payment (%)
- `mortgage_rate_percent` — Mortgage rate (%)
- `loan_term_years` — Loan term (years)
- `monthly_rent` — Monthly rent
- `years` — Years you'll stay
- `home_appreciation_percent` — Home appreciation (%/yr)
- `rent_growth_percent` — Rent growth (%/yr)
- `investment_return_percent` — Investment return (%/yr)
- `property_tax_percent` — Property tax (%/yr of value)
- `home_insurance_percent` — Home insurance (%/yr of value)
- `maintenance_percent` — Maintenance (%/yr of value)
- `hoa_monthly` — HOA / condo dues (monthly)
- `buying_closing_percent` — Buying closing costs (%)
- `selling_cost_percent` — Selling costs (%)
- `currency` — Currency symbol
- `decimals` — Decimal places

Example: `https://gizza.ai/tools/rent-vs-buy/?home_price=400000&down_payment_percent=20&mortgage_rate_percent=6.5&loan_term_years=30&monthly_rent=2000&years=10&home_appreciation_percent=3&rent_growth_percent=3&investment_return_percent=5&property_tax_percent=1.1&home_insurance_percent=0.5&maintenance_percent=1&hoa_monthly=0&buying_closing_percent=3&selling_cost_percent=6&currency=%24&decimals=0`

---

## About this tool

This calculator answers the real rent-vs-buy question — **over the years you actually plan to
stay, will you end up wealthier renting or buying?** — the way credible calculators do. It does
**not** just line up a monthly mortgage payment against monthly rent. It runs an
**"invest-the-difference" net-worth race**:

- The buyer pays the **down payment and closing costs up front**. The renter invests that same
  cash instead, so it keeps earning a return (the opportunity cost of tying money up in a house).
- **Each month**, whichever side has the lower housing cost invests the difference. Both invested
  pots compound at your assumed investment return.
- At the end of your horizon the **buyer's net worth** = the appreciated home value − selling
  costs − the remaining mortgage + their invested savings; the **renter's net worth** = their
  invested savings. Buying "wins" when the buyer comes out ahead.

The headline is a **verdict** (buy, rent, or a wash) plus the **break-even year** — the first year
buying pulls ahead of renting. Two levers usually decide it: **how long you stay** (short stays
favour renting because up-front buying and selling costs never get amortised) and your
**investment return** (a high return favours renting, because the down payment compounds hard
elsewhere).

You can tune every table-stakes input: home price, down payment, mortgage rate and term, monthly
rent, home appreciation, rent growth, investment return, property tax, insurance, maintenance,
HOA dues, and buying/selling costs. Everything runs locally in your browser — nothing you type is
uploaded.

**Limits (honesty):** rates are nominal with monthly compounding; costs are flat percentages; it
does **not** model PMI, mortgage-interest or property-tax deductions, or local price data. It's a
planning estimate, not financial advice.

## FAQ

<details>
<summary>How is this different from comparing my rent to a mortgage payment?</summary>

A monthly rent-vs-mortgage comparison ignores the two things that actually decide the outcome:
the **opportunity cost** of the down payment (the renter invests it instead) and the **equity and
appreciation** the buyer builds over time. This tool runs the full **net-worth race** — the buyer
pays up-front costs, the renter invests that cash, and each month whoever pays less invests the
difference. At your horizon it compares total wealth on each side, not just one month's bill.

</details>

<details>
<summary>What is the break-even year?</summary>

The **break-even year** is the first whole year at which the buyer's net worth — computed as if
they sold the home that year, paying selling costs and the remaining mortgage — catches up to the
renter's. Before it, renting is ahead; after it, buying is. If buying never overtakes renting
within your horizon, the tool says so and reports no break-even year. It's the number behind the
common rule of thumb "buy only if you'll stay at least N years."

</details>

<details>
<summary>Why does a higher investment return favour renting?</summary>

Because the renter's advantage is that they never tie up a large down payment in a house — they
invest it. The higher the return that invested money earns, the more the renter's side-fund grows,
and the harder it is for home appreciation and mortgage paydown to catch up. Try setting the
investment return to 10–12% and you'll usually see the verdict flip to renting; drop it to 3–4%
and buying wins sooner.

</details>

<details>
<summary>Which inputs matter most?</summary>

**How long you'll stay** is the single biggest driver — short stays lose to the up-front buying
and selling costs, long stays let appreciation and equity win. After that: the **investment
return** (higher favours renting), the **home-appreciation rate** (higher favours buying), and the
gap between your **mortgage rate** and **rent**. The smaller cost knobs (tax, insurance,
maintenance, HOA) shift the number but rarely change the verdict on their own.

</details>

<details>
<summary>Is this financial advice?</summary>

No. It's a planning estimate that runs entirely in your browser. It uses nominal rates with
monthly compounding and flat percentage costs, and it deliberately leaves out PMI, mortgage-interest
and property-tax deductions, and any local market data. Real deals involve taxes, loan details, and
market timing this model doesn't capture — treat the result as a starting point and adjust for your
own situation.

</details>

## Related tools

- [Base Decoder](https://gizza.ai/tools/base-decoder/): Auto-detect and decode Base16, Base32, Base45, Base58, Base64, and Base85 text, including nested layers, locally in your browser.
- [Detect Clipping in WAV Audio](https://gizza.ai/tools/clipping-detector/): Paste base64 or hex WAV bytes and detect clipped full-scale samples, consecutive clipping runs, timestamps, and worst distorted regions. Runs locally in your browser.
- [Decode/Transform Recipe Pipeline](https://gizza.ai/tools/cyberchef-pipeline/): Chain byte-level decode/transform steps — Base64, hex, URL, gzip/zlib, XOR, ROT13 — into one recipe, applied top to bottom. Free, private, runs entirely in your browser.
- [Downsample Time-Series (LTTB)](https://gizza.ai/tools/downsample-timeseries/): Reduce a large time-series to a target point count with LTTB, min/max, M4, or every-nth downsampling — shape preserved, in your browser, no upload.
- [ipynb to Script](https://gizza.ai/tools/ipynb-to-script/): Extract code cells from a Jupyter .ipynb into a clean Python script or Markdown, dropping outputs and execution counts. Runs locally in your browser.
