Pool salt calculator
A 50,000-liter pool at 2,500 ppm that must reach 3,200 ppm has a 700 ppm gap and needs 35 kg of salt. Enter the volume, your reading and the level your salt cell asks for, and know how much to buy before you open a bag. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Volume
- 50,000
- Current salinity
- 2,500
- Target salinity
- 3,200
- Volume unit
- L
- Salinity unit
- ppm
- Delta ppm
- 700
- Salt kg
- 35
Saltwater swimming pools and salt-chlorine generators need a stable sodium chloride concentration, usually a few thousand parts per million, before the cell can make chlorine and the water feels right on the skin. Homeowners topping a winter-diluted basin, builders filling a new shell, and service routes all face the same arithmetic: given the basin volume in liters, the salinity you measure today, and the target the manufacturer printed on the cell, how many kilograms of pool salt must go in. This pool salt calculator applies the closed-form mass balance that one part per million is one milligram of salt per liter, so the add-mass in kilograms is volume times the salinity gap divided by one million. It refuses a target that is not strictly above the current reading, because dilution—not more salt—is the path when you overshoot.
How pool salt mass follows from volume and the salinity gap
Start from the definition of parts per million in water: one ppm of dissolved sodium chloride is one milligram of salt in each liter. Raising a basin by a known gap therefore means adding that many milligrams for every liter of water you actually have. A fifty-thousand-liter backyard pool that sits at two thousand five hundred ppm and must reach three thousand two hundred ppm has a seven-hundred-ppm gap and needs thirty-five kilograms of salt.
An eighty-thousand-liter new fill at zero ppm aimed at three thousand ppm needs two hundred forty kilograms. The same identity is what salt-cell manuals print as “kilograms of salt per thousand liters per thousand ppm,” just rewritten as a single multiply. Volume must be strictly positive; both salinity readings must be non-negative finite numbers.
Results are deterministic floating-point arithmetic with no random seeds, no wall-clock timestamps, and no network.
Where a pool salt calculator earns its keep, and what it will not do
Use the free browser tool when you are standing beside a salt-chlorine generator that will not run until the water sits in the manufacturer’s window, usually a few thousand parts per million, and you need a bag count before you tear open twenty-five-kilogram sacks. Limits are intentional. The calculator does not convert US gallons or cubic metres for you; send liters (one US gallon is about 3.785 liters; one cubic metre is one thousand liters).
It does not tell you how much water to drain when you overshoot—that is dilution, a different search and a different landing. It does not dose chlorine, cyanuric acid, or pH chemicals; a free-chlorine raise is a separate chlorine-dosage intent. It does not read a salt-cell model number or guess a factory default target.
Walk the salt around the shallow end, brush it off the floor, and run the pump until the reading stabilizes before you add a second increment.
What you can do with it
Bring a salt-chlorine cell into its operating window
Read today’s ppm, set the manufacturer’s target, enter the basin liters, and buy the exact kilograms of pool salt so the generator can start making chlorine.
Spring top-up after rain and splash-out
Winter rain and backwashing dilute salinity. Measure the new reading and compute the kilograms needed to climb back to the cell’s recommended band.
FAQ
What happens if the target salinity is not above the current reading?
Equal or lower targets need a retest or a dilution plan, not more bags.
What units should I use?
Volume is liters. Current and target salinity are in ppm, equivalent to mg/L.
How much salt raises 1,000 liters by 1,000 ppm?
Exactly 1 kg. One ppm is one milligram of salt per liter, so raising 1,000 liters by 1,000 ppm takes one million milligrams, which is the rule many salt-cell manuals print.
Does it also tell me the chlorine or pH dose?
No. It only works out the salt needed to reach your target salinity. Chlorine, stabiliser and pH chemicals are separate calculations with their own doses.
What if I already added too much salt?
Then the fix is to replace some water with fresh water, not to add anything. This calculator only works out salt to add, so it refuses a target that is not above your current reading.
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/life/pool-salt \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"volume":50000,"current_salinity":2500,"target_salinity":3200}'const res = await fetch("https://api.kit.forhosting.com/life/pool-salt", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"volume": 50000,
"current_salinity": 2500,
"target_salinity": 3200
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/pool-salt",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"volume": 50000,
"current_salinity": 2500,
"target_salinity": 3200
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/pool-salt", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"volume":50000,"current_salinity":2500,"target_salinity":3200}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"volume":50000,"current_salinity":2500,"target_salinity":3200}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/pool-salt", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"volume": 50000,
"current_salinity": 2500,
"target_salinity": 3200
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.pool_salt",
"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
How pool salt mass follows from volume and the salinity gap
Convert milligrams to kilograms by dividing by one million and you get the working identity this endpoint implements: salt_kg equals volume in liters times (target_salinity minus current_salinity) divided by one million. Target salinity must sit strictly above current_salinity—equal readings and a lower target are invalid_input, not a zero bag or a negative dose, because this calculator does not drain water. The primary output is salt_kg, accompanied by the echoed inputs, the computed delta_ppm, and a short formula string you can print on a delivery ticket.
Input contract, response shape, and error behaviour
Zero or negative volume fails because a physical basin cannot have that size. Negative salinity readings fail because a concentration cannot be below zero. Wire the free browser form for a patio bag count, then call the identical contract from scripts when you need multi-pool schedules. POST a JSON body with three required finite numbers: volume for pool water in liters, current_salinity for the present reading in parts per million, and target_salinity for the desired reading in the same units. Each field may arrive as a JSON number or as a numeric string. Volume also accepts the aliases vol, liters, litres, and pool_volume; current_salinity accepts current, current_ppm, and salinity; target_salinity accepts target, desired, desired_salinity, and target_ppm. Missing fields, empty strings, Infinity, and NaN fail with invalid_input naming the problem and are not billed. When target_salinity is not strictly greater than current_salinity the request fails with a message that the target is not above current salinity, so clients correct a test-kit typo or switch to a dilution workflow instead of receiving a negative bag count. On success the body echoes the three cleaned inputs, sets volume_unit to L and salinity_unit to ppm, returns delta_ppm as the raise, returns salt_kg as the kilograms to add, and restates the formula so a receipt can show the arithmetic. Example: volume fifty thousand, current_salinity two thousand five hundred, target_salinity three thousand two hundred yields delta_ppm seven hundred and salt_kg thirty-five. Successful API calls cost the published $0.002 per item; validation failures do not consume prepaid balance.
Where a pool salt calculator earns its keep, and what it will not do
Each successful request is one billable item at $0.002; failed validation does not consume balance. Pair salt_kg with your own bag size if you stock twenty-kilogram or twenty-five-kilogram sacks: this endpoint returns mass, not a package count, because bag sizes change by brand.
Integration use cases
New-fill start-up after plaster or a full drain
A freshly filled shell often sits near zero ppm. Convert volume and the start-up target into salt_kg so the first salt delivery matches the work order.
Technical questions
How do I calculate how much salt to add to a pool?
Send a positive volume in liters plus current_salinity and a higher target_salinity in ppm. The API returns salt_kg = volume × (target_salinity − current_salinity) / 1,000,000.
Does this tell me how much water to drain if I added too much salt?
No. Overshoot is a dilution problem. This endpoint rejects a target that is not above the current reading instead of inventing a drain volume.
What does the pool salt calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.