ForHosting KIT · Finance & money

Lifetime earnings calculator

A salary of 50,000 rising 3% a year adds up to 265,456.79 over 5 remaining working years, with 56,275.44 paid in the final year. See the total pay still ahead of you from three numbers. 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

Salary: 50,000
Raise: 3
Years: 5

You get

Raise decimal: 0.03
Lifetime earnings: 265,456.79
Last year salary: 56,275.44

Lifetime earnings is the cumulative pay still ahead of you: every annual salary from this year through the last remaining working year, with one constant raise applied once per year. Recruiters, candidates, household planners, and career counselors search for a lifetime earnings calculator because they already hold three planning numbers — current salary, an annual raise as a percent, and remaining working years — and they need that sum, not a single future paycheck and not a discounted present value. This tool compounds the raise across the remaining horizon, adds the resulting sequence of annual salaries, and returns the cumulative total together with the last-year salary when the horizon is at least one year.

What lifetime earnings means and how the cumulative figure appears

Lifetime earnings, in the sense this landing ranks for, is the sum of a sequence of annual salaries that starts at today's pay and grows at one constant annual raise until the remaining working years run out. It is not the salary you would earn in the last year alone — that single end-point is a future-salary projection — and it is not the present value of those paychecks after a discount rate.

If this year's salary is salary and the annual raise as a percent is raise, then the first remaining year pays salary, the second remaining year pays salary times one plus raise divided by one hundred, and the k-th remaining year pays salary times that growth factor raised to k minus one. Adding those n terms is a geometric series: when the raise is not zero, the closed form is salary times ((1 + raise/100) raised to years, minus one) divided by (raise/100).

When the raise is exactly zero every year pays the same amount, so the total is simply salary times years. A worked example: fifty thousand growing at three percent per year for five remaining working years sums year one at fifty thousand, year two at fifty-one thousand five hundred, and so on through year five, which totals 265456.79 after half-up rounding to two decimal places. Zero remaining years is an honest empty career: the cumulative is zero and last-year salary is omitted.

A negative raise models a constant pay cut and shrinks each later year, provided the raise stays above negative one hundred percent so that one plus r stays positive.

What you can do with it

Offer letters and remaining-tenure totals

Turn a current salary, a stated annual raise, and remaining working years into the cumulative career pay and the last-year salary for candidates, managers, and compensation explainers.

Household multi-year budgets

Sum every remaining paycheck across a five-, ten-, or thirty-year horizon from today's pay and a planned merit increase without opening a spreadsheet for each scenario.

Classroom geometric-series checks

Let students submit salary, raise, and remaining working years and verify the cumulative total, including the hard fail when the year count is negative.

FAQ

How are lifetime earnings calculated from salary, raise, and remaining working years?

Each remaining year k pays salary times (1 + raise/100) to the power k minus one. The cumulative is the geometric sum: salary times years when the raise is zero, otherwise salary times ((1 + raise/100)^years − 1) divided by (raise/100), after half-up rounding to two decimal places.

What happens if remaining working years is negative?

A negative remaining-year count is not accepted; enter zero or more working years for the cumulative. Failed validation is not billed.

Is the annual raise a percent or a decimal fraction?

Enter raise as percent points per year, not as a decimal fraction — three means three percent per year, not 0.03. The engine divides by one hundred before summing the geometric series.

What if the raise is zero, and what does zero remaining years return?

A negative raise models a constant pay cut as long as the raise is greater than −100%.

Are lifetime earnings the same as my salary in the final year?

No. Lifetime earnings add up every remaining year of pay. With 50,000 rising 3% over 5 years, the final year pays 56,275.44, while the total for all five years is 265,456.79.

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/fin/lifetime-earnings

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/fin/lifetime-earnings \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"salary":50000,"raise":3,"years":5}'

const res = await fetch("https://api.kit.forhosting.com/fin/lifetime-earnings", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "salary": 50000,
    "raise": 3,
    "years": 5
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/fin/lifetime-earnings",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "salary": 50000,
    "raise": 3,
    "years": 5
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/lifetime-earnings", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"salary":50000,"raise":3,"years":5}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"salary":50000,"raise":3,"years":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/lifetime-earnings", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "salary": 50000,
  "raise": 3,
  "years": 5
}

Example response

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

When remaining working years is negative the task fails with invalid_input instead of inventing a reverse-time career.

Input contract, response shape, and error behaviour

A negative salary is rejected for the same reason a paycheck cannot be a negative number. Pair the result with your own promotion ladder if you need changing percentages; start here when the product question is a transparent, three-input career total for a page, a worksheet, or a batch of offer scenarios that already share one raise and one remaining horizon. POST a JSON body with three required finite numbers: salary (the current annual pay that starts the sequence, zero or greater; aliases current_salary, current, amount, pay), raise (the fixed annual raise as a percent such as three for three percent per year; aliases annual_raise, raise_percent, rate, percent), and years (the remaining working years, greater than or equal to zero and at most one hundred; aliases working_years, remaining_years, n, horizon). Each field may arrive as a JSON number or as a numeric string. Missing fields, empty strings, booleans, and non-finite values fail with invalid_input naming the field and are not billed. If raise is less than or equal to negative one hundred percent, one plus r is not positive and the geometric factor is not a useful real number, so that case is invalid_input as well. On success the body echoes salary, raise and years; reports raise_decimal rounded half-up to eight decimals; returns lifetime_earnings rounded half-up to two decimal places as currency; includes last_year_salary (the pay in the final remaining year, equal to salary times (1 + raise/100) to the power years minus one) when years is at least one, omitted otherwise; and includes a short formula string restating the geometric-sum identity.

Where a lifetime earnings calculator earns its keep

Household budgets that ask whether a role can fund a twenty- or thirty-year plan can pin the cumulative next to savings and housing goals without opening a spreadsheet for each scenario. Educators teaching the difference between a last-year salary and the sum of every year along the way can seed classroom examples that show fifty thousand at three percent for five years as a geometric series, and can demonstrate the hard fail when someone types a negative remaining-year count. Failed validation does not consume balance. Candidates comparing two offers that differ in starting pay, raise policy, and expected tenure can post the same three numbers twice and quote a stable lifetime_earnings with a two-decimal currency contract. Because the implementation is tier A parse, every successful call costs the published $0.002 base price with no model tokens and no outbound network. Keep the raise above negative one hundred percent, keep remaining working years at zero or more, pin the rounded lifetime_earnings in tests, and you get reproducible career totals for widgets, CMS embeds, and edge workers without standing up a spreadsheet service of your own.

Technical questions

What does the lifetime earnings calculator cost?

The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free