EPF calculator
A monthly salary of 50,000 with 12% from you and 12% from your employer, over 20 years at 8.25%, builds an EPF corpus of 7,077,837.34, of which 4,197,837.34 is interest. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Salary
- 50,000
- Employee rate
- 12
- Employer rate
- 12
- Years
- 20
- Interest rate
- 8.25
- Monthly contribution
- 12,000
- Annual contribution
- 144,000
- Total contribution
- 2,880,000
- Corpus
- 7,077,837.34
The Employee Provident Fund (EPF) is a defined-contribution retirement scheme in which a share of monthly salary is credited each month to a member account and that running balance earns a published annual interest rate until retirement or withdrawal. An EPF calculator answers a planning question that a generic compound-growth tool does not name: given a monthly salary, the employee and employer contribution rates that actually credit the provident-fund account, a whole number of years of service, and an annual interest rate, what corpus stands in the account at retirement? This capability takes those five inputs, applies the standard year-end EPF identity that each year the opening balance grows at the stated rate while twelve monthly deposits plus a 6.5-month equivalent of interest on those deposits are added, and returns the projected corpus together with the monthly and lifetime contributions and the interest earned.
What an EPF retirement corpus means and how the balance is built
The Employee Provident Fund is a defined-contribution account whose balance at retirement is the corpus of monthly employee and employer credits, grown at a statutory or assumed annual interest rate for every completed year of service. Unlike a one-shot lumpsum that compounds in a single exponent, an EPF account receives a fresh deposit every month: the monthly contribution is salary times the sum of the employee and employer rates, each expressed as a percent of that monthly salary.
Interest is not paid on a day-count of each deposit the way a savings-bank product might; the conventional EPF year-end identity used by planners and by this calculator credits interest once per year of service.
Opening balance grows at the annual interest rate, twelve monthly deposits are added, and in-year deposits are treated as earning the equivalent of six and a half months of interest — the 6.5 factor is the average of twelve deposits that sit in the account for twelve months down to one month if they are treated as being made at the start of each month.
Algebraically, if r is the interest rate as a decimal and M is the monthly contribution, each year adds M times (12 plus 6.5 r) on top of multiplying the opening balance by (1 plus r). Starting from a zero opening balance, the closed form after a whole number of years is that yearly addend times ((1 plus r) raised to years minus one) divided by r, or simply the addend times years when the interest rate is zero.
The response reports that corpus after half-up rounding to two decimals, together with the monthly contribution, the lifetime total of deposits, and the interest earned as corpus minus those deposits. A worked example: a monthly salary of fifty thousand with twelve percent employee and twelve percent employer rates contributes twelve thousand a month; at eight point two five percent for one year the corpus is one hundred fifty thousand four hundred thirty-five, of which six thousand four hundred thirty-five is interest.
What you can do with it
Retirement corpus planning
Turn a monthly salary, employee and employer EPF rates, years of service, and an annual interest rate into the projected corpus and interest earned for articles, planners, and landing-page widgets.
Employee versus employer share scenarios
Quote the corpus when the employer credits a full twelve percent versus only the provident-fund share after a pension split, without opening a spreadsheet for each mix.
FAQ
What happens if salary is not positive?
Zero, negative, missing, and non-finite salary values are not accepted; enter a monthly salary strictly greater than zero. Failed validation is not billed.
Are contribution rates and the interest rate percents or decimal fractions?
Enter them as percent points, not as decimal fractions — twelve means twelve percent of salary, and 8.25 means eight point two five percent a year, not 0.12 or 0.0825. The engine divides by one hundred before compounding.
How is the EPF balance at retirement calculated?
Each month, salary times the two contribution rates goes into the account. Once a year, the opening balance grows at the interest rate, and the twelve new deposits earn the equivalent of six and a half months of interest.
Why does the EPF formula use six and a half months of interest?
Because deposits arrive throughout the year. If each one is treated as made at the start of its month, the twelve deposits stay in the account between twelve months and one month, which averages six and a half.
Which employer rate should I enter?
Only the part that actually credits the EPF account, as a percent of monthly salary. Enter 12 if the full employer share goes in, or 3.67 if the pension share is excluded.
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/fin/epf \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"salary":50000,"employee_rate":12,"employer_rate":12,"years":20,"interest_rate":8.25}'const res = await fetch("https://api.kit.forhosting.com/fin/epf", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"salary": 50000,
"employee_rate": 12,
"employer_rate": 12,
"years": 20,
"interest_rate": 8.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/epf",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"salary": 50000,
"employee_rate": 12,
"employer_rate": 12,
"years": 20,
"interest_rate": 8.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/epf", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"salary":50000,"employee_rate":12,"employer_rate":12,"years":20,"interest_rate":8.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"salary":50000,"employee_rate":12,"employer_rate":12,"years":20,"interest_rate":8.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/epf", 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,
"employee_rate": 12,
"employer_rate": 12,
"years": 20,
"interest_rate": 8.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.epf",
"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
A salary that is not strictly positive fails with invalid_input instead of inventing a reverse-pay or zero-pay story.
Input contract, response shape, and error behaviour
Contribution rates and the interest rate must lie between zero and one hundred inclusive; a zero interest rate is valid and yields a corpus equal to the lifetime deposits. Pair the result with your own salary-hike schedule if you need stepped pay; start here when the product question is a transparent, five-input EPF retirement corpus for a page, a worksheet, or a batch of service-year scenarios that already share one salary and one interest assumption. POST a JSON body with five required fields: salary (the monthly pay that contribution rates apply to, a finite number strictly greater than zero; aliases monthly_salary, basic, wage), employee_rate (the employee contribution as a percent such as twelve for twelve percent of salary; aliases employee, ee_rate), employer_rate (the employer contribution that actually credits the EPF account as a percent; aliases employer, er_rate), years (years of service as a positive integer from one to sixty; aliases service, tenure, n), and interest_rate (the annual interest rate as a percent such as eight point two five; aliases rate, interest, annual_rate). 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. On success the body echoes salary, employee_rate, employer_rate, years and interest_rate; returns monthly_contribution, annual_contribution and total_contribution; returns corpus and interest_earned rounded half-up to two decimals; and includes a short formula string restating the closed form. If the employer twelve percent is split between a pension scheme and the provident fund, pass only the EPF share as employer_rate so the corpus is not inflated by money that never entered the account.
Where an EPF calculator earns its keep
Educators teaching defined-contribution retirement can seed classroom examples that show fifty thousand a month at eight point two five percent for one year versus twenty years, and can demonstrate the hard fail when someone types a zero or negative salary. Failed validation does not consume balance. Keep salary strictly positive, keep years a positive integer, pin the rounded corpus in tests, and you get reproducible Employee Provident Fund projections for widgets, CMS embeds, and edge workers without standing up a spreadsheet service of your own. Payroll and HR teams comparing take-home pay with long-run savings can post the same basic salary with twelve plus twelve versus twelve plus three point six seven (EPF share after a pension split) and read corpus and interest_earned 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.
Integration use cases
Classroom defined-contribution checks
Let students submit salary, rates, years, and interest_rate and verify the year-end EPF identity, including the hard fail when salary is not a positive number.
Technical questions
How is the EPF corpus at retirement calculated?
Monthly contribution M is salary times (employee_rate plus employer_rate) divided by one hundred. With r as interest_rate divided by one hundred, the corpus is M times (12 plus 6.5 r) times ((1 plus r) raised to years minus one) divided by r, or that addend times years when the interest rate is zero. Results are rounded half-up to two decimals.
Does the employer rate include the pension (EPS) share?
Only if you pass it. This calculator credits whatever employer_rate you send to the EPF account. If the employer twelve percent is split between a pension scheme and the provident fund, enter only the EPF share as employer_rate so the corpus is not inflated.
What does the EPF calculator cost?
The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.