Combined maneuver Δv calculator
Going from 7.8 to 7.5 km/s while turning the orbit 30° takes 3.970519835 km/s in a single combined burn. Enter the speed before and after and the turn angle in degrees to get that delta-v. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Initial speed
- 7.8
- Final speed
- 7.5
- Turn angle
- 30
- Turn angle rad
- 0.5235987756
- Delta v
- 3.970519835
A combined plane-change and speed-change burn is the single impulse that both rotates the velocity vector through a turn angle and stretches or shrinks its magnitude from an initial orbital speed to a final orbital speed. Instead of sequencing a pure inclination change and a pure tangential burn as two separate burns, mission designers often ask for the magnitude of one combined maneuver: the straight-line distance in velocity space between the initial and final velocity vectors. That length follows the law of cosines on the velocity triangle.
Why one combined burn instead of two
A spacecraft that must change both its orbital plane and its speed could do it with two separate burns: one that only rotates the velocity and one that only lengthens or shortens it. Mission designers often look at a single combined burn instead, done at the point where the two orbital planes cross. What counts is the straight-line gap between the old velocity and the new one. Picture both velocities as arrows drawn from the same point: the burn you need is the arrow that joins their tips, and its length is the delta-v.
How the number is worked out and what to watch
The two speeds and the turn angle between them form a triangle, and the law of cosines gives its third side: square both speeds, add them, subtract twice their product times the cosine of the angle, and take the square root. With 7.8 and 7.5 km/s and a 30° turn, the result is 3.970519835 km/s. Typical mistakes are mixing units between the two speeds, entering the angle in radians instead of degrees, or forgetting that this is the ideal two-body case with an instant burn.
What a combined plane-change burn means and which inputs to send
In the two-body idealization, an impulsive burn changes the spacecraft velocity vector instantly. When the burn both alters orbital speed and rotates the velocity direction—commonly a simultaneous plane change and circular-speed adjustment at a node—the required delta-v is the Euclidean length of the difference between the initial velocity vector and the final velocity vector.
If those vectors have magnitudes v1 and v2 and the angle between them is theta, the law of cosines gives delta-v equal to the square root of v1 squared plus v2 squared minus twice v1 times v2 times the cosine of theta. Speeds must be non-negative finite numbers in consistent units—kilometers per second is the usual textbook choice. The turn angle is converted to radians only inside the cosine; callers always supply degrees.
FAQ
What if the two speeds are equal?
Use equal speeds when only the inclination (or heading) changes.
Is the combined maneuver delta-v calculator free?
The browser tool runs free on your device.
How much delta-v does a 30° turn from 7.8 to 7.5 km/s take?
3.970519835 km/s in one combined burn. The calculator treats the two speeds as sides of a triangle with the 30° turn between them and returns the length of the third side.
What if the turn angle is zero?
Then the burn is a pure speed change and the result is simply the difference between the two speeds. No rotation of the velocity is involved, so the formula collapses to that absolute difference.
Which units should I use?
Any speed unit works as long as both speeds use the same one; kilometers per second is the usual textbook choice. The turn angle is always entered in degrees, and the answer comes back in the same speed unit.
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/combined-plane-change \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"initial_speed":7.8,"final_speed":7.5,"turn_angle":30}'const res = await fetch("https://api.kit.forhosting.com/astro/combined-plane-change", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"initial_speed": 7.8,
"final_speed": 7.5,
"turn_angle": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/combined-plane-change",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"initial_speed": 7.8,
"final_speed": 7.5,
"turn_angle": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/combined-plane-change", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"initial_speed":7.8,"final_speed":7.5,"turn_angle":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"initial_speed":7.8,"final_speed":7.5,"turn_angle":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/combined-plane-change", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"initial_speed": 7.8,
"final_speed": 7.5,
"turn_angle": 30
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.combined_plane_change",
"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
What a combined plane-change burn means and which inputs to send
Send the required field initial_speed as a JSON number or numeric string for the speed before the burn, final_speed for the speed after the burn, and turn_angle for the plane-change or turn angle in degrees between those two velocity directions. Aliases v1, v_initial, and speed_before are accepted for the first speed; v2, v_final, and speed_after for the second; theta, angle, plane_change_angle, and delta_i for the turn angle. Negative speeds fail with invalid_input because orbital speed is a magnitude and the product contract forbids them. 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 checking special cases by hand
Classic checks include a pure plane change with equal speeds: when v1 equals v2 equals v and theta is the plane-change angle, delta-v reduces to two v times the sine of half of theta, which you can recompute by hand for small angles. When the turn angle is zero, the formula collapses to the absolute difference of the two speeds—a pure speed change with no rotation. When one speed is zero, delta-v equals the other speed, matching a burn from rest or to rest in the velocity plane. On success the response echoes initial_speed, final_speed, and turn_angle, reports turn_angle_rad as the internal radian conversion, and places the combined-maneuver magnitude in delta_v. The formula field is always the string describing the law-of-cosines expression, and method is always combined_plane_change_law_of_cosines so downstream code can branch without sniffing shapes. Units of delta_v match the units you chose for the two speeds; the calculator does not convert units for you. Missing fields, non-finite numbers, and negative speeds all fail with invalid_input and are not charged after the engine rejects the request. Use delta_v alone when a dashboard only needs the burn magnitude; keep formula and method when documenting the physics step for students or logging which algorithm produced a mission sketch.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser combined maneuver delta-v calculator for homework checks, lecture demos, and quick concept verification without installing Orekit, GMAT, or a local MATLAB toolbox. Typical classroom examples include a low-Earth-orbit circular speed near seven point eight kilometers per second with a modest plane change of ten to thirty degrees, or a simultaneous drop to a slightly lower circular speed while rotating the plane at a node—always with matching units for both speeds. Extremely large magnitudes are bounded for isolate safety; stay within the published numeric range for reliable results. Send a JSON body with required non-negative initial_speed and final_speed plus a finite turn_angle in degrees. 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 delta_v into tables that compare pure plane change versus combined burns, teaching how combining the speed change with the plane change can cost less propellant than stacking two separate impulses when both adjustments are required at the same orbital position.
Integration use cases
Homework and exam verification
Students and graders compute combined plane-change delta-v from two speeds and a turn angle, compare against textbook law-of-cosines answers, and get a clear invalid_input error when a speed is entered negative by mistake.
Tutoring and curriculum generators
Lesson builders produce worked combined-maneuver 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 single-burn delta-v estimate for simultaneous speed and plane changes call a prepaid endpoint instead of reimplementing the velocity-triangle formula in every language.
Technical questions
How do I calculate combined plane-change delta-v?
Send JSON with initial_speed (v1), final_speed (v2), and turn_angle (theta in degrees). The response includes delta_v equal to sqrt(v1² + v2² − 2·v1·v2·cos θ), plus the radian conversion and formula label.
What happens if a speed is negative?
The request fails with invalid_input. Speeds are magnitudes and must be non-negative; a negative initial_speed or final_speed is rejected with a message that names the offending field.
Is turn_angle in degrees or radians?
Degrees in the public contract. The solver converts to radians only for the cosine; the response also reports turn_angle_rad so you can verify the conversion.