Rule of 72 calculator
At 8% a year your money doubles in about 9 years, because 72 divided by 8 is 9. Enter an annual growth rate in percent for a quick doubling estimate before you open full compound-interest tables. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Interest rate
- 8
- Years
- 9
- Precision
- 10
This rule of 72 calculator turns a constant annual growth rate into a quick estimate of how many years a principal, portfolio, or other growing quantity needs to double. The classic mental-math formula is years approximately equals seventy-two divided by the rate in percent points: at eight percent a year you get about nine years, at six percent about twelve years, and at twelve percent about six years. Enter rate as percent points, not as a decimal fraction — eight means eight percent per year, not zero point zero eight. The engine is fully deterministic arithmetic with no network calls, no sampling, and no date-dependent shortcuts, so the same rate always yields the same years figure.
Where doubling estimates fit in study, planning, and software
Students meet the rule of 72 when a textbook introduces compound interest without full logarithms, when a personal-finance unit asks how long savings take to double at a stated return, or when a contest problem wants a quick order-of-magnitude check. Teachers can pre-generate answer keys for modest rates without trusting opaque calculator apps that silently switch between percent and decimal forms.
Developers call the same contract from scripts to seed deterministic test vectors for portfolio demos, to normalize user-entered growth rates before showing a doubling timeline, or to satisfy programming-challenge statements that demand the classic seventy-two-over-rate figure rather than a hand-waved guess. Product and education tools use the estimate when a learner types an annual percent and the UI must show years to double next to a chart of compound growth. Pair it with 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
Personal finance doubling checks
Estimate how many years a savings balance or investment needs to double at a stated annual return before you dig into full compound-interest tables.
Classroom and contest drills
Generate reproducible years-to-double answers for homework keys, worksheets, and timed finance or algebra practice without logarithms.
FAQ
What does the rule of 72 calculator cost?
It is free in your browser on this page.
Is rate a percent or a decimal fraction?
Percent points. Enter 8 for 8% per year, not 0.08. The classic rule is years ≈ 72 / rate with rate in that form.
What happens if rate is zero or negative?
Zero or negative annual growth has no finite doubling time under the rule of 72.
Is this the exact compound doubling time?
No. It is the classic mental-math approximation years ≈ 72 / rate. Exact continuous or discrete doubling uses logarithms of one plus the growth factor.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
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/rule-of-72 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"rate":8}'const res = await fetch("https://api.kit.forhosting.com/life/rule-of-72", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"rate": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/rule-of-72",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"rate": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/rule-of-72", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"rate":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"rate":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/rule-of-72", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"rate": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.rule_of_72",
"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_rate | 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 personal finance checks, classroom demos, and quick compound-growth intuition, or call the API at $0.002 per successful request when you need reproducible doubling estimates in CI, tutoring software, or product calculators.
What the rule of 72 means and what the response contains
The rule of 72 is a long-standing approximation for the doubling time of a quantity that grows at a constant annual percentage rate. If money or another value compounds near rate r percent per year, the number of years until it roughly doubles is seventy-two divided by r. The approximation is closest for moderate rates in the mid single digits to low teens and is meant for intuition, not for regulatory amortization schedules. This calculator returns the normalized rate you supplied, the computed years value rounded to the requested precision, a method tag rule_of_72, a short formula string reminding that years is approximately seventy-two over rate in percent, and the precision used. There is no Monte Carlo path and no market data fetch: the engine either divides seventy-two by a positive finite rate or rejects the input with invalid_input. Rejected cases include a missing rate, non-finite values, magnitudes above the documented ceiling, and any rate that is zero or negative, because a non-positive annual growth rate has no finite doubling time under this rule.
How rate is read and how years stay reproducible
Optional leading plus signs and scientific notation on rate 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 doubling time. The preferred field is rate for the annual growth rate in percent points, but aliases r, percent, annual_rate, growth_rate, interest_rate, and pct are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Rate must be strictly positive: if it is zero, negative, or numerically at or below a tiny epsilon, the request fails with invalid_input because division by zero or a negative denominator is not a valid rule-of-72 estimate. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for rate and years, 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 division yourself.
Where doubling estimates fit in study, planning, 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 product fixtures
Seed unit tests, property checks, and CI assertions with stable rule-of-72 outputs for portfolio UIs and growth calculators.