Sagitta of a circular arc calculator
A radius of 10 with a 90° central angle gives an arc that rises about 2.9289, worked out from those two values alone. The chord length comes with it, in the same unit, before you cut stock or set a template. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Radius
- 10
- Angle
- 90
- Angle unit
- Degrees
- Angle radians
- 1.5707963268
- Angle degrees
- 90
- Sagitta
- 2.9289321881
The sagitta is the rise of a circular arc: the straight-line distance from the midpoint of the chord to the arc along the perpendicular that points toward the circle center. Architects, woodworkers, metal fabricators, surveyors, and students often know the design radius and the central angle of an opening, arch, or fillet, but need that height before they can cut stock, set a template, or check clearance under a vault. This sagitta of a circular arc calculator takes a positive radius and a central angle in degrees or radians, applies the closed-form identity sagitta equals radius times one minus cosine of half the angle, and returns the height together with the matching chord length and angle conversions. Zero angle yields zero height; a semicircle of one hundred eighty degrees yields a sagitta equal to the radius; a full three hundred sixty degrees collapses the chord to a point and the sagitta to the diameter.
What sagitta means and how the half-angle formula works
In the right triangle formed by the radius, the half-chord, and the line from the center to the chord, the adjacent side to the half-angle is radius times cosine of half the central angle. The distance from the center to the chord is therefore r cos(θ/2) when θ is measured in radians.
The sagitta—the remaining gap from the chord out to the arc on the near side of the segment—is the radius minus that distance: sagitta equals r minus r cos(θ/2), which factors cleanly to r times one minus cosine of θ over two. Equivalently, the half-chord is r sin(θ/2), so the full chord is two r sin(θ/2); you can recover the same height from radius and chord with the Pythagorean form used by segment-height tools, but this capability starts from the angle so you never need to measure the chord first.
When the central angle is zero the cosine of zero is one and the sagitta is zero. When the angle is one hundred eighty degrees the half-angle is ninety degrees, cosine is zero, and the sagitta equals the radius—a semicircular arch. When the angle approaches three hundred sixty degrees the half-angle approaches one hundred eighty degrees, cosine approaches minus one, and the sagitta approaches twice the radius while the chord shrinks toward a point.
Units are homogeneous: millimetres, inches, or metres all work as long as radius and the returned sagitta and chord share the same length unit. The response always reports this geometric height for the arc that subtends the supplied central angle; it does not switch to a complementary major-segment height unless you deliberately send the complementary angle yourself.
Where a sagitta-from-angle calculator earns its keep
Metal fabrication and woodworking shops use a sagitta of circular arc calculator when a known design radius and a known central angle on a drawing must produce the rise of the curve for jigs, templates, and CNC stock allowances. Civil and architectural notebooks convert arch design angles and radii into crown height so clearance under a vault or roadway curve is correct before pour or erection. Optical and mechanical designers size circular-segment gaps and lens edge drops from angular apertures without first measuring a physical chord on a prototype.
Classroom trigonometry and entrance-exam prep need a deterministic oracle that returns the half-angle cosine form and rejects impossible negative angles or zero-or-negative radii instead of silent NaN values a buggy grader might treat as success. Failed validation does not consume balance. Keep requests small, pin the rounded sagitta in tests, and you get reproducible arc heights for shop floor, LMS plugins, and edge workers without standing up a full computer-algebra stack of your own.
What you can do with it
Shop templates and CNC rise
From a known arc radius and central angle on a drawing, compute the sagitta so a woodworking or metalworking template matches the intended curve rise before cutting stock.
Arch and vault crown height
Convert design radius and central angle into segment height for vault clearance, arch crown, or roadway curve formwork before construction.
Classroom and exam grading
Check homework and auto-grade items on circular-arc sagitta from radius and angle with a deterministic oracle that rejects invalid radii and out-of-range angles.
FAQ
What is the difference between sagitta and segment height from a chord?
Both describe the same geometric rise of a circular segment. This tool starts from radius and central angle. A chord-based segment-height tool starts from radius and measured chord length using h = r − √(r² − (c/2)²). Use whichever pair of inputs you already have.
Can I enter the angle in radians?
In radian mode the angle must be between 0 and 2π inclusive.
What happens at 0°, 180°, and 360°?
Zero angle yields sagitta 0 and chord 0. A semicircle (180° or π rad) yields sagitta equal to the radius and chord equal to the diameter. A full turn (360° or 2π) yields sagitta equal to the diameter and chord 0.
How do I calculate the sagitta of an arc from the radius and angle?
Multiply the radius by one minus the cosine of half the central angle. With a radius of 10 and a 90° angle, half the angle is 45° and the sagitta comes out at about 2.9289, in the radius unit.
Does the calculator also give the chord length?
Yes. Next to the sagitta it shows the chord, which equals twice the radius times the sine of half the angle. You never have to measure the chord first: it is worked out from the same two values.
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/trig/sagitta \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"radius":10,"angle":90}'const res = await fetch("https://api.kit.forhosting.com/trig/sagitta", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"radius": 10,
"angle": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/sagitta",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"radius": 10,
"angle": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/sagitta", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"radius":10,"angle":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"radius":10,"angle":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/sagitta", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"radius": 10,
"angle": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.sagitta",
"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
Invalid radii, negative angles, and angles outside a simple arc are rejected with invalid_input instead of inventing a complex result.
What sagitta means and how the half-angle formula works
Drop a perpendicular from the circle center to the chord that joins the two endpoints of an arc. That line bisects the central angle into two equal half-angles and bisects the chord into two equal half-chords.
Input contract, response shape, and error behaviour
The field radius is a positive circle radius within the published limits. Example: radius ten and angle ninety degrees yield sagitta approximately two point nine two eight nine because half of ninety is forty-five and ten times one minus cosine of forty-five degrees is ten times one minus the square root of two over two. Radius five and angle one hundred eighty degrees yield sagitta five exactly. Radius one and angle pi radians yield sagitta one. POST a JSON body with two required finite numbers and one optional unit string. The field angle is a non-negative central angle whose unit is controlled by angle_unit, which defaults to degrees when omitted and may be set to radians. In degree mode the angle must lie between zero and three hundred sixty inclusive; in radian mode it must lie between zero and two pi inclusive so that the request describes a simple circular arc rather than multiple windings. Each numeric field may arrive as a JSON number or as a numeric string; missing fields, empty strings, non-finite values, non-positive radii, negative angles, angles outside the simple-arc domain, and unknown angle_unit tokens fail with invalid_input naming the problem. Those validation failures are not billed. On success the body includes the echoed radius and angle, the resolved angle_unit, both angle_radians and angle_degrees for unit-agnostic clients, sagitta as the primary height result, height as an identical alias for callers that prefer that name, chord as the straight distance between the arc endpoints, method equal to sagitta_from_angle, and a formula string restating the closed form. Pair the numbers with your own drafting code if you need a sketch; this endpoint returns structured geometry only and does not emit plots or CAD paths.
Technical questions
How do I calculate the sagitta of a circular arc from radius and central angle?
Send a positive radius and a non-negative central angle (degrees by default, or radians via angle_unit). The API returns sagitta = r × (1 − cos(θ/2)) with θ in radians, plus the chord length 2r sin(θ/2).
How much does a successful API call cost?
Each successful call is billed at the published base price of $0.002. Invalid input is not charged. The free browser widget uses the same pure module and does not consume API balance.