Early retirement calculator
Spending 40,000 a year at a 4% withdrawal rate means you need a nest egg of 1,000,000, which is 25 times your annual expenses. Enter your yearly spending and the rate you are comfortable with to see your target. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Annual expenses
- 40,000
- Withdrawal rate
- 4
- Withdrawal decimal
- 0.04
- Expense multiple
- 25
- Nest egg
- 1,000,000
Leaving full-time work years before a traditional pension age is a spending problem as much as a savings problem: you need a portfolio that can cover annual expenses without a paycheck. The classic safe-withdrawal-rate method answers that with one division. Divide planned yearly spending by the withdrawal rate you are willing to take from invested assets, and you obtain the target nest egg. This early retirement calculator performs that Trinity-style identity: nest egg equals annual expenses divided by the withdrawal rate as a percent over one hundred. A four percent rate on forty thousand of spending yields one million; a three percent rate on the same spending yields about one million three hundred thirty-three thousand.
The nest-egg identity and the safe withdrawal rate
The target nest egg for early retirement is the portfolio that can fund a chosen lifestyle from withdrawals alone, without relying on a paycheck. The identity used by the Trinity study and by most planning that talks about a safe withdrawal rate is simple: if you withdraw a fixed percentage of the starting portfolio each year, the starting portfolio must equal annual expenses divided by that percentage.
The second form is the familiar expense multiple: a four percent withdrawal rate is a twenty-five-times rule; a three percent rate is about thirty-three times; a five percent rate is twenty times. Those multiples are not magic constants. They encode a judgment about how much sequence-of-returns risk, inflation, and longevity you are willing to take.
A more conservative retiree lowers the withdrawal rate and therefore raises the nest egg; a retiree who will keep some earned income or who expects a later pension can raise the rate and shrink the target. This calculator does not pick the rate for you and does not default it to four.
Who uses a nest-egg target, and how
Coaching practices and independent advisors can embed the same pure module so a client who typed spending and a four percent rate on a public page sees the identical nest egg later in a saved plan. Spreadsheet replacements and personal-finance apps often already store annual spending; posting that figure with a handful of trial rates—three, three and a half, four, five—fills a scenario table without standing up a planning vendor.
Educators teaching the four percent rule can generate worked examples that show how a one-point change in the withdrawal rate moves a six-figure spending plan by hundreds of thousands of dollars of required capital. Product teams building independence dashboards can keep this identity in a tiny parse worker instead of copying a twenty-five-times multiply into every client. Failed validation does not consume balance.
The calculator does not project investment growth, inflation indexing, taxes, state benefits, or years until you hit the number; those belong in companion tools.
What you can do with it
Headline early-retirement target
Turn planned yearly spending and a chosen safe withdrawal rate into the nest egg a career-break or independence plan has to reach.
Coaching and course worksheets
Embed a deterministic Trinity-style target in advice tools and personal-finance lessons without a server-side planning engine.
FAQ
What withdrawal rate should I enter?
Enter a percent, not a fraction: 4 means 4%. Common planning rates sit between 3% and 5%. This tool does not choose a rate or default it for you.
Why is a non-positive withdrawal rate rejected?
A rate of zero would require an infinite portfolio. A negative rate inverts the identity.
Does this include inflation, taxes, or investment growth?
No. It returns the static Trinity-style target only. Pair it with a growth, tax, or sustainability tool if you need a path through those effects.
What is the 25-times rule?
It is the 4% rule turned around: at a 4% withdrawal rate you need 25 times your yearly spending. A 3% rate needs about thirty-three times and a 5% rate twenty times, so a lower rate means a bigger target.
Can I count a pension or part-time income?
There is no separate box for them. Retirees who expect a later pension or will keep some earned income can justify a higher withdrawal rate, which shrinks the nest egg the calculator returns.
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/early-retirement \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"annual_expenses":40000,"withdrawal_rate":4}'const res = await fetch("https://api.kit.forhosting.com/fin/early-retirement", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"annual_expenses": 40000,
"withdrawal_rate": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/early-retirement",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"annual_expenses": 40000,
"withdrawal_rate": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/early-retirement", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"annual_expenses":40000,"withdrawal_rate":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"annual_expenses":40000,"withdrawal_rate":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/early-retirement", 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_expenses": 40000,
"withdrawal_rate": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.early_retirement",
"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
The rate must be positive; a zero or negative withdrawal rate would imply an infinite or inverted portfolio and is rejected as invalid_input.
The nest-egg identity and the safe withdrawal rate
Written as a formula, nest_egg equals annual_expenses divided by (withdrawal_rate over one hundred). Equivalently, nest_egg equals annual_expenses times (one hundred divided by withdrawal_rate). You supply both annual_expenses and withdrawal_rate so the result is an explicit function of your assumptions rather than a hidden rule of thumb. The response echoes both inputs, reports the implied expense_multiple, reports the withdrawal_decimal used in the division, and returns nest_egg rounded with a half-up rule to two decimal places so currency displays stay stable across runtimes.
Input contract, response shape, and error behaviour
The required error path for this capability is a withdrawal rate that is not positive: zero would imply an infinite portfolio, and a negative rate would invert the identity into a nonsense short position. Example: annual expenses of forty thousand and a withdrawal rate of four produce a withdrawal decimal of 0.04, an expense multiple of twenty-five, and a nest egg of one million. POST a JSON body with two required finite numbers. annual_expenses is planned yearly spending in currency units, greater than or equal to zero; aliases expenses, spending, yearly_expenses, and annual_spend are accepted. withdrawal_rate is the safe withdrawal rate as a percent, not a fraction: send four for four percent, not 0.04, unless you truly mean four hundredths of one percent. Aliases swr, swr_percent, safe_withdrawal_rate, and rate are accepted. Each field may arrive as a JSON number or as a numeric string. Missing fields, empty strings, booleans, and non-finite values fail with invalid_input naming the field. Negative annual_expenses is rejected because a spending target cannot be negative. Those requests fail with invalid_input whose message states that withdrawal_rate must be positive; they are not billed. On success the body includes annual_expenses, withdrawal_rate, withdrawal_decimal (the rate divided by one hundred), expense_multiple (one hundred divided by the rate), nest_egg, and a short formula string. Pair the figure with a sustainability simulator if you need a path through sequence-of-returns risk; this endpoint returns the static Trinity-style target only.
Where an early-retirement nest-egg API earns its keep
Keep the withdrawal rate positive, pin the rounded nest_egg in tests, and you get a reproducible early-retirement target for widgets, course modules, and edge workers.
Integration use cases
Rate scenario tables
Sweep withdrawal_rate from 3% to 5% on the same expenses to show how conservative assumptions raise the required portfolio.
Technical questions
How is the early-retirement nest egg calculated?
nest_egg equals annual_expenses divided by (withdrawal_rate/100). At a 4% rate, $40,000 of yearly spending returns $1,000,000, which is the 25× expense multiple.
What does the early retirement calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.