Kinetic energy lost in collision calculator
When a 2 kg body at 4 m/s sticks to a 3 kg body at −2 m/s, 21.6 J of the 22 J of kinetic energy turns into heat, deformation or sound. Enter both masses and signed velocities to see the energy lost. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- M1
- 2
- V1
- 4
- M2
- 3
- V2
- -2
- Total mass
- 5 J
- Reduced mass
- 1.2
- Final velocity
- 0.4
- Ke initial
- 22
This kinetic energy lost in collision calculator reports how much mechanical energy disappears when two bodies stick together in a perfectly inelastic head-on collision. You supply the two masses and their initial one-dimensional velocities; the engine conserves momentum to obtain the shared final speed, compares initial and final kinetic energy, and returns the positive difference as energy lost to heat, deformation, or sound. An equivalent closed form uses reduced mass: KE lost equals one-half times mu times the square of the relative approach speed, with mu equal to m1 m2 over m1 plus m2. The result is fully deterministic with no network calls, no sampling, and no date-dependent shortcuts. Masses must be non-negative and the total mass must not be zero, or the common final velocity and energy loss are undefined.
What kinetic energy lost means in a perfectly inelastic collision
In a perfectly inelastic head-on collision the two objects stick together and move as one combined body after impact. Momentum along the line of motion is conserved if external impulses are negligible during the brief contact, so the sum of mass times velocity before the crash equals total mass times the shared final velocity after the crash. The difference is the kinetic energy lost, which textbooks associate with irreversible conversion into heat, permanent deformation, sound, or other non-mechanical channels.
The same loss can be written with the reduced mass mu equals m1 m2 over m1 plus m2 as one-half mu times open parenthesis v1 minus v2 close parenthesis squared, which is always non-negative for real masses and speeds and vanishes only when the relative velocity is zero.
This calculator reports that scalar energy loss together with the intermediate quantities that make the result auditable: normalized inputs, total mass, reduced mass, final velocity, initial KE, final KE, the precision used, a method tag, a formula reminder, and a unit hint of joules when masses are in kilograms and velocities in meters per second. Opposite-direction approaches use opposite velocity signs on the same axis; a body initially at rest simply has initial velocity zero.
Where energy-loss collision checks fit in study, design, and software
Students meet kinetic energy lost when a textbook introduces perfectly inelastic collisions, when a lab drops putty onto a cart and asks how much energy was not conserved, or when a contest problem couples momentum conservation with an energy-loss question after stick-together impact. Teachers can pre-generate answer keys for modest mass and velocity values without trusting opaque calculator apps that silently switch units or confuse elastic and inelastic cases.
Developers call the same contract from scripts to seed deterministic test vectors for game-physics demos, to normalize user-entered crash parameters before a free-body or deformation check, or to satisfy programming-challenge statements that demand the joules lost rather than a hand-waved sketch. First-order engineering and product checks use the formula when only masses and approach speeds are known and an upper-bound energy dissipation estimate is enough before modeling multi-axis loads or material plasticity.
What you can do with it
Homework and lab energy checks
Compute kinetic energy lost from two masses and initial speeds before grading worksheets or comparing to sensor-based energy estimates.
Tutoring and design software
Normalize user-entered masses and approach velocities for energy-loss lessons, crash demos, and interactive physics helpers.
FAQ
What does the kinetic energy lost in collision calculator cost?
It is free in your browser on this page.
How is kinetic energy lost defined?
Equivalently KE_lost = ½·μ·(v1−v2)² with μ = m1m2/(m1+m2). With masses in kg and velocities in m/s, energy is in joules (J).
What happens if total mass is zero?
Both masses zero (or total mass numerically zero) leaves the final velocity and energy loss undefined.
Does this tool model elastic collisions or restitution?
No. It only computes kinetic energy lost for a perfectly inelastic stick-together event. Use a different tool if you need elastic bounce speeds or a coefficient of restitution.
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/mech/kinetic-energy-lost-collision \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"m1":2,"v1":4,"m2":3,"v2":-2}'const res = await fetch("https://api.kit.forhosting.com/mech/kinetic-energy-lost-collision", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"m1": 2,
"v1": 4,
"m2": 3,
"v2": -2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/kinetic-energy-lost-collision",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"m1": 2,
"v1": 4,
"m2": 3,
"v2": -2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/kinetic-energy-lost-collision", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"m1":2,"v1":4,"m2":3,"v2":-2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"m1":2,"v1":4,"m2":3,"v2":-2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/kinetic-energy-lost-collision", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"m1": 2,
"v1": 4,
"m2": 3,
"v2": -2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.kinetic_energy_lost_collision",
"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
What kinetic energy lost means in a perfectly inelastic collision
Kinetic energy is not conserved: the initial kinetic energy is one-half m1 v1 squared plus one-half m2 v2 squared, while the final kinetic energy is one-half times total mass times v_f squared. There is no multi-body contact simulation and no coefficient of restitution path: the engine either evaluates the energy-loss formula inside the supported numeric range or rejects the input with invalid_input. Rejected cases include missing masses or velocities, non-finite values, magnitudes above the documented ceilings, negative mass, and any case where total mass is zero or numerically zero, because division by zero leaves no defined common final velocity or reduced mass.
How masses and velocities are read and how KE lost stays reproducible
Zero mass for one body is allowed when the other mass is positive; in that limit the reduced mass is zero and kinetic energy lost is zero because there is no second body to share momentum with. Both masses zero is rejected because total mass must not be zero. Velocities may be positive, negative, or zero to encode direction on a one-dimensional axis; the tool does not convert unit systems for you, so keep masses consistent with each other and velocities in a matching length-per-time unit so that energy is in joules or a consistent energy unit. 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 fields are m1 and m2 for the two masses and v1 and v2 for the two initial velocities, but aliases mass1, M1, and mass_1 for m1, mass2, M2, and mass_2 for m2, and velocity1, u1, vel1, V1 for v1 plus velocity2, u2, vel2, V2 for v2 are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Masses must be finite and non-negative: a negative mass fails with invalid_input and a message that names the field, so a bad cell does not become a silent nonsense result. 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 inelastic energy-loss formula yourself.
Where energy-loss collision checks fit in study, design, and software
Product and education tools use the endpoint when a learner types two masses and two speeds and the UI must show how much kinetic energy disappeared after a perfectly inelastic crash. 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 the inelastic common-velocity helper, elastic collision final speeds, kinetic energy, or weight-force tools when you need related mechanics, and with other math endpoints when you are building a small lab of free, deterministic physics calculators.
Integration use cases
Deterministic test fixtures
Generate reproducible KE-lost values for unit tests, game-physics demos, and CI assertions on stick-together collisions.