Orbital velocity calculator
Find the speed that keeps a satellite on a circular orbit: 6,778,000 m from the centre of a body with Earth's mass, it must travel at 7,668.527496 m/s. Enter the central mass and the distance from its centre. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Central mass
- 5,972,000,000,000,000,000,000,000
- Radius
- 6,778,000
- G
- 0.0000000001
- Orbital velocity
- 7,668.527496
Circular orbital velocity is the tangential speed a satellite needs to stay on a closed circular path about a central body under Newtonian gravity. For a given central mass M and orbital radius r measured from the center of mass, the balance of gravitational force and centripetal requirement yields the compact formula v equals the square root of G times M over r. Optional G defaults to a fixed CODATA SI constant so results stay stable across environments; override it when your unit system is not SI.
What circular orbital speed means
A satellite on a circular orbit keeps the same speed and the same distance from the body it circles. Gravity pulls it toward the centre, and for the path to stay a circle that pull must exactly match what is needed to keep the satellite turning. Balancing the two gives the speed: the square root of the gravitational constant times the central mass, divided by the distance from the centre. Only the central mass and the distance matter; the satellite's own mass drops out. With Earth's mass and a distance of 6,778,000 m, the answer is 7,668.527496 m/s.
How to use it and the usual mistakes
Enter the mass of the body being orbited in kilograms and the distance from its centre to the satellite in metres. The gravitational constant has a fixed default; change it only if you work in a different unit system. The most common mistake is entering the height above the surface instead of the distance from the centre, so add the planet's radius first. Another is typing the satellite's mass where the planet's mass belongs. Mixing kilometres and metres also gives a badly wrong speed, so keep every value in the same system.
What circular orbital velocity means and which inputs to send
Under inverse-square gravity and the two-body idealization, a satellite on a circular orbit has constant speed and constant distance from the central mass. Setting the gravitational acceleration G M over r squared equal to the centripetal acceleration v squared over r rearranges immediately to v equals the square root of G M over r. Altitude alone is incomplete: you must add the planetary radius first if your source quotes height.
Mass and G must be strictly positive. Non-finite values are rejected.
FAQ
What happens if radius is zero?
Zero (or non-positive) radius is rejected because the circular orbit formula divides by r and is not defined for a vanishing path radius.
Is radius the altitude above the surface?
No. Radius must be the distance from the center of the central body to the satellite. If you only know altitude, add the body's radius first, then submit the sum.
Can I change the gravitational constant G?
Use a matching G whenever your mass and radius are not in SI units.
Is the orbital velocity calculator free?
The browser tool runs free on your device.
How fast does a satellite orbit 6,778,000 m from Earth's centre?
At 7,668.527496 metres per second. That is the square root of the gravitational constant times Earth's mass, divided by the distance from the centre.
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/astro/orbital-velocity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"central_mass":5.972e+24,"radius":6778000}'const res = await fetch("https://api.kit.forhosting.com/astro/orbital-velocity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"central_mass": 5.972e+24,
"radius": 6778000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/orbital-velocity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"central_mass": 5.972e+24,
"radius": 6778000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/orbital-velocity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"central_mass":5.972e+24,"radius":6778000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"central_mass":5.972e+24,"radius":6778000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/orbital-velocity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"central_mass": 5.972e+24,
"radius": 6778000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.orbital_velocity",
"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 evaluates that expression deterministically from finite numeric inputs, rejects zero or non-positive radius with a clear invalid input error, and returns structured JSON that homework checkers, mission concept tools, and lightweight astrodynamics pipelines can pin in continuous integration without installing a full orbital mechanics stack.
What circular orbital velocity means and which inputs to send
Send the required field central_mass as a JSON number or numeric string for the body being orbited—for example Earth mass in kilograms—and the required field radius as the distance from the center of that body to the satellite, not merely the altitude above the surface. Aliases mass, M, and m are accepted for the central mass; aliases r and orbital_radius are accepted for the path radius. The optional field G, with aliases gravitational_constant and grav_const, lets you inject a textbook approximation or a non-SI constant; when omitted the engine uses the fixed value 6.6743 times ten to the minus eleven so every environment agrees. Radius must be strictly positive as well: zero radius is invalid_input because the formula divides by r and a vanishing orbit is not a physical circular path. Identical inputs always produce identical JSON because the path is pure floating-point arithmetic with no network, no random seed, and no wall clock.
Reading the response fields and unit consistency
If you switch to astronomical unit systems, supply a matching G; the calculator does not convert units for you. On success the response echoes central_mass, radius, and the G that was used, then reports orbital_velocity as the circular speed magnitude. The formula field is always the string v equals sqrt of G M over r, and method is always circular_orbital_velocity so downstream code can branch without sniffing shapes. Units are your responsibility and must be consistent: with SI mass in kilograms, radius in meters, and the default G, orbital_velocity is in meters per second. Missing central_mass, missing radius, zero radius, negative mass, non-positive G, and non-finite numbers all fail with invalid_input and are not charged after the engine rejects the request. Use orbital_velocity alone when a dashboard only needs the speed number; keep formula and method when documenting the physics step for students or when logging which algorithm produced a mission sketch. Pair this endpoint with centripetal force tools when the next question is the force magnitude for a given satellite mass, remembering that orbital velocity itself depends only on the central body and radius, not on the satellite mass under the two-body model.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser orbital velocity calculator for homework checks, lecture demos, and quick concept verification without installing Orekit, GMAT, or a local MATLAB toolbox. Typical classroom examples include low Earth orbit at roughly Earth radius plus a few hundred kilometers, geostationary radius near forty-two thousand kilometers, and simplified solar orbits with solar mass and astronomical-unit scales—always with matching G and consistent units. Extremely large or tiny magnitudes are bounded for isolate safety; stay within the published numeric range for reliable results. Send a JSON body with required positive central_mass and radius, and optional positive G when you need a non-default constant. Use the prepaid API when a tutoring platform, coding-assessment sandbox, curriculum generator, or early mission-design pipeline needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after rejection. Authors shipping SDKs can map orbital_velocity into tables that compare circular speeds across altitudes, teaching how speed falls as the square root of one over r while period grows with r to the three-halves power—a companion concept you may compute separately when building multi-step lesson flows.
Integration use cases
Homework and exam verification
Students and graders compute circular orbital speed for given central mass and radius, compare against textbook answers, and get a clear invalid_input error when radius is zero by mistake.
Tutoring and curriculum generators
Lesson builders produce worked orbital-velocity examples with structured JSON for flashcards, step sheets, and auto-graded drills without embedding a full astrodynamics library.
Early mission concept sketches
Lightweight pipelines that need a stable circular-speed check from mass and radius call a prepaid endpoint instead of reimplementing sqrt(GM/r) in every language.
Technical questions
How do I calculate circular orbital velocity?
Send JSON with central_mass (M) and radius (r) as positive finite numbers. The response includes orbital_velocity equal to sqrt(G M / r), plus the G used and the formula label.