Velocity components calculator
A speed of 10 m/s at 30° splits into 8.6602540378 m/s horizontally and 5 m/s vertically. Enter the speed and the angle from the horizontal to get both parts and the angle in radians. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Speed
- 10
- Angle
- 30
- Angle rad
- 0.5235987756 m/s
- Vx
- 8.6602540378
- Vy
- 5
- Components
- 8.6602540378, 5
This velocity components calculator splits a speed and a direction angle into the horizontal and vertical parts of the velocity vector. In two-dimensional kinematics the magnitude of velocity is the speed, and the direction is measured counterclockwise from the positive horizontal axis in degrees. The closed forms are vx equals v times cosine of theta and vy equals v times sine of theta, with the angle converted from degrees to radians before the trigonometric call. When speed is given in metres per second, the components are reported in the same unit; any consistent length-over-time unit works the same way. The engine returns both scalar components, a two-element components array, the angle in radians, and a short formula tag so you can verify the polar-to-cartesian step without a second tool. Everything is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What velocity components mean and what you get
In introductory mechanics, a planar velocity is a vector with a magnitude called speed and a direction relative to a chosen horizontal axis. Resolving that vector into components is the first step before applying independent horizontal and vertical equations of motion, before adding forces in free-body diagrams, or before feeding a game or simulation engine that stores velocity as two scalars.
With the standard engineering convention that angle is measured counterclockwise from the positive x-axis, the horizontal component is speed times cosine of the angle and the vertical component is speed times sine of the angle. Zero degrees points fully to the right, ninety degrees points straight up, one hundred eighty degrees points left, and two hundred seventy degrees points down; three hundred sixty degrees coincides with zero for a full turn.
This calculator answers the finite closed-form case used in homework and first-order engineering checks when speed and direction are known and air resistance or three-dimensional out-of-plane motion are ignored. Zero speed is valid and yields zero components at any allowed angle.
Where velocity components fit in study, labs, and software
Students meet velocity components when a textbook introduces two-dimensional kinematics, when a lab measures the launch speed and angle of a projectile cart, or when a contest problem gives a speed and a bearing and asks for the horizontal and vertical parts before applying independent motion equations. Teachers can pre-generate answer keys for modest speed and angle values without trusting opaque calculator apps that silently switch between degrees and radians or flip the sine and cosine assignment.
Developers call the same contract from scripts to seed deterministic test vectors for game physics demos of 2D movement, to normalize user-entered polar velocity before a visualization, or to satisfy programming-challenge statements that demand vx and vy rather than a hand-waved sketch. First-order engineering checks use the polar decomposition when only a speedometer reading and a heading are known: the horizontal and vertical parts follow immediately before drag, bank angle, or three-dimensional wind corrections are modeled.
What you can do with it
Homework and kinematics checks
Split textbook speed-and-angle problems into vx and vy before applying independent horizontal and vertical motion equations.
Labs and tutoring software
Normalize measured launch speed and heading into components for plotters, step helpers, and interactive lessons.
FAQ
What does the velocity components calculator cost?
It is free in your browser on this page.
How are vx and vy defined?
For speed v and direction angle θ in degrees from the positive horizontal axis (counterclockwise), vx = v·cos(θ) and vy = v·sin(θ), with θ converted to radians for the trig functions.
What angle range is accepted?
Angles must lie in the closed range 0 to 360 degrees inclusive.
Can speed be negative?
No. Speed is a non-negative magnitude. Encode reverse headings with the direction angle instead of a negative speed.
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/velocity-components \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"speed":10,"angle":30}'const res = await fetch("https://api.kit.forhosting.com/mech/velocity-components", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"speed": 10,
"angle": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/velocity-components",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"speed": 10,
"angle": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/velocity-components", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"speed":10,"angle":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"speed":10,"angle":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/velocity-components", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"speed": 10,
"angle": 30
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.velocity_components",
"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 | 1000000000000000 |
angle_min_deg | 0 |
angle_max_deg | 360 |
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 velocity components mean and what the response contains
The response returns the normalized speed and angle inputs, the angle converted to radians, the computed vx and vy values, a two-element components array, the precision used, a method tag polar_to_cartesian_velocity, a short formula reminder, and a unit hint m/s for SI inputs. There is no numerical ODE integration of trajectories and no Monte Carlo sampling of directions: the engine either evaluates the trig identities inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing speed or angle, non-finite values, speed magnitudes above the documented ceiling, a negative speed, and any angle strictly outside the closed interval from zero to three hundred sixty degrees, because this page standardizes on that degree range rather than silently wrapping negative or multi-turn headings.
How speed and angle are read and how vx and vy stay reproducible
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 field for the speed magnitude is speed, but aliases v, V, magnitude, and velocity_magnitude are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Speed must be finite and non-negative; a negative value fails with invalid_input because speed is a magnitude and reverse headings should be encoded with the direction angle, and magnitudes above the documented ceiling are also rejected. The preferred field for the direction is angle, with aliases theta, direction, deg, and degrees. Angle must be finite and lie between zero and three hundred sixty degrees inclusive: a value of negative ten or three hundred seventy fails with invalid_input and a message that names the field and explains that values outside zero through three hundred sixty are rejected, so a bad cell does not become a silently wrapped heading. 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 cosine and sine decomposition yourself.
Where velocity components fit in study, labs, and software
Product and education tools use the endpoint when a learner types a speed and an angle and the UI must show metres per second along each axis together with the angle in radians. 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 projectile-max-height or circular-velocity 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 vx, vy, and components arrays for unit tests, game-physics demos, and CI assertions on polar-to-cartesian velocity.