ForHosting KIT · Finance & money

FIRE number calculator

Find the portfolio that can cover your spending indefinitely: 40,000 a year at a 4% safe withdrawal rate means a FIRE number of 1,000,000, the familiar 25x rule. Adjust the rate or add a safety buffer. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Annual expenses: 40,000

You get

Safe withdrawal rate (%): 4
Safety buffer (%): 0
FIRE target number: 1,000,000

Compute your FIRE number, the portfolio that sustains withdrawals indefinitely, from annual or monthly expenses, a safe withdrawal rate (default 4%), and an optional safety buffer.

What the FIRE number means

In a financial-independence plan, the FIRE number is the size of portfolio whose withdrawals can cover your spending indefinitely. It comes from two inputs: what you spend in a year and the share of the portfolio you plan to withdraw each year, known as the safe withdrawal rate. The calculation divides annual spending by that rate. With the usual default of 4%, the result is 25 times your yearly spending, which is where the 25x rule comes from: 40,000 of spending points to 1,000,000. If you enter monthly spending, it is multiplied by twelve first.

Choosing the rate and the buffer

The withdrawal rate has a strong effect on the result. A lower rate means a bigger target: at 3%, the same 40,000 a year needs about 1,333,333. The rate has to be above zero, because withdrawing nothing would require an endless portfolio, and it cannot exceed 100%. The optional buffer adds a margin of safety on top of the raw figure, so 10% lifts 1,000,000 to 1,100,000. A common slip is to mix monthly and yearly spending: enter one or the other and the calculator converts it.

What you can do with it

Retirement target

Turn annual spending into the 25x, or a custom SWR, portfolio target behind a financial-independence plan.

Coaching dashboards

Embed a deterministic, reproducible target inside planning tools without a server-side math engine.

FAQ

Why is the FIRE number 25 times annual spending?

Because 25 is what you get when you divide by a 4% withdrawal rate. Withdrawing 4% of 1,000,000 gives 40,000 a year, so a 40,000 budget needs 1,000,000 at that rate.

What happens if I use a lower withdrawal rate?

The target rises. At 3%, the same 40,000 of yearly spending needs about 1,333,333 instead of 1,000,000, because each year's withdrawal is a smaller slice of the portfolio.

Can I enter monthly expenses instead of annual ones?

Yes. Monthly spending is multiplied by twelve first, so 3,333.33 a month and 40,000 a year lead to the same 1,000,000 target.

What does the safety buffer add?

It adds a margin of safety on top of the raw target. A 10% buffer turns a FIRE number of 1,000,000 into 1,100,000, without changing the withdrawal rate you chose.

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

POSThttps://api.kit.forhosting.com/finance/fire-number

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/fire-number \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"annual_expenses":40000}'

const res = await fetch("https://api.kit.forhosting.com/finance/fire-number", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "annual_expenses": 40000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/finance/fire-number",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "annual_expenses": 40000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/fire-number", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"annual_expenses":40000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"annual_expenses":40000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/fire-number", 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
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "finance.fire_number",
  "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

Per request$0.002

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 formula behind the number

The FIRE number is the portfolio size that lets withdrawals cover your spending indefinitely, and the calculator derives it from annual_expenses divided by your safe withdrawal rate. Concretely, fire_number equals annual_expenses divided by swr_percent-over-one-hundred, then multiplied by one plus buffer_percent-over-one-hundred. With the default swr_percent of 4 and no buffer, $40,000 of annual spending returns exactly $1,000,000, the familiar 25x rule expressed as a formula rather than a rule of thumb. If you provide monthly_expenses instead of annual_expenses, the core multiplies it by twelve first, so $3,333.33 per month and $40,000 per year converge on the same target. The response echoes annual_expenses, swr_percent, and buffer_percent so the assumptions behind the single fire_number figure are always visible and reproducible.

Inputs, defaults, and validation

Provide either annual_expenses or monthly_expenses; the resolved yearly figure must be a finite number greater than zero or the core returns a typed invalid_input error naming annual_expenses. The swr_percent must be greater than zero and no more than one hundred: a rate of zero would imply an infinite portfolio and is rejected, while values above one hundred are nonsensical and also rejected. The buffer_percent defaults to zero and adds a margin of safety on top of the raw target, so a buffer of ten inflates a $1,000,000 number to $1,100,000. The optional decimals field defaults to two, and the final fire_number is rounded once with an explicit half-up rule on the raw product rather than through successive rounding, keeping the target stable across repeated calls.

Sensitivity and scope

The calculator intentionally models only the target multiple; it does not project growth, inflation, taxes, or years-to-FIRE, so pair it with a savings-timeline tool for a full plan. Lowering swr_percent is the most consequential lever: dropping from 4 to 3 raises the same $40,000 target from $1,000,000 to about $1,333,333, reflecting a more conservative, longer-horizon withdrawal assumption. The buffer_percent lets you layer healthcare, sequence-of-returns, or lifestyle-inflation cushions without changing your spending input. Because the math is pure and deterministic, the number is reproducible across sessions and safe to embed in retirement dashboards, coaching tools, or scenario tables that sweep swr_percent from 3 to 5.

Integration use cases

Scenario tables

Sweep swr_percent from 3% to 5% to see how conservative withdrawal assumptions raise the number.

Technical questions

How is the FIRE number computed?

annual_expenses divided by (swr_percent/100), times (1 + buffer_percent/100). At 4% SWR, $40,000 gives $1,000,000.

Can I enter monthly spending?

Yes. Pass monthly_expenses and it is multiplied by twelve before the calculation.

What does the buffer do?

buffer_percent adds a safety margin on top of the raw target; a 10% buffer turns $1,000,000 into $1,100,000.

What are the input limits?

Expenses must be above zero and swr_percent must be greater than 0 and at most 100, or you get invalid_input.

Is it free?

Yes in the browser widget. The deterministic API is priced from $0.002 and charges only successful runs.

Read the full KIT documentation →

Run — free