Emergency fund calculator
Essential bills of 3000 a month covered for 6 months make an emergency fund target of 18000. Enter what you must still pay each month if income stops and how many months you want to be covered. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Monthly expenses
- 3,000
- Months
- 6
- Emergency fund
- 18,000
- Precision
- 10
This emergency fund calculator turns two simple inputs — your monthly essential living expenses and how many months of coverage you want — into a clear cash-target number. The formula is fully deterministic: emergency fund equals monthly expenses times months, so three thousand per month for six months is eighteen thousand, and twenty-five hundred for three months is seventy-five hundred. Essential expenses mean the bills you still must pay if income stops: housing, food, utilities, insurance, minimum debt payments, and similar must-haves, not optional dining or subscriptions. Classic personal-finance guidance often recommends three to six months of expenses, or six to twelve when income is uneven or a household has higher fixed costs. The engine uses only finite arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where emergency-fund sizing fits in planning, teaching, and software
Households use the target when building a starter savings goal after listing rent, groceries, utilities, insurance, and minimum loan payments, then choosing three, six, or twelve months based on job stability and dependents. Students meet the same product when a personal-finance unit asks for a cash buffer sized to essential costs rather than total take-home pay. Teachers can pre-generate answer keys for modest monthly figures without trusting opaque apps that mix gross income with discretionary spend.
Developers call the same contract from scripts to seed deterministic test vectors for budgeting apps, to normalize user-entered expense totals before showing a fund goal, or to satisfy programming-challenge statements that demand expenses times months rather than a hand-waved round number. Coaching and product tools use the figure when a learner types monthly must-pays and a horizon and the UI must show a single savings target next to a progress bar.
Pair it with rule-of-72, cost-per-use, or other life helpers when you are building a small lab of free, deterministic personal-finance tools.
What you can do with it
Household cash buffer goals
Size a 3–6 or 6–12 month emergency fund from listed essential monthly bills for budgeting and savings plans.
Classroom and coaching worksheets
Generate reproducible expenses × months targets for personal-finance lessons, answer keys, and coaching sessions.
FAQ
What does the emergency fund calculator cost?
It is free in your browser on this page.
How is the emergency fund calculated?
For example, 3000 per month for 6 months yields 18000.
What counts as monthly essential expenses?
Must-pay living costs such as housing, food, utilities, insurance, and minimum debt payments — not discretionary or optional spending.
What happens if monthly expenses are negative?
Emergency fund size is defined only for non-negative essential costs in this calculator.
How many months should I choose?
Common guidance is 3–6 months for stable income and 6–12 when income is irregular or household fixed costs are high. The calculator accepts any non-negative finite month count you choose.
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/life/emergency-fund \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"monthly_expenses":3000,"months":6}'const res = await fetch("https://api.kit.forhosting.com/life/emergency-fund", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"monthly_expenses": 3000,
"months": 6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/emergency-fund",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"monthly_expenses": 3000,
"months": 6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/emergency-fund", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"monthly_expenses":3000,"months":6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"monthly_expenses":3000,"months":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/emergency-fund", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"monthly_expenses": 3000,
"months": 6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.emergency_fund",
"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_abs_value | 1000000000000000 |
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
Use it free in the browser for budgeting sessions, classroom demos, and quick planning checks, or call the API at $0.002 per successful request when you need reproducible fund targets in CI, coaching tools, or product calculators.
What an emergency fund target means and what the response contains
An emergency fund is a cash or near-cash reserve sized to cover essential living costs for a chosen number of months if paychecks pause. Negative months are also rejected because a coverage horizon cannot be negative. Zero expenses or zero months are allowed and correctly yield a zero fund, which is useful when testing forms or demonstrating edge cases. The calculator multiplies monthly essential expenses by the target month count and returns that product as emergency_fund, along with the normalized monthly_expenses and months you supplied, a method tag expenses_times_months, a short formula string, and the precision used for rounding. There is no portfolio simulation, no inflation path, and no credit-score lookup: the engine either multiplies two finite non-negative numbers inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include a missing monthly_expenses or months field, non-finite values, magnitudes above the documented ceiling, and any monthly_expenses that is negative, because a negative cost base does not define a meaningful cash buffer in this model.
How monthly expenses and months are read and how results stay reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong fund target. Months must not be negative either, for the same horizon-validity reason. The preferred fields are monthly_expenses for must-pay living costs per month and months for the coverage horizon, but aliases expenses, monthly_essential_expenses, essential_expenses, monthly_cost, monthly, and monthly_spend map to the expense input, while target_months, n_months, months_of_expenses, coverage_months, and horizon_months map to the horizon so spreadsheets, query strings, and typed forms can reuse the same contract. Monthly expenses must not be negative: if the value is below zero, the request fails with invalid_input naming monthly_expenses. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric fields, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the multiplication yourself.
Where emergency-fund sizing fits in planning, teaching, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic budgeting fixtures
Seed CI and product calculators with stable emergency_fund values from known monthly_expenses and months inputs.