Turn anticipation distance calculator
The turn anticipation distance calculator finds how far before a waypoint an aircraft should begin a constant-radius turn so that it rolls out aligned with the next leg.
Run — free
Enter the planned turn radius and the smaller course change, and it applies the standard tangent geometry for a fly-by waypoint. The result is expressed in the same distance unit as the radius, making the calculator useful with metres, nautical miles, feet, or any other consistent planning unit.
Understand the fly-by waypoint geometry
A fly-by turn starts before the waypoint because an aircraft cannot change heading instantaneously at the leg intersection. For two straight legs joined by a circular arc, the tangent points lie the same distance from the waypoint along each leg. A right triangle formed by the turn centre, waypoint, and tangent point gives the relationship distance = turn radius × tan(course change ÷ 2). This calculator evaluates that relationship directly. The course change is the smaller angle between the inbound and outbound courses, from zero degrees up to but not including 180 degrees. A zero-degree change produces zero anticipation because both legs continue in the same direction. As the change grows, the tangent point moves farther from the waypoint. An exact 180-degree reversal is rejected: the tangent becomes unbounded, and a single circular fly-by arc between the two collinear, opposite legs does not have a finite anticipation point under this model. The output includes the half-angle in radians and the formula used, making the numerical result straightforward to audit in a flight-planning worksheet or software test.
Choose a radius and course change consistently
Use the turn radius that belongs to the aircraft speed and planned bank angle for the relevant phase of flight. This capability does not derive radius from speed, bank, wind, or performance limits; it treats the supplied radius as the horizontal geometric radius of the intended ground-path arc. The anticipation distance inherits that radius unit. If the radius is 1.5 nautical miles, the result is in nautical miles; if it is 2,400 metres, the result is in metres. Supply the course change in degrees as a non-negative value smaller than 180. Determine it as the smaller angular difference between the inbound and outbound courses, accounting for the wrap through north. For example, a transition from 350 degrees to 020 degrees is a 30-degree course change, not 330 degrees. The calculation uses course change magnitude, so left and right turns with the same radius and angle have the same distance. Turn direction can be handled separately by navigation logic. Numeric strings are accepted for API convenience, while missing, infinite, negative-radius, out-of-range, and exact-reversal inputs return a clear invalid-input error.
Interpret the result and its operational limits
The returned anticipation distance is the along-leg distance from the theoretical waypoint back to the point where the constant-radius arc becomes tangent to the inbound leg. Under ideal planar geometry, beginning the turn there and maintaining the stated radius places the exit tangent on the outbound leg at the corresponding distance beyond the waypoint. Real navigation systems may add roll-in, roll-out, wind, groundspeed variation, containment, obstacle clearance, and guidance-law corrections. Those effects are intentionally outside this compact analytic calculation. Treat the result as a geometric planning value or a component inside a broader flight-management model, not as standalone operational authorization. Check that the selected radius is feasible for the aircraft, speed, bank limit, altitude, and environmental conditions, and follow approved procedures and certified avionics where required. The deterministic output is especially useful for validating route-design spreadsheets, producing reproducible software fixtures, or comparing a system’s nominal tangent geometry. Because no network, current weather, aircraft database, or random source is involved, identical inputs always produce identical values. Via the API, each calculation costs $0.002; the browser calculation can use the same pure solving logic.
What you can do with it
Draft a fly-by route
Estimate where a constant-radius turn should begin when laying out connected route legs.
Check flight-planning software
Compare an application's nominal anticipation distance with a deterministic tangent-geometry reference.
Build calculation fixtures
Generate reproducible expected values for navigation, simulation, or avionics test cases.
FAQ
What formula does the calculator use?
It uses distance = turn radius × tan(course change ÷ 2), with the course change converted from degrees for the tangent calculation.
Which unit is the result in?
The result uses the same distance unit as turn_radius. A radius in nautical miles yields nautical miles; a radius in metres yields metres.
How do I handle a course crossing north?
Enter the smaller angular difference. From 350 degrees to 020 degrees, enter 30 degrees.
Why is a 180-degree course change invalid?
The tangent of half that angle is unbounded, so this single-arc fly-by model has no finite anticipation distance for an exact reversal.
Does the result include wind or aircraft roll dynamics?
No. It is ideal planar tangent geometry. Apply wind, roll, performance, containment, and operational corrections in the appropriate certified planning process.
What does an API calculation cost?
Each API request costs $0.002.
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/geo/turn-anticipation-distance \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"turn_radius":1500,"course_change_deg":60}'const res = await fetch("https://api.kit.forhosting.com/geo/turn-anticipation-distance", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"turn_radius": 1500,
"course_change_deg": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geo/turn-anticipation-distance",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"turn_radius": 1500,
"course_change_deg": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geo/turn-anticipation-distance", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"turn_radius":1500,"course_change_deg":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"turn_radius":1500,"course_change_deg":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geo/turn-anticipation-distance", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"turn_radius": 1500,
"course_change_deg": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geo.turn_anticipation_distance",
"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. |