ForHosting KIT · Engineering & construction

Inelastic collision calculator

When a 2 kg cart at 3 m/s sticks to a 4 kg cart moving at −1 m/s, the pair moves on at 0.3333333333 m/s. Enter both masses and signed velocities to get the common final velocity, total mass and total momentum. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
M1
2
V1
3
M2
4
V2
-1
You get
Total mass
6 m/s
Total momentum
2
Final velocity
0.3333333333
Precision
10

This inelastic collision calculator finds the single common final velocity after two bodies stick together in a perfectly inelastic collision. Kinetic energy is not conserved in this model: only momentum is, which is exactly the textbook definition of a perfectly inelastic event. Velocities may be positive or negative to encode opposite directions on the line; masses must be non-negative, and the total mass must not be zero or the final velocity is undefined. The arithmetic is fully deterministic with no network calls, no sampling, and no date-dependent shortcuts.

What a perfectly inelastic collision is and what you get

A perfectly inelastic collision is the extreme case where the two colliding 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: the sum of m times v before the crash equals the total mass times the shared final velocity after the crash. Kinetic energy is not conserved; some or all of the lost kinetic energy appears as heat, deformation, or sound, but this calculator does not estimate those losses.

It only reports the kinematic outcome of the stick-together model. Opposite-direction approaches use opposite velocity signs on the same axis; a body initially at rest simply has initial velocity zero.

Where perfectly inelastic collisions fit in study, design, and software

Students meet stick-together collisions when a textbook introduces one-dimensional momentum, when a lab drops a putty ball onto a cart, or when a contest problem couples conservation of momentum with energy loss and asks only for the shared speed after 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 check, or to satisfy programming-challenge statements that demand a common final velocity rather than a hand-waved sketch. First-order engineering and product checks use the formula when only masses and approach speeds are known and a stick-together bound is enough before modeling deformation or multi-axis loads.

Homework and lab checks

Compute common final velocity from two masses and initial speeds before grading worksheets or comparing to motion-sensor data.

Tutoring and design software

Normalize user-entered masses and approach velocities for momentum lessons, crash demos, and interactive physics helpers.

What does the inelastic collision calculator cost?

It is free in your browser on this page.

What happens if total mass is zero?

Both masses zero (or total mass numerically zero) leaves the final velocity undefined.

Does this tool model elastic collisions or restitution?

No. It only computes the common final velocity 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.

How do I enter two bodies moving toward each other?

Give their velocities opposite signs on the same axis, for example 3 m/s for one body and −1 m/s for the other. A body that starts at rest simply has a velocity of zero.

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.

POSThttps://api.kit.forhosting.com/mech/inelastic-collision

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.

curl -X POST https://api.kit.forhosting.com/mech/inelastic-collision \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"m1":2,"v1":3,"m2":4,"v2":-1}'
{
  "m1": 2,
  "v1": 3,
  "m2": 4,
  "v2": -1
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "mech.inelastic_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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_abs_mass1000000000000000
max_abs_velocity1000000000000000
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

You supply the two masses and their initial velocities along a chosen one-dimensional axis; the engine applies conservation of momentum and returns v_f equals open parenthesis m1 times v1 plus m2 times v2 close parenthesis divided by open parenthesis m1 plus m2 close parenthesis.

What a perfectly inelastic collision means and what the response contains

Rearranging that identity gives the closed form v_f equals open parenthesis m1 v1 plus m2 v2 close parenthesis over open parenthesis m1 plus m2 close parenthesis. The response returns the normalized inputs m1, v1, m2, and v2, the total_mass m1 plus m2, the total_momentum m1 v1 plus m2 v2, the final_velocity v_f, the precision used, a method tag perfectly_inelastic_collision, a short formula reminder, and a unit hint m/s when masses are in kilograms and velocities in meters per second. There is no multi-body contact simulation and no coefficient of restitution path: the engine either evaluates the momentum quotient 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.

How masses and velocities are read and how v_f stays reproducible

Zero mass for one body is allowed when the other mass is positive, which simply reduces to the remaining body keeping its velocity. 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. 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-collision formula yourself.

Where perfectly inelastic collisions 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 the combined velocity 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 weight-force, friction-force, or average-acceleration helpers when you need related mechanics, and with other math endpoints when you are building a small lab of free, deterministic physics calculators.

Deterministic test fixtures

Generate reproducible v_f values for unit tests, game-physics demos, and CI assertions on stick-together collisions.

How is the common final velocity defined?

For a perfectly inelastic (stick-together) collision, v_f = (m1·v1 + m2·v2) / (m1 + m2). With masses in kg and velocities in m/s, v_f is in m/s.

Read the full KIT documentation →