Life insurance needs calculator
Replacing an income of 75,000 for 10 years and clearing 50,000 of debts calls for 800,000 of life insurance. Get a starter coverage figure from income, years of support and debts, and rerun it when your life changes. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Annual income
- 75,000
- Years of replacement
- 10
- Outstanding debts
- 50,000
- Income replacement
- 750,000
- Recommended coverage
- 800,000
Choosing how much life insurance to carry is one of the first hard money questions households face after a new job, a mortgage, or a child. Rule-of-thumb multiples of salary help a little, but a clearer starter figure multiplies the income you want replaced by the number of years dependents would need that support, then adds the debts that should not outlive you. This life insurance needs calculator implements that DIME-style estimate in pure arithmetic: annual income times years of replacement plus outstanding debts equals the recommended coverage amount. There is no underwriting score, no premium quote, and no medical questionnaire—only a transparent formula you can re-run whenever income, debt, or the replacement horizon changes.
What the DIME-style coverage estimate means
DIME is a classic personal-finance mnemonic for sizing a first-pass life insurance face amount: Debt, Income, Mortgage, and Education. In its textbook form you list remaining consumer and student loans, multiply annual earnings by a chosen income-replacement horizon, add the mortgage balance still owed, and add the cost of educating dependents. Income replacement equals annual income times the number of years you want paychecks notionally continued after death; recommended coverage is that product plus the debt total.
The result is a recommended face amount, not a premium, cash-value projection, or tax analysis. Non-negative income and debts are required; negative values fail with a clear field message instead of inventing a coverage figure. Pair the number with a licensed adviser when you need product selection, riders, or estate design; this tool only multiplies and adds so you never disagree with a spreadsheet that uses the same three cells.
What you can do with it
Household coverage planning
Estimate a starter life insurance face amount from salary, years of support for dependents, and a consolidated debt total after a job change or home purchase.
Coaching and classroom worksheets
Generate reproducible DIME-style answer keys for personal-finance lessons that teach income replacement plus debt payoff, not premium shopping.
FAQ
Does this quote premiums or underwrite a policy?
No. The calculator only estimates a face-amount starting point from income, years, and debts. Premiums, health underwriting, and product selection require a licensed adviser or carrier.
What does DIME stand for in life insurance?
Debt, Income, Mortgage and Education, the four needs a policy is often sized to cover. Here the mortgage and education loans are folded into one debt total, so you only enter three numbers.
How many years of income should I replace?
Use the number of years your dependents would need your paycheck to continue, for example until children are independent. Any positive number of years works; zero or negative years are rejected.
Which debts should I include?
Add up everything you want the policy to clear: the remaining mortgage, car loans, credit cards, personal loans and education loans. Enter that sum as a single total of outstanding debts.
Is this figure enough to buy a policy?
It is a starting face amount, not a recommendation of a product. For choosing a policy, riders or estate planning, review the number with a licensed adviser.
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/life-insurance-needs-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"annual_income":75000,"years_of_replacement":10,"outstanding_debts":50000}'const res = await fetch("https://api.kit.forhosting.com/fin/life-insurance-needs-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"annual_income": 75000,
"years_of_replacement": 10,
"outstanding_debts": 50000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/life-insurance-needs-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"annual_income": 75000,
"years_of_replacement": 10,
"outstanding_debts": 50000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/life-insurance-needs-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"annual_income":75000,"years_of_replacement":10,"outstanding_debts":50000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"annual_income":75000,"years_of_replacement":10,"outstanding_debts":50000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/life-insurance-needs-estimate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"annual_income": 75000,
"years_of_replacement": 10,
"outstanding_debts": 50000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.life_insurance_needs_estimate",
"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.
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
What the DIME-style coverage estimate means
Many households already keep a single outstanding-debts total that folds mortgage and education loans into one line item, so this capability uses a streamlined contract: annual_income, years_of_replacement, and outstanding_debts. Years of replacement must be strictly positive—zero or negative years do not define a meaningful income-replacement horizon and are rejected as invalid_input. On success the response echoes the three inputs, reports income_replacement and recommended_coverage rounded to two decimal places for stable currency-style comparisons, and includes a short method tag and formula string you can show next to the answer.
Input contract, response shape, and error behaviour
Example: seventy-five thousand annual income, ten years of replacement, and fifty thousand of debts yields seven hundred fifty thousand of income replacement and eight hundred thousand of recommended coverage. Failed validation is not billed. POST a JSON body with three required finite numbers. annual_income is the gross yearly income to replace; aliases income, yearly_income, and salary are accepted so forms and spreadsheets can reuse familiar column names. years_of_replacement is the horizon in years; aliases years, replacement_years, and income_years map to the same field, and the value must be greater than zero or the task fails with invalid_input naming years_of_replacement. outstanding_debts is the lump sum of obligations you want the policy to clear—mortgage remainder, car loans, credit cards, personal loans—with aliases debts, total_debt, and debt. Each field may arrive as a JSON number or a numeric string; missing fields, empty strings, and non-finite values fail with invalid_input. Negative annual_income or outstanding_debts are rejected because a coverage estimate cannot start from a negative income base or a negative debt pile in this model. When validation passes, the body returns annual_income, years_of_replacement, outstanding_debts, income_replacement (income times years), recommended_coverage (income_replacement plus debts), method set to a DIME-style label, and formula restating the closed form. The pure parse path never calls a carrier API, never samples randomness, and never depends on the system clock, so goldens and client tests compare byte-for-byte across runtimes when they pin the same three inputs.
Where a life insurance needs API earns its keep
Households use a life insurance needs calculator when a new salary, a home purchase, or a child forces a first conversation about how much cover would keep dependents whole if income stopped. Financial coaches and educators need a deterministic oracle that marks non-positive replacement years as invalid instead of silently returning zero coverage that a buggy form might treat as success. Product teams wire the same contract into onboarding wizards so users see a starter face amount before a human underwriter or agent refines it. Keep requests small, pin rounded recommended_coverage values in tests, and you get reproducible coverage estimates for worksheets, LMS plugins, and edge workers without standing up actuarial infrastructure of your own. When you later add education costs or a separate mortgage field in a spreadsheet, simply include those balances in outstanding_debts here so the DIME-style total stays aligned with the full mnemonic while the API surface remains three fields.
Integration use cases
Product onboarding and CI fixtures
Seed budgeting apps and automated tests with deterministic recommended_coverage values that match browser and API paths byte-for-byte.
Technical questions
How is the recommended life insurance coverage calculated?
recommended_coverage equals annual_income times years_of_replacement plus outstanding_debts. That is a simplified DIME-style estimate: income replacement plus debts to clear.
What happens if years_of_replacement is zero or negative?
The task fails with invalid_input. Years of replacement must be a positive number greater than zero so the income-replacement horizon is meaningful.
Should mortgage and education costs go in outstanding_debts?
Yes if you already track them as balances to pay off. Classic DIME lists mortgage and education separately; this tool accepts a single debt total so you can fold those lines in.
What does the life insurance needs calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.