CAGR calculator
Growing from 100 to 200 over 5 years is a compound annual growth rate of 14.8698%, the steady yearly rate behind a doubling. Enter start, end and years, or reverse the formula to find the final value, the starting value or the time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Starting value
- 100
- Ending value
- 200
- Years
- 5
- CAGR
- 0.148698
- CAGR (%)
- 14.8698
- Calculate
- CAGR
compound annual growth free
What CAGR tells you
The compound annual growth rate turns a start value, an end value and a number of years into one constant yearly rate. It is a geometric mean, not a simple average: the end value is divided by the start value, the result is raised to the power of one over the years, and one is subtracted. Multiplied by 100, that is the percentage. Doubling in five years, from 100 to 200, gives 14.8698% a year, the steady rate that would have reached the same end point if growth had been perfectly even.
Comparing investments and metrics over time
Because CAGR smooths uneven years into one equivalent rate, it lets you compare assets, revenue lines or user counts held over different spans on the same footing. A portfolio that jumped one year and stalled the next and one that grew steadily have the same CAGR if they start and end at the same values, so the figure tells you where you ended up, not how bumpy the road was. Use it to rank options by annualized growth, then look at the year-by-year path separately when risk matters.
Validation, rounding and edge cases
When a rate is involved the tool guards the base of the power, rejecting any cagr where 1+r is zero or negative, and the years solver additionally rejects a rate of exactly zero because dividing by ln(1) is undefined. The decimals parameter is an integer from 0 to 8 (default 4); the raw cagr field is deliberately rounded to decimals+2 so a percentage at four places keeps enough precision in the underlying rate.
What you can do with it
Investment return analysis
Turn a starting and ending portfolio value over a holding period into a single annualized growth rate you can compare across assets.
FAQ
What is the CAGR of 100 growing to 200 in 5 years?
0.148698 as a rate, or 14.8698 percent, matching (200/100)^(1/5)-1.
Can I find the future value from a growth rate?
Yes. Choose to solve for the end value and enter the start value, the rate and the number of years. The result is the start value times one plus the rate, raised to the number of years. You can solve for the starting value the same way.
How many years does it take to reach a target at a given rate?
Solve for the number of years instead: the calculator divides the logarithm of end over start by the logarithm of one plus the rate. A rate of exactly zero is refused, because with no growth no number of years would get you there.
Can the growth rate be negative?
Yes. If the end value is lower than the start, the result is a negative rate that describes the yearly shrinkage. A rate of minus 100 percent or below is refused, because one plus the rate must stay above zero.
How precise is the result?
You choose from 0 to 8 decimals, 4 by default. The rate itself keeps two extra places, so a percentage shown with four decimals, like 14.8698, still rests on enough precision underneath.
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/dev/cagr \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"begin_value":100,"end_value":200,"years":5}'const res = await fetch("https://api.kit.forhosting.com/dev/cagr", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"begin_value": 100,
"end_value": 200,
"years": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/cagr",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"begin_value": 100,
"end_value": 200,
"years": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/cagr", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"begin_value":100,"end_value":200,"years":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"begin_value":100,"end_value":200,"years":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/cagr", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"begin_value": 100,
"end_value": 200,
"years": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.cagr",
"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
Computes the compound annual growth rate from begin_value, end_value and years using (end/begin)^(1/years)-1, and can instead solve for end_value, begin_value or years when you set solve_for and supply the known cagr.
The CAGR formula
Because the rate is a geometric mean of annual growth rather than a simple average, it correctly smooths uneven year-to-year changes into one constant equivalent rate, which is exactly what makes CAGR the standard measure for comparing investments or metrics over multi-year spans. With the default solve_for of cagr the tool takes begin_value, end_value and years and returns the compound annual growth rate r as Math.pow(end/begin, 1/years) minus 1. It reports two forms: cagr, the raw rate rounded to your decimals plus two extra places, and cagr_percent, the same rate times 100 at your decimals. The worked example grows 100 to 200 over five years and returns cagr 0.148698 with cagr_percent 14.8698, the familiar doubling-in-five-years rate. The response also echoes begin_value, end_value, years and the solve_for you chose, so a single object fully documents the calculation.
Rearranging for any variable
Set solve_for to end_value, begin_value or years to run the formula in reverse, supplying cagr instead of the missing field. For end_value it returns begin_value times (1+r)^years; for begin_value it divides end_value by (1+r)^years; for years it computes ln(end/begin) divided by ln(1+r). The rate you pass in is read according to as_percent, which defaults to true, so a cagr of 10 means ten percent (r = 0.10); set as_percent to false to pass the rate directly as 0.10. This lets you answer projection questions, such as what a 100 stake becomes after five years at a given rate, or how many years a target takes at a known rate, all from the same endpoint. The output object always carries the completed begin_value, end_value, years and rate together regardless of which one you solved for.
Validation, rounding and edge cases
Inputs are checked per mode: begin_value must be a finite non-zero number, end_value must be finite, years must be finite and greater than zero, and for the default cagr mode negative begin or end values are rejected as unsupported.
Integration use cases
Forecasting a target
Set solve_for to end_value or years to project a future balance at an assumed rate, or find how long a goal takes at a known CAGR.
KPI growth reporting
Feed revenue or user counts through the API to report smoothed year-over-year growth in dashboards without hand-rolling the geometric mean.
Technical questions
Can I solve for the end value or the number of years?
Yes. Set solve_for to end_value, begin_value or years and pass the known cagr; the tool runs the formula in reverse.
Is cagr entered as a percent or a decimal?
It depends on as_percent (default true): 10 means ten percent. Set as_percent false to pass the raw rate like 0.10.
Are negative or zero values allowed?
begin_value cannot be zero, years must be positive, and the default cagr mode rejects negative values with a typed invalid_input error.
Is the browser tool free?
Yes, the widget is free (tier A). The API runs on prepaid KIT balance from $0.002, charging only successful tasks.