Safe withdrawal rate calculator
Test whether a withdrawal rate lasts: 1,000,000 at 4% with a 7% yearly return over 30 years starts at 40,000 a year, holds to the end and leaves 3,569,333.39. The balance is projected one year at a time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Portfolio
- 1,000,000
- Withdrawal rate percent
- 4
- Years
- 30
- Annual return percent
- 7
- Inflation percent
- 0
- Initial annual withdrawal
- 40,000
- Total withdrawn
- 1,200,000
- Final balance
- 3,569,333.39
- Years survived
- 30
A planned retirement withdrawal rate is only useful if the portfolio can support it for the full horizon under a clear return assumption. This safe withdrawal rate calculator takes your starting balance, the first-year withdrawal as a percent of that balance, a fixed annual portfolio return, an optional inflation path for the withdrawal, and the number of retirement years, then projects the balance year by year. Each year it withdraws the inflated dollar amount first, applies the fixed return to what remains, and reports whether the plan lasts, how many years the portfolio survived, total dollars withdrawn, and the ending balance. Use it to stress a four-percent-style rule, compare six percent versus three percent spending, or document a deterministic baseline before you run more complex Monte Carlo tools.
What a safe withdrawal rate test measures under fixed returns
A safe withdrawal rate answers a practical spending question: given a nest egg at retirement, what fraction of that starting balance can you take in year one—and keep spending in real terms afterward—without running out of money before the plan ends. Classic rules of thumb such as the four percent rule are historical heuristics, not guarantees; they come from studying sequence-of-returns risk across past markets. This capability does not sample random returns.
It runs a transparent fixed-return projection so you can see, under one assumed annual portfolio return and one inflation path for spending, whether the plan is sustainable on paper. If the balance cannot cover a full withdrawal in some year, the run marks the portfolio depleted, records years survived as the complete years before that shortfall, and sets sustainable to false.
What you can do with it
Baseline retirement spending check
Test whether a planned withdrawal rate (for example four percent of the starting portfolio) lasts for a thirty-year horizon under a fixed annual return you choose.
Compare spending rates side by side
Run three percent, four percent, and five percent plans on the same portfolio, return, inflation, and years to see which rates remain sustainable.
Classroom and content demos
Teach the four percent rule and constant-real spending with a deterministic fixed-return projection that students and readers can reproduce exactly.
FAQ
Does inflation change the withdrawal each year?
Leave inflation at zero for a constant nominal withdrawal path.
In what order are the withdrawal and the return applied each year?
The withdrawal comes first, and the return is then applied to what remains. That matches spending at the start of each year, and the same inputs always give the same projection.
What does it mean when the plan is not sustainable?
It means that in some year the balance could not cover the full withdrawal. The projection marks the portfolio as depleted and reports how many complete years it lasted before that shortfall.
How do I compare different withdrawal rates?
Run the same portfolio, return, inflation and years with only the rate changed: 3%, then 4%, then 5%. You will see which rates stay sustainable and how the ending balance differs between them.
Can I test a plan with a negative return?
Yes. The yearly return can be negative as long as it stays above minus 100%. A fixed loss each year shows how a weak market assumption shortens the life of the portfolio.
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/finance/safe-withdrawal-rate-test \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"portfolio":1000000,"withdrawal_rate_percent":4,"years":30,"annual_return_percent":7}'const res = await fetch("https://api.kit.forhosting.com/finance/safe-withdrawal-rate-test", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"portfolio": 1000000,
"withdrawal_rate_percent": 4,
"years": 30,
"annual_return_percent": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/finance/safe-withdrawal-rate-test",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"portfolio": 1000000,
"withdrawal_rate_percent": 4,
"years": 30,
"annual_return_percent": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/safe-withdrawal-rate-test", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"portfolio":1000000,"withdrawal_rate_percent":4,"years":30,"annual_return_percent":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"portfolio":1000000,"withdrawal_rate_percent":4,"years":30,"annual_return_percent":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/safe-withdrawal-rate-test", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"portfolio": 1000000,
"withdrawal_rate_percent": 4,
"years": 30,
"annual_return_percent": 7
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "finance.safe_withdrawal_rate_test",
"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
Invalid input fails with invalid_input and is not billed.
What a safe withdrawal rate test measures under fixed returns
The first-year withdrawal is portfolio times withdrawal_rate_percent over one hundred. In every later year the withdrawal grows by the inflation factor, which keeps real spending constant when inflation_percent matches the cost-of-living path you care about. Growth is applied after the withdrawal each year at the constant annual_return_percent you supply. If every year succeeds and a positive balance remains after the final growth step, sustainable is true and final_balance is the leftover nest egg. That boolean-plus-dollars shape is what planners, educators, and automation need for a crisp yes-or-no sustainability check before layering taxes, Social Security, or variable markets.
Input contract, projection order, rounding, and worked examples
Projection order is always withdraw first, then grow: that matches a common beginning-of-year spending model and keeps goldens stable. Example: portfolio one million, withdrawal rate four, years thirty, annual return seven, inflation zero yields an initial annual withdrawal of forty thousand, sustainable true after thirty years, and a large final balance because seven percent growth outpaces a four percent initial spend with no inflation. POST a JSON body with four required fields: portfolio (starting balance, finite and strictly greater than zero), withdrawal_rate_percent (first-year withdrawal as a percent of that initial balance, finite and greater than zero), years (whole retirement horizon as an integer from one to one hundred twenty), and annual_return_percent (fixed nominal yearly return applied after each withdrawal; must be finite and greater than negative one hundred so the growth factor stays positive). Optional inflation_percent defaults to zero and must also stay above negative one hundred; optional decimals is an integer from zero through eight (default two) controlling half-up rounding on money fields. Missing fields, empty strings, non-finite values, non-positive portfolio or withdrawal rate, and out-of-range years fail with invalid_input and are not billed. Example: the same million-dollar portfolio at ten percent withdrawal, three percent return, thirty years, and two percent inflation typically depletes early; the response sets depleted true, sustainable false, years_survived below thirty, and final_balance zero. Pin the rounded money fields and the boolean flags in tests so clients stay byte-stable across runtimes.
Where a fixed-return SWR calculator earns its keep
Individuals and advisors use a safe withdrawal rate calculator when they want a fast, explainable baseline before opening a full planning suite: pick a portfolio, a spending rate, a long-run return, and a horizon, then see whether the plan survives on those assumptions alone. Educators and FIRE communities need a deterministic oracle for classroom problems and blog demos that ask whether four percent lasts thirty years at a stated return, without importing Monte Carlo libraries or historical return tables. Failed validation does not consume balance. Workflow tools can call the API from n8n, Zapier-style bridges, or edge workers to gate a larger plan: only continue to tax or Social Security modules when sustainable is true under the user’s conservative return.
Technical questions
How does the safe withdrawal rate calculator work?
It takes first-year withdrawal as portfolio times withdrawal_rate_percent/100, inflates that withdrawal each year by inflation_percent, subtracts it from the balance, then multiplies the remainder by (1 + annual_return_percent/100). After the full horizon it reports sustainable, depleted, years_survived, total_withdrawn, and final_balance.
Is this the historical four percent rule or Monte Carlo?
Neither. This is a fixed-return projection under your assumed annual_return_percent and inflation_percent. It is a transparent baseline, not a historical Trinity-study replication and not a stochastic simulation.
What does sustainable mean in the response?
sustainable is true only when the portfolio covers every planned withdrawal for all years and ends with a positive final_balance. If a year cannot fund the full withdrawal, depleted is true, sustainable is false, and years_survived is the number of complete years before that shortfall.
What does the safe withdrawal rate test cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.