Radians to gradians conversion calculator
Move an angle from radians to the 400-part circle in one step: π radians become exactly 200 gradians, a straight angle. Negative and multi-turn values keep their sign and size. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Radians
- 3.1415926536
- Result
- 200
- Radians
- 3.1415926536
- Gradians
- 200
- From unit
- rad
This radians-to-gradians conversion calculator changes an angle measured in radians into gradians, also known as gons or grades. Enter a finite radian value and it applies the standard full-turn relationship: two pi radians equal four hundred gradians. The response provides the converted value, units, formula, and readable substitution steps. Positive, negative, fractional, zero, and multi-turn angles are supported with deterministic arithmetic and stable rounding.
Understand how radians relate to gradians
Radians and gradians measure the same angle on different numerical scales. Radian measure comes from geometry: an angle of one radian subtends an arc whose length equals the circle radius. A complete revolution contains two pi radians.
The gradian system instead divides a complete revolution into four hundred equal parts, making a right angle exactly one hundred gradians and a straight angle two hundred gradians. Equating those descriptions gives two pi radians equals four hundred gradians. Divide both sides by two pi and one radian equals two hundred divided by pi gradians.
The direct conversion formula is therefore gradians equals radians multiplied by two hundred and divided by pi. Using this direct factor avoids a conversion through degrees and prevents an intermediate rounded figure from reducing accuracy. Useful checkpoints reveal whether a result is on the right scale: pi over two radians should become one hundred gradians, pi radians should become two hundred, and two pi radians should become four hundred.
The sign remains unchanged, so a negative radian angle becomes a negative gradian angle. Values beyond one revolution are preserved rather than automatically reduced, allowing the result to represent accumulated rotation when that distinction matters.
Verify results and use converted angles correctly
Start verification with a familiar landmark angle. A right angle is pi over two radians and one hundred gradians; a straight angle is pi radians and two hundred gradians; a complete turn is two pi radians and four hundred gradians. If those landmarks produce a different scale, check that the source value is truly in radians and was not supplied in degrees.
For downstream calculations, use the numeric gradians field returned by the capability rather than copying a shortened number from an explanatory sentence. Although angle measures are dimensionless in formal analysis, explicit rad and gon labels in user interfaces, variable names, and logs help prevent costly unit confusion. This converter does not evaluate sine or cosine, parse symbolic expressions containing pi, normalize angles to a single revolution, or infer the intended source unit.
A negative input stays negative to preserve orientation conventions such as clockwise rotation. Likewise, a multi-turn input stays multi-turn so robotics, animation, and motion-control systems can retain accumulated movement. The bounded input, deterministic formula, stable rounding, and absence of external calls also make this capability suitable for repeatable automated tests, batch transformations, and auditable calculation pipelines.
What you can do with it
Surveying data exchange
Convert radian angles from analysis software into gradians for surveying workflows and instruments that use gons.
Mathematics education
Check exercises about radian and centesimal angle measures with a formula and visible substitution steps.
Engineering integrations
Translate signed or accumulated radian rotations into gradians before sending them to a gon-based system.
FAQ
What formula converts radians to gradians?
Multiply radians by 200/π: gradians = radians × 200 / π.
How many gradians are in pi radians?
Pi radians equal 200 gradians, which represents a straight angle.
Are gradians, gons, and grades the same unit?
Yes. Gon and grade are alternative names for the gradian; one complete turn contains 400 gradians.
Can I convert negative or fractional radians?
Yes. Any finite number within the published absolute limit is accepted, with its sign and fractional magnitude preserved.
How many gradians are in π/2 radians?
Exactly 100 gradians, which is a right angle. Multiply the radians by 200 and divide by π; a full turn of 2π radians gives 400 gradians the same way.
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/rad-to-gradian \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"radians":3.141592653589793}'const res = await fetch("https://api.kit.forhosting.com/trig/rad-to-gradian", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"radians": 3.141592653589793
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/rad-to-gradian",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"radians": 3.141592653589793
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/rad-to-gradian", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"radians":3.141592653589793}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"radians":3.141592653589793}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/rad-to-gradian", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"radians": 3.141592653589793
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.rad_to_gradian",
"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.
Limits
max_abs | 1000000000000 |
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
The browser calculator and API use the same conversion logic, so the same valid input produces the same JSON without network access, randomness, stored state, or dependence on the current time.
Provide input and read the conversion response
Guessing a number from ambiguous text could return a plausible conversion for the wrong input, so validation fails clearly instead. The supported absolute range is one trillion radians. Results are rounded to twelve decimal places. For example, pi radians multiplied by two hundred and divided by pi gives exactly two hundred gradians within floating-point representation. Supply the required radians field as a finite JSON number. The solver also accepts a strictly formatted numeric string and the practical aliases rad, value, angle, or input. It intentionally rejects unit suffixes, prose, comma separators, mathematical expressions, booleans, empty values, and non-finite numbers. A successful response echoes the radian value, returns gradians and result as the same converted number, labels rad as the source unit and gon as the destination unit, and includes the formula plus three explanatory steps. That keeps JSON output stable across repeated runs while retaining enough precision for common mathematical, educational, engineering, surveying, and graphics work. Missing input, malformed numeric strings, infinity, and out-of-range values produce an invalid_input error instead of a partial answer. Each successful API call costs $0.002, while the page calculator executes the identical deterministic conversion in the browser.
Verify results and use converted angles correctly
If another application requires a value from zero through four hundred gradians, normalize the result there according to that application’s endpoint rules.
Technical questions
What does the API conversion cost?
Each successful API request costs $0.002. The same deterministic calculation can also run free in the browser.