ForHosting KIT · Engineering & construction

Rocket thrust calculator

An engine expelling 250 kg of propellant per second at 3000 m/s produces 750,000 N of thrust. Enter the mass flow rate and the effective exhaust velocity to get ideal thrust in newtons for homework, lab checks or a first sizing. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Mass flow rate: 250
Exhaust velocity: 3,000

You get

Thrust: 750,000
Thrust newtons: 750,000
Thrust class: positive

A rocket thrust calculator turns the ideal momentum relation force equals mass-flow times exhaust velocity into a practical tool for homework, lab checks, and first-pass propulsion sizing. Zero on either input is allowed and yields zero thrust, matching the ideal model when the engine is off or the exit speed is zero.

Thrust as momentum leaving the nozzle

In the simplest ideal rocket model, thrust is the rate at which momentum leaves the vehicle through the nozzle. Every second a certain mass of propellant is thrown backward at the effective exhaust velocity, and the product of the two is the force that pushes the rocket forward. With 250 kilograms per second leaving at 3000 metres per second, that is 750,000 newtons. The units work out neatly: kilograms per second times metres per second gives kilogram metres per second squared, which is exactly one newton. Zero on either input is allowed and gives zero thrust, which is what you expect when the engine is off or the exhaust is not moving.

What this calculation leaves out

The result is ideal vacuum thrust. It ignores the extra push or loss caused by the difference between nozzle exit pressure and outside air pressure, so it matches textbooks only when that term is neglected or the nozzle is perfectly expanded. It also does not convert specific impulse in seconds into an exhaust velocity, and it does not work out how much speed a vehicle gains with the rocket equation: those are separate questions. Use one consistent set of units for both inputs, because mixing them still gives a number but no longer one in newtons. Negative values are refused instead of producing a misleading backward force.

What rocket thrust really means

In the simplest ideal rocket model, thrust is the rate at which momentum leaves the vehicle through the nozzle. In SI units, kilograms per second times metres per second yields newtons: one newton is one kilogram metre per second squared. Effective exhaust velocity already folds in nozzle efficiency conventions used in introductory propulsion courses; it is not always identical to the geometric exit speed of the gas, but it is the number that multiplies mass flow to give thrust in this ideal formula.

Mass flow rate is non-negative because mass cannot flow backward through the nozzle in this model; exhaust velocity is treated as a non-negative magnitude along the thrust axis for the same classroom contract. When either quantity is zero, thrust is zero. The calculator never rearranges multi-stage vehicle mass ratios, never solves the Tsiolkovsky equation for delta-v, and never converts seconds of specific impulse into metres per second; those problems share propulsion vocabulary but answer different search queries.

FAQ

What formula does the rocket thrust calculator use?

In SI units the product is thrust in newtons.

Can either input be zero?

Yes. Zero mass flow or zero exhaust velocity yields zero thrust and is accepted as a valid ideal-model edge case.

Does this convert specific impulse or solve the rocket equation?

No. This landing only multiplies mass flow by exhaust velocity.

Is the rocket thrust calculator free?

The browser tool is free and runs locally.

What is effective exhaust velocity?

It is the speed that, multiplied by the mass flow, gives the thrust in this ideal formula. It already includes the nozzle efficiency conventions of introductory courses, so it is not always the same as the gas's geometric exit speed.

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

POSThttps://api.kit.forhosting.com/mech/rocket-thrust

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/rocket-thrust \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mass_flow_rate":250,"exhaust_velocity":3000}'

const res = await fetch("https://api.kit.forhosting.com/mech/rocket-thrust", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "mass_flow_rate": 250,
    "exhaust_velocity": 3000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/mech/rocket-thrust",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "mass_flow_rate": 250,
    "exhaust_velocity": 3000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/rocket-thrust", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"mass_flow_rate":250,"exhaust_velocity":3000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"mass_flow_rate":250,"exhaust_velocity":3000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/rocket-thrust", 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_flow_rate": 250,
  "exhaust_velocity": 3000
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "mech.rocket_thrust",
  "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

Per request$0.002

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

Enter the exhaust mass flow rate ṁ in kilograms per second and the effective exhaust velocity v_e in metres per second; the tool multiplies them and returns thrust in newtons together with unit hints, a short formula string, and a thrust class of zero or positive. Negative mass flow or negative exhaust velocity is rejected with invalid_input so incomplete or nonsensical forms never invent a force. Pricing is a flat $0.002 per successful API request; failed validation is never charged. This page does not convert specific impulse, solve the rocket equation for delta-v, or add atmospheric pressure-area terms; those are separate search intents.

What rocket thrust F = ṁ × v_e means

If propellant leaves at effective exhaust velocity v_e relative to the vehicle and the exhaust mass flow rate is ṁ, the momentum flux is ṁ times v_e, which has the dimensions of force. Textbooks write F equals ṁ v_e for vacuum thrust when pressure terms are neglected, or when the nozzle is perfectly expanded so the pressure-area contribution is zero. When either quantity is negative, the calculator rejects the request rather than returning a signed force that would mislead homework and auto-graders. Keep ṁ and v_e in one consistent unit system end to end so the numeric product still means newtons when you claim SI, or your chosen force unit when you scale both inputs together.

How to call the API and what comes back

Send a JSON body with two required finite fields: mass_flow_rate (aliases mdot, m_dot, mass_flow) and exhaust_velocity (aliases ve, v_e, v_exhaust, exhaust_speed). Both must be finite numbers; missing fields, empty strings, NaN, and Infinity fail with invalid_input naming the field. Negative mass_flow_rate or negative exhaust_velocity also fail with invalid_input and a message that states the non-negative requirement for rocket thrust. On success the response echoes cleaned mass_flow_rate and exhaust_velocity, returns thrust and thrust_newtons as the product in newtons under SI assumptions, sets thrust_class to zero or positive, provides a units object naming kilograms per second, metres per second, and newtons, sets method to rocket_thrust_mdot_times_ve, and includes the short formula string F equals ṁ times v_e for display. Classic textbook checks include ṁ equals two hundred fifty kilograms per second and v_e equals three thousand metres per second for seven hundred fifty thousand newtons, ṁ equals ten and v_e equals two thousand for twenty thousand newtons, and a zero mass-flow case that correctly yields zero thrust. Prefer JSON numbers when you control the client; numeric strings that parse as finite values are accepted for homework-form paste paths. Pricing is a flat $0.002 per successful request with unit item; validation failures do not consume prepaid balance.

Practical tips, limits, and related searches

Use one consistent unit system before calling: kilograms per second and metres per second for thrust in newtons is the default interpretation of the unit hints, but the math is a pure product, so scaled pairs stay coherent if you document the force unit yourself. Prefer this capability when you already know exhaust mass flow and effective exhaust velocity and only need ideal momentum thrust; if your source problem gives thrust and one of the two factors, rearrange offline or use a general algebra tool. Convert specific impulse in seconds to effective exhaust velocity with v_e equals I_sp times g_0 only outside this calculator if your source data is given in seconds; this landing does not perform that conversion so it stays focused on the F equals ṁ v_e search intent. Do not expect atmospheric correction: full nozzle thrust often includes an extra term left parenthesis p_e minus p_a right parenthesis A_e; if you need sea-level versus vacuum thrust with pressure and area, use a dedicated pressure-thrust or nozzle calculator rather than overloading this page. Pair classroom examples deliberately: positive flow and speed for a nominal engine, zero flow for an off engine, and a deliberate negative input to demonstrate the hard invalid_input path. This page targets people searching for a rocket thrust calculator, mass-flow times exhaust velocity, or thrust in newtons from ṁ and v_e; it is not a rocket equation solver for delta-v, not a specific-impulse converter, and not a multi-engine stacker. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send negative values. Round-trip checks are easy: recompute ṁ times v_e by hand and confirm it equals the published thrust within the same cleaning used in the response.

Integration use cases

Homework checks for ideal rocket thrust

Students enter exhaust mass flow rate and exhaust velocity from textbook propulsion problems and compare the newton result against a deterministic F = ṁ × v_e oracle.

First-pass engine sizing scripts

Propulsion notebooks convert known ṁ and v_e into ideal thrust fixtures for stage budgets before adding pressure-area or multi-engine models.

Auto-graders and golden tests

Generate known-good thrust cases plus deliberate negative-input rejections for coding kata expected values in sims and LMS plugins.

Technical questions

What happens if mass flow rate or exhaust velocity is negative?

The tool returns invalid_input. Ideal rocket thrust requires non-negative ṁ and non-negative v_e; negative inputs are rejected and not billed.

Read the full KIT documentation →

Run — free