ForHosting KIT · Finance & money

Lumpsum plus SIP calculator

Investing 100,000 today plus 5,000 a month at 12% a year grows to 1,480,232.14 in 10 years, from 700,000 actually put in. See what a lump sum and a monthly SIP build together over your horizon. 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

Lumpsum: 100,000
Sip: 5,000
Interest rate: 12
Duration: 10

You get

Months: 120
Monthly rate: 0.01
Lumpsum future value: 330,038.69
Sip future value: 1,150,193.45

A lumpsum plus SIP plan puts an initial amount to work on day one and then adds a fixed monthly contribution for the rest of the horizon. Mutual-fund investors, goal planners, and product teams ask the same question: if I invest L now and S every month at an expected annual return for t years, what is the corpus. This lumpsum plus SIP calculator accepts those four numbers—initial lumpsum, monthly SIP, annual return as a percent, and duration in years—and returns the total future value as the sum of the compounded lumpsum and the future value of the monthly SIP annuity. It does not quote a fund, convert currencies, schedule step-ups, or invert a target corpus into the SIP you would need.

What lumpsum plus SIP means and how the closed form works

A lumpsum is a single amount invested at the start of the horizon. A SIP, or systematic investment plan, is a constant monthly contribution invested for every month of that horizon. The two cash-flow shapes compound under the same expected annual return, but they do not share the same closed form, so adding them after the fact is the honest way to project a combined corpus.

Convert the annual percent to a monthly rate i by dividing by one hundred and then by twelve. The number of months n is twelve times the duration in years. The lumpsum grows as L times one plus i to the n, which is ordinary monthly compounding of a principal.

The SIP is treated as an ordinary end-of-month annuity: SIP times the quantity one plus i to the n, minus one, divided by i. When the expected return is zero the monthly rate is zero and that annuity ratio is undefined, so the SIP future value collapses to SIP times n, which is simply the cash you put in. The total future value is the sum of the two pieces.

Total invested is the lumpsum plus SIP times n, and gain is future value minus that cash. This landing is not a lumpsum-only compound-interest page, not a beginning-of-period annuity-due identity, and not an annual IRA contribution projector: those queries already have their own calculators.

What you can do with it

Windfall plus monthly SIP projections

Project the combined corpus of a bonus or existing lumpsum invested today together with a fixed monthly SIP at a stated annual return and duration.

Classroom and coaching oracles

Generate reproducible lumpsum-plus-SIP answer keys that split the future value into the compounded principal and the monthly annuity so learners can check each piece.

FAQ

How is lumpsum plus SIP future value calculated?

The lumpsum grows as L×(1+i)^n. The SIP is an ordinary end-of-month annuity SIP×[((1+i)^n−1)/i], or SIP×n when i is zero. The total future value is the sum of those two pieces.

Is the rate a percent or a decimal?

A percent. Send 12 for twelve percent per year. Sending 0.12 would be treated as twelve hundredths of a percent, not twelve percent.

What happens if duration is zero or negative?

Duration must be a positive number of years. Zero, negative, missing, or non-finite duration values are rejected and are not billed.

Does this include SIP step-ups or beginning-of-month contributions?

No. The SIP is a constant end-of-month amount for every month of the duration. Step-up SIPs and annuity-due (beginning-of-period) identities are different contracts.

Can I project only a lump sum or only a monthly SIP?

Yes. Either amount can be zero, so you can set the monthly SIP to zero for a pure lump sum, or the starting amount to zero for a pure SIP, with the same return and years.

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/lumpsum-plus-sip

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/lumpsum-plus-sip \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lumpsum":100000,"sip":5000,"rate":12,"duration":10}'

const res = await fetch("https://api.kit.forhosting.com/fin/lumpsum-plus-sip", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "lumpsum": 100000,
    "sip": 5000,
    "rate": 12,
    "duration": 10
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/fin/lumpsum-plus-sip",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "lumpsum": 100000,
    "sip": 5000,
    "rate": 12,
    "duration": 10
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/lumpsum-plus-sip", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"lumpsum":100000,"sip":5000,"rate":12,"duration":10}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"lumpsum":100000,"sip":5000,"rate":12,"duration":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/lumpsum-plus-sip", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "lumpsum": 100000,
  "sip": 5000,
  "rate": 12,
  "duration": 10
}

Example response

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

Duration must be strictly positive; a zero or negative horizon fails with invalid_input instead of a silent empty growth path.

Input contract, response shape, and error behaviour

Example: one hundred thousand lumpsum, five thousand monthly SIP, twelve percent, and ten years is one hundred twenty months at a one percent monthly rate and a combined future value of one million four hundred eighty thousand two hundred thirty-two point fourteen. Failed validation does not consume balance. POST a JSON body with four required finite numbers. lumpsum is the initial investment in one currency; aliases lump_sum, principal, and initial are accepted so spreadsheets can keep familiar column names, and the value must sit between zero and one trillion inclusive. sip is the recurring monthly contribution in the same units, with aliases monthly_sip, pmt, and monthly, also from zero through one trillion. Either cash-flow may be zero so you can project a pure lumpsum or a pure SIP on the same contract. rate is the expected annual return as a percent—twelve means twelve percent per year, not a decimal 0.12 unless you truly intend twelve hundredths of a percent; aliases annual_rate, expected_return, and return_rate map to the same field. rate must be greater than negative one hundred and at most one hundred so that one plus the monthly rate stays positive and the power stays finite. duration is the horizon in years, a finite positive number greater than zero and at most eighty; fractional years such as two point five are allowed, and aliases years, t, and time are accepted. If duration is missing, zero, negative, or otherwise not a positive finite number, the task fails with invalid_input naming duration; that is the contracted error and it is not billed. Each field may arrive as a JSON number or a numeric string. On success the body echoes lumpsum, sip, rate, and duration, reports months as twelve times duration and monthly_rate as the decimal i, and returns lumpsum_future_value, sip_future_value, future_value, total_invested, and gain rounded half-up to two decimal places for stable currency-style goldens, plus a formula string restating the closed form.

Where a lumpsum plus SIP API earns its keep

Households and mutual-fund investors use a lumpsum plus SIP calculator when a windfall, a bonus, or an existing corpus sits beside a monthly systematic plan and they need one number for the combined horizon. Personal-finance coaches need a deterministic oracle that rejects a non-positive duration instead of silently showing a zero corpus that a buggy form might treat as success. When you later need beginning-of-month annuity-due SIP or annual rather than monthly contributions, switch to those identities rather than stretching this four-field lumpsum-plus-monthly-SIP contract. Product teams wire the same contract into onboarding demos so a user who types a lumpsum, a monthly SIP, an expected percent, and a duration sees the identical future_value the API will later return in production tests. Keep requests small, pin rounded future_value and the two component future values in tests, and you get reproducible corpus figures for worksheets, LMS plugins, and edge workers without standing up a spreadsheet service of your own.

Integration use cases

Product demos and CI fixtures

Seed goal-planning apps and automated tests with deterministic future_value, total_invested, and gain that match the free browser widget byte-for-byte.

Technical questions

What does the lumpsum plus SIP calculator cost?

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

Read the full KIT documentation →

Run — free