ForHosting KIT · Finance & money

Loan total interest calculator

Borrow 250,000 at 6.5% for 30 years and you pay 318,861.22 in interest, more than the loan itself. Enter the amount, rate and term to see that lifetime cost, the fixed payment and everything you will repay. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Principal amount: 250,000
Annual rate: 6.5
Term years: 30

You get

Payments per year: 12
Payment count: 360
Periodic rate: 0.0054166667
Payment: 1,580.17

Borrowers, advisors, and product teams often ask a single plain question before signing: how much interest will this fixed-rate amortizing loan cost over its full term? Headline rates and monthly payments hide the lifetime cost of capital, especially on long mortgages and multi-year installment plans where interest can approach or exceed the principal. This loan total interest calculator accepts principal, annual rate as a percent, and term in years, optionally adjusts payments per year, and returns the fixed periodic payment, total amount paid, total interest, and interest as a percent of principal.

What total interest means on a fixed-rate amortizing loan

A fixed-rate amortizing loan charges a constant periodic payment that covers both interest and principal so the balance reaches zero exactly after a known number of payments. Each period, interest is computed on the remaining principal at the contractual periodic rate, and the rest of the payment reduces principal. Early payments are mostly interest; later payments are mostly principal.

Total interest over the life of the loan is simply the sum of every interest portion across all periods, which equals the sum of all payments minus the original principal. That lifetime figure is what households use when comparing a fifteen-year versus thirty-year mortgage, what fintech onboarding flows show next to APR explanations, and what underwriting sandboxes check when they stress long terms at high rates.

Unlike simple interest on a single bullet principal, amortizing interest depends on the schedule length and payment frequency, so you cannot read it from principal times rate times years alone. This capability isolates that lifetime interest so you do not need a full amortization table to answer the cost question.

With a two-hundred-fifty-thousand principal at six and a half percent for thirty years of monthly payments, the schedule is three hundred sixty payments, each payment is fixed by the standard formula, and total interest is the excess of three hundred sixty times that payment over the original two hundred fifty thousand—often well over the principal itself on long residential terms.

What you can do with it

Mortgage term comparison

Compare total interest on the same principal at 15-year versus 30-year fixed terms to show the true cost of a lower monthly payment.

FAQ

How is total interest calculated?

The fixed periodic payment uses the standard amortizing formula (or principal/n when the rate is zero). Total interest equals payment times the number of payments minus principal.

How much interest will I pay on 250,000 at 6.5% over 30 years?

About 318,861.22 with monthly payments. The fixed payment is 1,580.17 over 360 payments, so you repay 568,861.22 in total, and the interest alone equals 127.54% of the amount borrowed.

Why can't I just multiply the principal by the rate and the years?

Because each payment lowers the balance, and interest is charged only on what is still owed. Early payments are mostly interest and later ones mostly principal, so the lifetime total depends on the schedule, not on one multiplication.

Can I work out total interest for biweekly or weekly payments?

Yes. Change the number of payments per year to 26 for biweekly, 52 for weekly, 4 for quarterly or 1 for annual; monthly, 12, is the default. The years multiplied by that number must give a whole count of payments.

What happens if the interest rate is zero?

Each payment is simply the amount borrowed divided by the number of payments, and total interest is zero. You repay exactly the principal and nothing more, which makes a handy baseline when comparing offers.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/finance/loan-total-interest

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/finance/loan-total-interest \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":250000,"annual_rate":6.5,"term_years":30}'

const res = await fetch("https://api.kit.forhosting.com/finance/loan-total-interest", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "principal": 250000,
    "annual_rate": 6.5,
    "term_years": 30
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/finance/loan-total-interest",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "principal": 250000,
    "annual_rate": 6.5,
    "term_years": 30
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/loan-total-interest", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"principal":250000,"annual_rate":6.5,"term_years":30}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"principal":250000,"annual_rate":6.5,"term_years":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/loan-total-interest", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "principal": 250000,
  "annual_rate": 6.5,
  "term_years": 30
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "finance.loan_total_interest",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

Input contract, payment formula, and response fields

Currency-like fields use half-up rounding once from the raw values. Send a JSON object with three required finite numbers: principal greater than zero (the amount borrowed), annual_rate as a nominal percent greater than or equal to zero (six point five means six point five percent per year, not a decimal fraction), and term_years greater than zero. Optionally set payments_per_year to an integer from one to three hundred sixty-five (default twelve for monthly; twenty-six biweekly, fifty-two weekly, four quarterly, or one annual are common), and decimals from zero to eight for currency-style rounding (default two). The engine forms payment_count as term_years times payments_per_year and requires that product to be a whole number of payments so fractional schedules are rejected with a clear invalid_input message. The periodic rate r is annual_rate over one hundred divided by payments_per_year. When r is zero, each payment is principal divided by payment_count and total interest is zero. When r is positive, payment equals principal times r times (one plus r) to the n, divided by (one plus r) to the n minus one, with n equal to payment_count. total_paid is payment times n; total_interest is total_paid minus principal; interest_to_principal_percent is total_interest over principal times one hundred. Outputs also echo principal, annual_rate, term_years, payments_per_year, payment_count, periodic_rate, and a short formula string. Missing fields, non-finite numbers, non-positive principal or term, negative rates, and out-of-range integers fail with invalid_input and are not billed.

Where a loan total interest API earns its keep

Mortgage and auto-loan education pages need a live total interest number next to payment estimates so visitors understand the long-term cost of a lower monthly payment on a longer term. Personal finance apps and advisors run side-by-side scenarios—same principal, different rates or terms—to show how much interest a borrower saves by refinancing or by choosing fifteen years instead of thirty. Classroom and exam tools teaching amortization can assert total interest against known textbook cases with stable rounded goldens. Marketplaces and loan originators pre-fill calculators from quote forms and need a deterministic parse endpoint that matches spreadsheet amortizations without standing up a full banking core. Sweep term_years or annual_rate in a loop from your own code to build comparison tables; pin payment and total_interest in tests; and keep requests small.

Integration use cases

Rate quote side-by-sides

Sweep annual_rate across competing offers and rank loans by lifetime interest instead of payment alone.

Fintech and LMS automation

Call the API from onboarding or homework tools for a deterministic total_interest oracle that matches spreadsheet amortizations.

Technical questions

Which fields are required?

principal (>0), annual_rate (≥0 as a percent), and term_years (>0). payments_per_year defaults to 12; decimals defaults to 2.

Does annual_rate mean 0.065 or 6.5 for 6.5%?

Use 6.5 for a 6.5% nominal annual rate. The engine divides by 100 internally before applying the periodic rate.

Can I model biweekly or weekly payments?

Yes. Set payments_per_year to 26 (biweekly), 52 (weekly), 4 (quarterly), or 1 (annual). term_years times payments_per_year must be a whole payment count.

What does the loan total interest calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free