Accumulated depreciation calculator
Find how much of an asset has been written off so far: a machine that cost 50,000, with a salvage value of 5,000 and a ten-year life, has 18,000 of accumulated depreciation after 4 years and a book value of 32,000. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Cost
- 50,000
- Salvage value
- 5,000
- Useful life years
- 10
- Years elapsed
- 4
- Depreciable base
- 45,000
- Annual depreciation
- 4,500
- Accumulated depreciation
- 18,000
- Book value
- 32,000
No spreadsheet, no rounding surprises, and a clear error when the years elapsed exceed the useful life you declared.
What straight-line depreciation means
Straight-line is the simplest and most widely used depreciation method in financial accounting. The idea is that an asset loses value evenly over its useful life: a machine that cost 50,000 and will be worth 5,000 after ten years loses 4,500 of value every year, no more and no less. The accumulated depreciation at any point is simply that annual charge multiplied by the number of years the asset has been in service.
This accumulated depreciation calculator encodes exactly that rule. You provide four numbers — cost, salvage value, useful life in years and years elapsed — and it returns the accumulated depreciation, the annual depreciation charge, the depreciable base (cost minus salvage value) and the remaining book value.
How the computation works
The algorithm is a short, auditable sequence. First the depreciable base is computed as cost minus salvage value; that is the total amount that will ever be written off, because the salvage value is what you expect to recover at the end. Dividing the base by the useful life in years gives the annual depreciation charge.
Multiplying that charge by the years elapsed yields the accumulated depreciation, and subtracting it from the original cost gives the current book value. Every returned amount is rounded to the number of decimal places you request, two by default, so the output is stable byte for byte across machines.
What you can do with it
Automate the monthly close
Walk the fixed-asset register in a batch job and compute accumulated depreciation for every asset as of the reporting date, with no spreadsheets involved.
Recompute balances during an audit
Independently recalculate accumulated depreciation from the client's stated cost, salvage value and life to flag discrepancies against the ledger.
Quote a book value in an asset sale
Get the current book value of a vehicle or machine before listing it, using the same straight-line figures your accounting already relies on.
FAQ
Which depreciation method does it use?
Straight-line only: a constant annual charge equal to (cost minus salvage value) divided by the useful life in years. Other methods such as declining balance are intentionally out of scope.
What happens if years elapsed exceed the useful life?
Once an asset has reached the end of its useful life it is fully depreciated, and accumulated depreciation beyond the depreciable base has no meaning.
Can the salvage value be zero?
Yes. A zero salvage value means the entire cost is depreciated over the useful life. The salvage value may not, however, exceed the cost.
Does it accept fractional years?
Yes. Useful life and years elapsed are plain numbers, so 7.5 years elapsed over a 10-year life is a valid input.
Is any data stored?
No. The computation is stateless: the numbers you send are processed and discarded, and only the result is returned.
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/accumulated-depreciation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"cost":50000,"salvage_value":5000,"useful_life_years":10,"years_elapsed":4}'const res = await fetch("https://api.kit.forhosting.com/fin/accumulated-depreciation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"cost": 50000,
"salvage_value": 5000,
"useful_life_years": 10,
"years_elapsed": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/accumulated-depreciation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"cost": 50000,
"salvage_value": 5000,
"useful_life_years": 10,
"years_elapsed": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/accumulated-depreciation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"cost":50000,"salvage_value":5000,"useful_life_years":10,"years_elapsed":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"cost":50000,"salvage_value":5000,"useful_life_years":10,"years_elapsed":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/accumulated-depreciation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"cost": 50000,
"salvage_value": 5000,
"useful_life_years": 10,
"years_elapsed": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.accumulated_depreciation",
"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
The accumulated depreciation API answers one precise bookkeeping question: given what an asset cost, what it will be worth at the end of its useful life, how long that life is and how many years have already passed, how much value has been written off so far? It applies the straight-line method — the same constant charge every year — and returns the accumulated depreciation together with the annual charge, the depreciable base and the current book value, all in a single deterministic call.
What straight-line depreciation means
Because the method assumes a constant charge, the result depends only on your inputs, never on market data or estimates, which makes the endpoint fully deterministic and easy to test against.
How the computation works
Validation is strict on purpose: negative inputs are rejected, the salvage value may not exceed the cost, the useful life must be greater than zero, and if the years elapsed exceed the useful life the call fails with an invalid_input error, because at that point the asset is already fully depreciated and an accumulated figure beyond the depreciable base would be meaningless.
Where it fits in a workflow
A common pattern is a monthly close job that walks every asset in the register, computes its accumulated depreciation as of the reporting date, and posts the journal entries without anyone opening a spreadsheet. Auditors use it the other way around: they recompute the accumulated depreciation independently and compare it against the client's ledger to flag discrepancies. Teams use this endpoint wherever fixed-asset registers are maintained programmatically. Because the same code that runs on our edge also runs free in your browser on this page, you can check a single asset by hand before wiring the API into your pipeline, and you only pay when you automate it at scale. The endpoint holds no state between calls and stores nothing, so it is safe to use with confidential asset registers: you send four numbers, you get four numbers back, and nothing is kept.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.