ForHosting KIT · Finance & money

ELSS calculator

100,000 invested in an ELSS fund at an expected 12% a year grows to 176,234.17 after 5 years, a gain of 76,234.17, with the units locked for the first 3 years. Enter the lumpsum, the expected return and the years. 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

Principal amount: 100,000
Annual return: 12
Years: 5

You get

Lock in years: 3
Maturity value: 176,234.17
Gain: 76,234.17

Equity Linked Savings Scheme (ELSS) funds are Indian equity mutual funds that qualify for a Section 80C deduction and carry a three-year statutory lock-in — the shortest lock-in among common 80C options. An ELSS calculator answers a planning question that a generic compound-growth tool does not name: given a lumpsum principal, an expected annual return as a percent, and a whole number of years invested, what is the projected maturity value when that lumpsum compounds once a year? This capability takes those three inputs, applies the identity that maturity value equals principal times one plus the expected annual return divided by one hundred, raised to the tenure in years, and returns the projected value together with the absolute gain and the three-year lock-in constant.

What an ELSS fund is and why the lock-in matters

An Equity Linked Savings Scheme is an Indian equity mutual fund that qualifies for a deduction under Section 80C. Money placed in it is held by a statutory lock-in of three years, the shortest among the common 80C options. In planning, the lumpsum is then grown at an expected annual return rather than at a bank deposit rate. This calculator projects that growth so you can quote the value at the end of the lock-in and at a later exit from the same principal and return, without building a spreadsheet for each scenario.

How the projection is worked out

Each year the balance is multiplied by one plus the expected return divided by 100. After five years at 12%, 100,000 becomes 176,234.17, a gain of 76,234.17. With an expected return of zero the factor is one and the maturity equals the principal. The years must be a whole number from 1 to 100, and the return is a percent, so 12 means 12% a year. The result is a projection built on the return you enter, compounded once a year.

What you can do with it

80C lumpsum planning

Turn an ELSS lumpsum, an expected annual equity return, and a whole-year tenure into the projected maturity and the absolute gain for articles, planners, and landing-page widgets.

Lock-in versus longer horizon

Quote the projected value at the three-year statutory lock-in and at a later exit from the same principal and expected return, without opening a spreadsheet for each scenario.

FAQ

What happens if the tenure is not a positive integer?

Zero, negative, and fractional years are not accepted; enter a whole number of years from 1 to 100. Failed validation is not billed.

Is the expected annual return a percent or a decimal fraction?

The engine divides by one hundred before raising the factor.

How is the ELSS maturity value calculated?

The lumpsum is multiplied by one plus the expected annual return divided by 100, once for each whole year invested. The gain is that maturity value minus the amount you put in.

What does the three-year lock-in mean for the result?

ELSS units cannot be redeemed during a statutory three-year lock-in, the shortest among common Section 80C options. Entering 3 years shows the projected value on the first date the units can be redeemed.

Does it work for monthly SIP investments?

No. It projects a single lumpsum that compounds once a year. For a monthly SIP, combine this result with your own schedule of contributions.

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/elss

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/elss \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":100000,"annual_return":12,"years":5}'

const res = await fetch("https://api.kit.forhosting.com/fin/elss", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "principal": 100000,
    "annual_return": 12,
    "years": 5
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/fin/elss",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "principal": 100000,
    "annual_return": 12,
    "years": 5
},
)
task_id = res.json()["task_id"]

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

body := bytes.NewBufferString(`{"principal":100000,"annual_return":12,"years":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/elss", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "principal": 100000,
  "annual_return": 12,
  "years": 5
}

Example response

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

Tenure that is not a positive integer fails with invalid_input instead of inventing a fractional year or a reverse-time story.

What an ELSS lumpsum projection means and how maturity appears

An Equity Linked Savings Scheme is an equity mutual fund with a tax-saving wrapper: a lumpsum invested today is locked for three calendar years and, in planning models, is then grown at a stated expected annual return rather than at a bank deposit rate. When the expected return is zero the factor is one and the maturity equals the principal. When years is three — the statutory lock-in — the same identity gives the value at the first date the units can be redeemed. The maturity identity used here is annual compounding of that lumpsum: if the opening investment is principal and the expected annual return as a percent is annual_return, the multiplier for one year is one plus annual_return divided by one hundred. After a whole number of years that multiplier has been applied that many times, which is exactly (1 + annual_return/100) raised to years, and the projected maturity_value is principal times that factor. The absolute gain is maturity_value minus principal. A worked example: one hundred thousand growing at twelve percent a year for five years has maturity_value 176234.17 after half-up rounding to two decimals, so the gain is 76234.17.

Input contract, response shape, and error behaviour

Pair the result with your own SIP schedule if you need instalments along the way; start here when the product question is a transparent, three-input ELSS lumpsum projection for a page, a worksheet, or a batch of 80C scenarios that already share one expected return and one whole-year horizon. POST a JSON body with three required fields: principal (the lumpsum invested, a finite number greater than zero; aliases amount, investment, lumpsum), annual_return (the expected annual return as a percent such as twelve for twelve percent a year; aliases rate, expected_return, return), and years (the tenure as a positive integer from one to one hundred; aliases tenure, term, n). Each numeric 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 annual_return is less than or equal to negative one hundred percent, one plus r is not positive and the power is not a useful real factor, so that case is invalid_input as well. On success the body echoes principal, annual_return and years; reports lock_in_years as three; returns maturity_value and gain rounded half-up to two decimals; and includes a short formula string restating the identity.

Where an ELSS calculator earns its keep

Educators teaching the difference between a lock-in and a compounding horizon can seed classroom examples that show one hundred thousand at twelve percent for five years versus the same lumpsum at the statutory three-year exit, and can demonstrate the hard fail when someone types a fractional tenure. Failed validation does not consume balance. Advisors comparing ELSS with PPF, NSC, or a tax-saving fixed deposit can post the same principal and a conservative equity assumption, then read maturity_value at three years and at a longer horizon from one 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 expected return above negative one hundred percent, keep years a positive integer, pin the rounded maturity_value in tests, and you get reproducible ELSS projections for widgets, CMS embeds, and edge workers without standing up a spreadsheet service of your own.

Integration use cases

Classroom time-value checks

Let students submit principal, annual_return, and years and verify the compounded ELSS maturity, including the hard fail when the tenure is not a positive integer.

Technical questions

How is the maturity value of an ELSS lumpsum calculated?

Multiply the principal by (1 + annual_return/100) raised to the number of whole years. The result is maturity_value after half-up rounding to two decimals, together with the absolute gain and lock_in_years equal to 3.

Why does the response include lock_in_years if I can enter other tenures?

ELSS units are locked for three years by statute. The calculator still projects any positive integer horizon so you can see the value at lock-in or later; lock_in_years is the legal holding period, not a second formula.

What does the ELSS 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