IRA growth calculator
Project what your IRA could be worth: 10,000 today plus 6,500 a year for 30 years at 7% grows to 690,117.66, of which 205,000 is money you put in. Works for traditional or Roth accounts with year-end deposits. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Annual contribution
- 6,500
- Years
- 30
- Rate percent
- 7
- Current balance
- 10,000
- Rate decimal
- 0.07
- Future value
- 690,117.66
- Total contributed
- 205,000
- Interest earned
- 485,117.66
An individual retirement account grows from two sources at once: the balance already inside the account, and the new contributions you add each year, both compounding at an expected annual rate of return. This IRA growth calculator projects that future balance with the closed-form identity used in textbooks and plan illustrations: the starting principal compounds as one plus r to the n, and the annual contribution stream grows as the ordinary-annuity future-value factor of one plus r to the n minus one, all divided by r, or simply contribution times years when the rate is zero. Enter the yearly contribution, the number of years, and the expected annual return as a percent; optionally include a current IRA balance. Results are educational projections, not tax advice or a promise of market returns.
What IRA growth means and how the projected balance is built
An IRA growth projection answers a single compounding question: if a traditional or Roth individual retirement account starts with a known balance, receives the same contribution at the end of every year, and earns a constant expected annual rate of return, what is the account worth after a chosen number of years.
That is a different search intent from a salary-multiple nest-egg check, a FIRE target from expenses, or a generic annuity-due table: people who type ira growth calculator want the IRA-shaped story of contribution limits, decades of compounding, and a split between money they deposited and money the market is assumed to add. Algebraically the terminal value is the sum of two closed forms. The current balance P rides for the full horizon, so it becomes P times (1+r) to the n.
Each annual contribution C is an ordinary (end-of-year) annuity, so the contribution stream becomes C times ((1+r) to the n minus one) divided by r. When the expected return is exactly zero there is no compounding, the annuity factor would divide by zero, and the identity collapses to P plus C times n — cash stacked, nothing grown.
A worked check is a ten-thousand starting balance, six thousand five hundred contributed each year, thirty years, and seven percent: the principal factor is about 7.612, the annuity factor is about 94.461, and the projected IRA sits near six hundred ninety thousand. Use this identity for long-run illustrations of traditional and Roth IRAs, SEP or SIMPLE annual deposits treated as a single year-end credit, and classroom TVM problems that ask for an IRA nest egg.
Do not use it for intra-year dollar-cost averaging, changing contribution limits, or sequence-of-returns risk — those need a period-by-period schedule, not a closed form.
Who projects IRA growth
Employers and benefits portals can project a payroll-deducted IRA or SEP contribution at a stated expected return so employees see the decades-ahead number next to this year's deposit. Classrooms and exam-prep generators need a deterministic oracle that handles a zero rate without dividing by zero, rejects an empty account, and returns the principal and contribution components separately. Keep requests small.
This tool does not apply IRS contribution limits, income-phaseout rules, required minimum distributions, inflation, taxes on traditional withdrawals, or Roth conversion math — it projects a constant-rate balance only. Pair it with your own tax or limit checks when the question is what you are allowed to deposit, not what a known deposit stream will grow into.
What you can do with it
Long-horizon traditional or Roth IRA illustration
Project the nest egg from this year's contribution limit, a starting balance, and a long-run expected return so a saver can see principal versus compounded growth.
Classroom and exam TVM checks
Verify textbook IRA future values, including the zero-rate stack of cash, without dividing by r or mixing ordinary contributions with annuity-due tables.
FAQ
Does this apply to both traditional and Roth IRAs?
Yes. The compounding identity is the same for traditional and Roth accounts. The difference is tax treatment on the way in and out, which this calculator does not model. Pass the contribution and balance you actually expect to sit in the account.
Are contributions assumed at the start or the end of each year?
At the end of each year (an ordinary annuity). That is the usual closed form in IRA growth illustrations. A beginning-of-year stream would earn one extra period of interest on every deposit and is a different identity.
What if the expected annual return is zero?
The solver uses that identity instead of dividing by r.
How much does my current balance add to the result?
The result shows the two parts separately. In the example, the 10,000 already in the account grows to 76,122.55 on its own, while 30 years of 6,500 contributions grow to 613,995.11.
Can I use it for changing contributions or market swings?
No. It assumes the same contribution at the end of every year and one constant return. Rising contribution limits, investing through the year or the order of good and bad years need a year-by-year schedule instead.
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/ira-growth \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"annual_contribution":6500,"years":30,"rate_percent":7}'const res = await fetch("https://api.kit.forhosting.com/finance/ira-growth", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"annual_contribution": 6500,
"years": 30,
"rate_percent": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/finance/ira-growth",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"annual_contribution": 6500,
"years": 30,
"rate_percent": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/ira-growth", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"annual_contribution":6500,"years":30,"rate_percent":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"annual_contribution":6500,"years":30,"rate_percent":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/ira-growth", 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_contribution": 6500,
"years": 30,
"rate_percent": 7
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "finance.ira_growth",
"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_years | 80 |
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
Input contract, formula, and response fields
Optionally set decimals to an integer from zero to eight for currency-style rounding; the default is two. Money-like fields use half-up rounding once from the raw floating-point results so goldens stay byte-stable across runtimes. POST a JSON body with three required finite numbers: annual_contribution, the yearly deposit (aliases contribution and contribution_amount), which must be greater than or equal to zero; years, a whole number of compounding years from one through eighty (aliases n and nper); and rate_percent, the expected annual return as a percent so that seven means seven percent per year, not a decimal fraction (aliases rate, expected_return, and return_rate). rate_percent must be greater than negative one hundred and at most fifty so that one plus r stays positive and (1+r) to the n stays finite. Optionally set current_balance (aliases balance, principal, starting_balance) to the IRA value already on the books; it defaults to zero and must be non-negative. At least one of annual_contribution or current_balance must be strictly positive — an empty account with no deposits cannot grow. The engine forms r as rate_percent over one hundred, compounds the principal as current_balance times (1+r) to the years, and grows the contribution stream as annual_contribution times ((1+r) to the n minus one) over r, or annual_contribution times years when r is zero. total_contributed is current_balance plus annual_contribution times years; interest_earned is future_value minus total_contributed; principal_future_value and contributions_future_value split the terminal balance so you can see how much came from money already saved versus new deposits. The response echoes the rounded inputs and those fields plus rate_decimal and a short formula string. Missing fields, empty strings, non-finite values, negative balances or contributions, non-integer or out-of-range years, a rate at or below negative one hundred or above fifty, and out-of-range decimals fail with invalid_input and are not billed.
Where an IRA growth calculator API earns its keep
Advisors and robo-onboarding flows use the endpoint as a first-pass illustration before collecting risk questionnaires: sweep years or rate_percent from your own code to build a family of scenarios, pin future_value and interest_earned in tests, and show how a higher contribution or a longer horizon changes the nest egg without standing up a full Monte Carlo engine.
Integration use cases
Advisor and benefits onboarding
Sweep years or rate_percent to build scenario tables for clients or employees without standing up a Monte Carlo engine or a spreadsheet per household.
Technical questions
How does the IRA growth calculator project the future balance?
With r = rate_percent/100 and n = years: future_value = current_balance × (1+r)^n + annual_contribution × [((1+r)^n − 1)/r]. When the rate is zero, future_value = current_balance + annual_contribution × years. The API also returns total_contributed, interest_earned, and the principal versus contribution components.
What does the IRA growth calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.