Projectile from height calculator
Throw at 20 m/s and 45 degrees from 10 m up and it lands 49.0821614194 m away after 3.4706329175 seconds under 9.81 m/s². Starting above the ground, the flight lasts longer than twice the climb. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Launch speed magnitude
- 20
- Angle
- 45
- Height
- 10
- Gravitational acceleration
- 9.81
- Angle deg
- 45
- Horizontal velocity
- 14.1421356237
- Initial vertical velocity
- 14.1421356237
- Flight time
- 3.4706329175
A projectile launched from a height above the landing plane is the natural next problem after ground-level range formulas: the vertical motion starts from a non-zero elevation, so flight time is no longer simply twice the time to the apex. Students, teachers, sports analysts, and game or robotics authors need the horizontal range and total flight time from launch speed, launch angle, and initial height under constant gravity—without reopening a textbook for the quadratic root every time.
What elevated projectile motion means and which quantities set the answer
In introductory two-dimensional kinematics, a projectile under constant gravity has constant horizontal velocity and vertical acceleration equal to minus g. When launch occurs from height h above the ground plane rather than from ground level, the vertical coordinate is written h plus v zero times sine of theta times t minus one half g t squared. Setting that equal to zero at landing yields a quadratic equation whose positive root is the flight time.
Search intent clusters around phrases such as projectile from height calculator, range of a projectile launched from a cliff, flight time elevated launch, and projectile motion with initial height. People want numeric range and time they can check against a worksheet, a sports trajectory estimate, a game physics sanity check, or a lab report—not only a derivation that the trajectory is a parabola.
How this calculator validates input and applies the range and flight-time formulas
Launch speed must be a finite non-negative number; angle must lie between minus ninety and ninety degrees so the launch direction is well defined relative to the horizontal axis used by this model; height must be a finite number that is not negative. Zero height recovers the classic ground-level flight time when angle is non-negative. Gravity, when provided, must be a positive finite number; when omitted, the engine uses the default standard Earth gravitational acceleration nine point eight zero six six five in SI-style units.
After validation, horizontal velocity is launch speed times cosine of the angle, initial vertical velocity is launch speed times sine of the angle, flight time is the positive root of the landing quadratic, and range is horizontal velocity times flight time. Edge cases are explicit: missing fields, non-numeric strings, non-finite values, negative speed or height, angle outside the allowed band, zero or negative gravity, and oversized magnitudes all fail before any kinematic result is returned.
There is no air resistance, no wind, and no Earth curvature—this is ideal constant-g planar projectile motion from an elevated launch.
What you can do with it
Homework and lab elevated-projectile drills
Students and graders confirm range and flight time for launches from a cliff or platform, including clear rejection when height is negative.
Game, sports, and robotics trajectory checks
Quick structured numbers for elevated spawn points, throw estimates, or briefing notes that need range without a full dynamics stack.
FAQ
What happens if height is negative?
Launch height above the landing plane must be non-negative; negative height is rejected and not charged.
What units should I use?
Any consistent set. For example metres, metres per second, and metres per second squared yield range in metres and flight time in seconds.
Is the projectile from height calculator free?
The browser tool runs free on your device.
Does this include air resistance?
No. The model is ideal planar projectile motion under constant g with no drag. Drag or wind would be a different product intent.
How is the flight time found?
The vertical position over time is written from the starting height and set to zero at landing. That gives a quadratic equation whose positive root is the flight time; the range is the horizontal speed multiplied by that time.
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/projectile-launch-from-height \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"launch_speed":20,"angle":45,"height":10}'const res = await fetch("https://api.kit.forhosting.com/mech/projectile-launch-from-height", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"launch_speed": 20,
"angle": 45,
"height": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/projectile-launch-from-height",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"launch_speed": 20,
"angle": 45,
"height": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/projectile-launch-from-height", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"launch_speed":20,"angle":45,"height":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"launch_speed":20,"angle":45,"height":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/projectile-launch-from-height", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"launch_speed": 20,
"angle": 45,
"height": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.projectile_launch_from_height",
"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
This capability accepts non-negative launch speed, an angle in degrees from the horizontal, a non-negative initial height, and optional gravity (defaulting to standard Earth g), rejects negative heights with a clear invalid_input error, and returns flight time, range, and the velocity components used in the solve as structured JSON.
What elevated projectile motion means and which quantities set the answer
Delivering launch_speed, angle_deg, height, gravity, horizontal_velocity, initial_vertical_velocity, flight_time, range, and method as JSON makes the result easy to paste into notes, diff in automated tests, or feed into a larger pipeline without reimplementing trigonometric roots in every language you teach or deploy. Units stay consistent with whatever length and time basis you chose for speed, height, and gravity: metres per second with metres and metres per second squared yield metres and seconds.
How this calculator validates input and applies the range and flight-time formulas
Send a JSON body with required launch_speed (aliases speed or v0), angle in degrees from horizontal (aliases angle_deg or theta), and height (aliases h or initial_height), plus optional gravity (alias g). A negative height fails immediately with invalid_input because launch height above the landing plane cannot point the wrong way on the vertical axis. Both primary results are rounded to a stable decimal precision so the same input always yields the same JSON across engines.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate projectile range and flight time while checking homework on cliff launches, estimating how far a ball travels when thrown from a balcony, verifying a game physics constant for elevated spawn points, or sanity-checking a sports or robotics demo that starts above ground. Choose gravity to match your planet, moon, or classroom convention—Earth default, lunar about one point six two, or any positive constant you already use in a problem set. There is no language model, no external physics service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials. Each successful request is one billable item at $0.002; failed validation does not consume balance. Results are fully deterministic: the same launch_speed, angle, height, and gravity always yield the same flight_time and range fields. Wire the endpoint into projectile drills, contest answer checkers, elevated-trajectory worksheets, or preprocessing steps where you already prefer explicit domain errors—such as rejecting a negative height—over opaque black-box widgets that cannot explain why a bad input was refused.
Integration use cases
Deterministic fixtures for physics tests
Pipelines that seed unit tests or interactive kinematics demos can call a pure elevated-projectile oracle instead of reimplementing quadratic roots in every language.
Technical questions
How do I calculate projectile range from an elevated height?
Send JSON with launch_speed, angle (degrees from horizontal), and height. The response includes flight_time and range under constant gravity (optional gravity field; default Earth g).