ForHosting KIT · Developer Utilities

Central angle calculator

The central angle calculator answers one precise question: given the length of an arc and the radius of its circle, what angle does that arc subtend at the center?

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Enter both values in the same unit and it returns the central angle in degrees, along with the radian equivalent. It is the inverse of the classic arc length formula, done in a single deterministic step — no iteration, no approximation — so it is equally at home checking homework, sizing a curved fence, or validating the output of a CAD export.

The formula behind the answer

A circle of radius r has a full circumference of 2πr, which corresponds to a full turn of 360 degrees. An arc of length s therefore takes up the fraction s / (2πr) of the whole circle, and the central angle θ in degrees is simply 360 × s / (2πr), which simplifies to θ = (s / r) × 180 / π. The intermediate quantity s / r is exactly the angle in radians, which is why this calculator reports both: radians are the natural unit for calculus and physics, while degrees are what drawings, protractors and building specs usually speak. Because the relationship is a plain ratio, the result does not depend on which unit you measured in — meters, inches or pixels all give the same angle, as long as the arc length and the radius use the same one. That is also the property that makes the computation deterministic: there is no iterative solver and no tolerance to tune, just one division and one multiplication, so the same inputs always produce the same output, in the browser or through the API.

Inputs, validation and edge cases

The calculator needs exactly two numbers: the arc length and the radius. The arc length must be zero or greater — an arc of length zero is legitimate and simply means a central angle of zero degrees, the degenerate case of a sector collapsed to a line. The radius must be strictly positive, because a circle of zero or negative radius is not a circle at all, and dividing by it would be meaningless. Any non-numeric or missing field is rejected with a clear validation error rather than a silent fallback, which matters when the calculator sits inside an automated pipeline: a malformed input stops the run instead of contaminating downstream results. Fields also accept their common aliases — r for radius, s or arc for arc length — so payloads from different sources integrate without remapping. Both values are rounded to twelve decimal places in the output, which keeps the JSON stable across machines while staying far beyond any practical measurement precision.

Where people actually use it

Surveyors and landscapers use it to turn a measured curve into an angle they can stake out with a theodolite. Machinists use it when a bent part is specified by its developed length and bend radius and they need the bend angle for the press brake. Teachers use it as the inverse exercise of the arc length lesson, and students use it to check that their hand calculation lands in the right quadrant. In software, it appears wherever circular geometry is reconstructed from samples: a curved road segment logged as distance along the curve and estimated radius becomes a heading change in degrees; a pie chart generator works back from a slice's outer length to its sweep; a robotics path planner converts an arc command into a turn angle. In every case the pattern is the same — two linear measurements in, one angle out — and that is exactly the contract this capability exposes. The same calculation runs free in your browser on this page, and the API charges $0.002 per request when you automate it.

What you can do with it

Turn a measured curve into an angle

A surveyor measures an arc length along a curved boundary and estimates its radius; the central angle tells them the sweep to lay out with their instruments.

Convert a bend spec for the press brake

A machinist has the developed arc length and bend radius of a formed part and needs the bend angle in degrees for the machine setup.

Check circular-geometry homework

Students solving the inverse of the arc length formula verify that θ = s / r converted to degrees matches their hand calculation.

FAQ

What formula does it use?

The central angle in degrees is (arc length / radius) × 180 / π. The quotient arc length / radius is the angle in radians, which is also returned.

Do the arc length and radius need a specific unit?

No, any unit works — meters, inches, pixels — as long as both values use the same unit, because the angle depends only on their ratio.

What does it cost?

$0.002 per request via the API. It is also free to run in your browser on this page.

Can the arc length be zero?

Yes. A zero arc length is valid and returns a central angle of zero degrees. Negative arc lengths and non-positive radii are rejected as invalid input.

What happens if the arc is longer than the circumference?

The angle comes out above 360 degrees, which is geometrically meaningful for a multi-turn winding. If you expected a sector angle, check that your radius estimate is not too small.

How precise is the result?

The computation is exact floating-point arithmetic — one division and one multiplication — with the output rounded to twelve decimal places for stable results across machines.

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

POSThttps://api.kit.forhosting.com/math/central-angle

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/math/central-angle \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"arc_length":15.708,"radius":10}'

const res = await fetch("https://api.kit.forhosting.com/math/central-angle", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "arc_length": 15.708,
    "radius": 10
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/central-angle",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "arc_length": 15.708,
    "radius": 10
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/central-angle", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"arc_length":15.708,"radius":10}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"arc_length":15.708,"radius":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/central-angle", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "arc_length": 15.708,
  "radius": 10
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.central_angle",
  "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

Per request$0.002

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.

Read the full KIT documentation →