Latent heat calculator
Melting 0.5 kg of ice with a latent heat of 334000 J/kg takes 167000 J. Enter the mass that changes phase and its latent heat of fusion or vaporization, and the energy of that phase change comes back in joules. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Mass
- 0.5
- Latent heat
- 334,000
- Q
- 167,000 J
- Precision
- 10
This latent heat calculator finds the thermal energy absorbed or released during a pure phase change when you know the mass of the substance and its specific latent heat of fusion or vaporization. The definition is the closed form Q equals m times L, which is the standard introductory model used in thermodynamics homework, calorimetry problems, and first-order engineering heat-load checks. When mass is given in kilograms and L in joules per kilogram, the result is reported in joules; any consistent mass and energy-per-mass pair works the same way. Zero mass is valid and yields zero energy; negative mass is rejected because it has no physical meaning in this model. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What latent heat means and what you get back
During a pure phase change at constant temperature and pressure, the energy exchanged with the surroundings is proportional to the mass of material that changes phase. The constant of proportionality is the specific latent heat L: for melting or freezing it is the latent heat of fusion, and for boiling or condensation it is the latent heat of vaporization. The defining relation is Q equals m times L.
Mass is the amount of substance that actually changes phase, and L is an intensive material property usually tabulated in joules per kilogram (or kilojoules per kilogram after a unit conversion you perform yourself). Positive Q with positive L in the usual homework convention means energy absorbed during melting or vaporization; the same formula with a sign convention you choose can represent energy released during freezing or condensation.
Latent heat is not the same as sensible heat from a temperature change: there is no c·ΔT term in this calculator, only the isothermal phase-change contribution. Zero mass is valid and yields zero Q when L is finite.
Where phase-change energy fits in study, design, and software
Students meet Q equals m L when a textbook introduces latent heat, when a calorimetry problem asks how much energy melts a known mass of ice, or when a contest problem gives mass and a tabulated latent heat and asks for joules without a multi-stage heating curve. Teachers can pre-generate answer keys for modest mass and L values without trusting opaque calculator apps that silently switch units or confuse latent heat with specific heat.
Developers call the same contract from scripts to seed deterministic test vectors for thermal simulators, to normalize user-entered phase-change loads before a process sketch, or to satisfy programming-challenge statements that demand joules rather than a hand-waved estimate. Process and product first-order checks use Q equals m L when only mass and a known latent heat are available before safety factors, heat losses, or multi-phase mixtures are modeled.
What you can do with it
Homework and lab checks
Compute Q = mL from mass and latent heat of fusion or vaporization before grading worksheets or calorimetry labs.
Process and tutoring software
Normalize user-entered mass and L into joules for heat-load sketches, tutoring UIs, and interactive lessons.
FAQ
What does the latent heat calculator cost?
It is free in your browser on this page.
How is Q defined?
For a pure phase change, Q = m · L, where m is mass and L is the specific latent heat of fusion or vaporization. With SI units (kg and J/kg) Q is in joules.
What happens if mass is negative?
Negative mass is not accepted; phase-change energy Q = m·L is undefined for negative mass in this calculator.
Does this tool look up latent heat for a material?
The calculator only multiplies mass by the value you supply.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
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/thermo/latent-heat \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mass":0.5,"latent_heat":334000}'const res = await fetch("https://api.kit.forhosting.com/thermo/latent-heat", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mass": 0.5,
"latent_heat": 334000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/thermo/latent-heat",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mass": 0.5,
"latent_heat": 334000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/thermo/latent-heat", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mass":0.5,"latent_heat":334000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mass":0.5,"latent_heat":334000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/thermo/latent-heat", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"mass": 0.5,
"latent_heat": 334000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "thermo.latent_heat",
"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.
Limits
max_abs_mass | 1000000000000000 |
max_abs_latent_heat | 1000000000000000 |
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
You supply L yourself—for example about 334000 J/kg for ice melting or about 2.26e6 J/kg for water boiling at atmospheric pressure—so the same endpoint covers fusion, vaporization, or any tabulated latent heat without hard-coded material tables.
What latent heat means and what the response contains
This calculator returns the normalized inputs mass and latent_heat, the computed Q, the precision used, a method tag latent_heat, a short formula reminder, and a unit hint J for SI inputs. There is no automatic material lookup, no multi-step heating curve, and no Monte Carlo sampling: the engine either evaluates the product inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing mass or latent heat, non-finite values, magnitudes above the documented ceilings, and any mass that is negative, because negative mass is not accepted in this calculator.
How mass and latent heat are read and how Q stays reproducible
Zero mass is allowed and returns zero Q. You choose the sign and magnitude of L; common textbook values include roughly 3.34 times ten to the five joules per kilogram for water ice melting and roughly 2.26 times ten to the six joules per kilogram for water boiling, but the tool never invents a material default. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens are rejected. The preferred field for mass is mass, but aliases m and M are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Mass must be finite and non-negative: a negative value fails with invalid_input and a message that names the field and explains that Q equals m times L is undefined for negative mass in this calculator, so a bad cell does not become a silent nonsense result. The preferred field for specific latent heat is latent_heat, with aliases L, l, latent, heat_of_fusion, heat_of_vaporization, Lf, and Lv so fusion and vaporization tables map cleanly. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the phase-change formula yourself.
Where phase-change energy fits in study, design, and software
Product and education tools use the endpoint when a learner types mass and L and the UI must show the phase-change energy. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with other thermo or mechanics helpers when you need related energy steps, and with math endpoints when you are building a small lab of free, deterministic physics calculators.
Integration use cases
Deterministic test fixtures
Generate reproducible phase-change energies for unit tests, thermal demos, and CI assertions on Q = m·L.