Projectile max height calculator
Launch at 20 m/s and 45 degrees and the projectile peaks 10.1971621298 m above the launch point after 1.4420964982 seconds, with no air resistance. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Initial speed
- 20
- Angle
- 45
- Angle rad
- 0.7853981634
- Angle unit
- Deg
- G
- 9.80665
- Vy0
- 14.1421356237
This projectile maximum height calculator finds how high an ideal projectile rises above its launch level when you know the initial speed and the launch angle, assuming constant gravity and no air resistance. The closed-form identity is H equals v zero squared times sine squared of theta, all over two g. That is the same as taking the vertical component of velocity, squaring it, and dividing by twice the gravitational acceleration. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
Where projectile max height fits in study, labs, and software
Students meet maximum height when a textbook separates two-dimensional motion into components, when a lab asks how high a spring launcher or ball toss will rise, or when a contest problem wants the apex without drawing a full parabola. Teachers can pre-generate answer keys for modest speeds and angles without trusting opaque calculator apps that silently switch between degrees and radians or use a rounded g without saying so.
Developers call the same contract from scripts to seed deterministic test vectors for game physics demos, to normalize user-entered launch parameters before a visualization, or to satisfy programming-challenge statements that demand H rather than a hand-waved sketch. Sports and hobby contexts use the ideal formula as a first-order check before air drag matters: a backyard water-balloon toss or a simple rocket-altitude estimate under constant g.
What you can do with it
Homework and lab checks
Compute ideal apex height from launch speed and angle before graphing trajectories or grading projectile-motion worksheets.
Tutoring and teaching software
Normalize user-entered v0 and θ into peak height and time to apex for interactive lessons and step helpers.
FAQ
What does the projectile max height calculator cost?
It is free in your browser on this page.
What formula is used for maximum height?
For ideal motion with constant g and no air resistance, H = (v0² · sin²(θ)) / (2 · g).
What happens if the launch speed is negative?
Speed is a non-negative magnitude; a negative value is not a valid launch speed.
Does this include air resistance?
No. The model is the standard ideal projectile under constant gravity only. Drag, wind, and spin are out of scope.
How long does it take to reach the highest point?
The time to the top is the vertical launch speed divided by g. At 20 m/s and 45 degrees that is 1.4420964982 seconds, the moment the projectile reaches 10.1971621298 m.
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-max-height \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"v0":20,"angle":45}'const res = await fetch("https://api.kit.forhosting.com/mech/projectile-max-height", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"v0": 20,
"angle": 45
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/projectile-max-height",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"v0": 20,
"angle": 45
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/projectile-max-height", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"v0":20,"angle":45}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"v0":20,"angle":45}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/projectile-max-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
{
"v0": 20,
"angle": 45
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.projectile_max_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.
Limits
max_abs_speed | 1000000000000 |
max_abs_g | 1000000 |
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 maximum height means and what the response contains
In introductory mechanics, a projectile is treated as a point mass launched with speed v zero at an angle theta above the horizontal under constant gravity, with air resistance ignored. The vertical motion is independent of the horizontal motion: the initial vertical speed is v zero times sine of theta, the vertical speed decreases at rate g, and the highest point occurs when the vertical velocity crosses zero. Integrating or using energy gives the same peak height above the launch point: H equals v zero squared sine squared theta over two g. This calculator returns the normalized inputs v zero, angle, angle in radians, angle unit, and g; the derived vertical launch component vy zero; the maximum height max_height; the time from launch to the apex t_apex; the precision used; a method tag ideal_projectile_max_height; and a short formula reminder. When the vertical component is zero or downward, the apex is already at the launch level, so max_height and t_apex are zero rather than a spurious positive rise. There is no numerical ODE integration and no Monte Carlo sampling of trajectories: the engine either evaluates the closed form inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing speed or angle, non-finite values, a non-positive g, magnitudes above the documented ceilings, and any negative launch speed, because a speed magnitude cannot be negative.
How v0, angle, and g are read and how H stays reproducible
Zero speed is valid and yields zero height. 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. Gravitational acceleration g defaults to nine point eight zero six six five meters per second squared, the conventional standard gravity, and may be overridden for other planets or textbook problems that use g equals ten; g must be strictly positive and within the documented magnitude ceiling. Computation uses Math.sin on the radian form of the angle, builds vy zero, then applies H equals vy zero squared over two g when rising. The preferred fields are v0 for the launch speed magnitude and angle for the elevation above the horizontal, but aliases v, speed, velocity, initial_speed, and initial_velocity for v0, and theta, launch_angle, and a for angle, are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Speed must be finite and non-negative: a negative v0 fails with invalid_input and a message that names the field, so a bad cell does not become a silent absolute-value guess. Angle may be any finite number; by default it is interpreted in degrees, and angle_unit may be set to deg, degrees, rad, or radians. 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.
Where projectile max height fits in study, labs, and software
Product and education tools use the endpoint when a learner types speed and angle and the UI must show the peak height and time to apex. 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 range or free-fall helpers when you need related kinematics, 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 max_height and t_apex values for unit tests, game-physics demos, and CI assertions.
Technical questions
Are angles in degrees or radians?
Degrees by default (angle_unit = deg). Set angle_unit to rad or radians if your angle is already in radians.