Amortization schedule calculator
Borrow 1,200 at 12% for 12 months and you pay 106.62 a month and 79.42 in interest, yet the first payment puts only 94.62 toward the debt. The table shows that split for every month, down to a zero balance. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Principal amount
- 1,200
- Annual rate
- 12
- Term months
- 12
- Monthly payment
- 106.62
- Total payment
- 1,279.42
- Total interest
- 79.42
principal and interest per payment
What an amortization schedule tells you
A fixed-rate loan looks simple from the outside — the same payment every month until it is gone — but the inside of that payment changes constantly. In the early months most of the money services the interest and only a small slice reduces the debt; as the balance falls, the interest shrinks and the principal share grows. The amortization schedule calculator makes that visible row by row.
You send three numbers: the principal, the annual rate in percent and the term in months. You get back the monthly payment, the total you will pay, the total interest, and a schedule with one entry per period showing the payment, its interest part, its principal part and the balance after it. That is the table a bank prints on page two of a loan contract, produced deterministically by the standard annuity formula, with the final payment adjusted so the balance ends at exactly zero instead of a rounding artifact.
How the numbers are computed
The monthly payment uses the classic annuity formula: principal times the monthly rate, divided by one minus one plus the monthly rate raised to the negative number of months. With a zero percent rate the payment is simply the principal divided by the term. Each period's interest is the outstanding balance times the monthly rate, rounded to cents, and the principal part is whatever remains of the payment.
Everything is rounded to two decimals as it is computed, which is exactly why the last row is special: it is set to the remaining balance plus its interest, guaranteeing the schedule closes at zero. There is also an upper bound of 1200 periods, a hundred years, to keep responses bounded.
Ways to put the schedule to work
Another is planning prepayments — look at how much interest is still packed into the early rows and you can see what an extra payment saves. Accounting teams use the schedule to split each booked payment between interest expense and principal repayment, and support teams use it to reconcile a customer's statement against the contract. Nothing is stored: the computation is pure arithmetic over your three inputs, performed and discarded.
What you can do with it
Split booked payments in accounting
Use each period's interest and principal parts to post interest expense and debt reduction separately.
Plan a prepayment
See how much of the remaining interest sits in the early periods and estimate what an extra payment saves.
FAQ
What inputs does it need?
Three: the principal (loan amount), the annual interest rate in percent, and the term in months.
What happens if the term is not a whole number?
The term must be a positive integer number of months, and invalid input is never charged.
Why is the last payment different from the others?
Each row is rounded to cents, so the final payment is adjusted to clear the exact remaining balance and close the schedule at zero.
Does it support a zero percent loan?
Yes. With an annual rate of 0 the payment is simply the principal divided by the number of months, and every row's interest is zero.
Is my loan data stored?
No. The schedule is computed from your input and discarded; nothing is persisted.
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
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/fin/amortization \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"principal":20000,"annual_rate":7.5,"term_months":60}'const res = await fetch("https://api.kit.forhosting.com/fin/amortization", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"principal": 20000,
"annual_rate": 7.5,
"term_months": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/amortization",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"principal": 20000,
"annual_rate": 7.5,
"term_months": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/amortization", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"principal":20000,"annual_rate":7.5,"term_months":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"principal":20000,"annual_rate":7.5,"term_months":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/amortization", 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": 20000,
"annual_rate": 7.5,
"term_months": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.amortization",
"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
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_periods | 1200 |
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
The amortization schedule API takes a loan's principal, annual interest rate and term in months and returns the complete repayment plan: the fixed monthly payment and, for every single period, how much of that payment goes to interest, how much reduces the principal, and the balance that remains. It also returns the total paid and the total interest over the life of the loan, so you can compare offers, plan prepayments or reconcile a lender's statement without opening a spreadsheet.
How the numbers are computed
Input validation is strict — the principal must be positive, the rate non-negative, and the term must be a positive whole number of months; a fractional term like 36.5 is rejected with an invalid_input error and is never charged.
Ways to put the schedule to work
The most common use is comparing offers: two loans with the same monthly payment can cost very different totals, and the total_interest field answers that in one glance. Because the same code runs free in your browser on this page and as the paid API at $0.002 per request, you can prototype interactively and then automate the identical calculation in your pipeline, knowing the numbers will match to the cent.
Integration use cases
Compare two loan offers
Run both sets of terms and compare total_interest: the cheaper loan is not always the one with the lower monthly payment.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.