ForHosting KIT · Math

Gradians to radians conversion calculator

100 gradians, a right angle, convert to 1.570796326795 radians, which is π over 2. The rule is short: multiply by π and divide by 200, because 400 gradians make a full turn of 2π radians. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Gradians: 100

You get

Result: 1.5707963268
Radians: 1.5707963268
From unit: gon
To unit: rad

This gradians-to-radians conversion calculator changes an angle measured in gradians, also called gons or grades, into its radian measure. Enter any finite gradian value and the calculator applies the standard full-turn relation: four hundred gradians equal two pi radians. The result includes the converted number, the formula, and readable substitution steps. It handles positive, negative, zero, fractional, and multi-turn angles with deterministic arithmetic and stable rounding.

Understand the relationship between gradians and radians

Gradians and radians describe the same geometric quantity with different scales. The gradian system divides one complete revolution into four hundred equal units, which makes a right angle exactly one hundred gradians. The radian system defines angles through the relationship between arc length and radius, and one complete revolution contains two pi radians.

Putting those two full-turn descriptions together gives the equality four hundred gradians equals two pi radians. Divide both sides by four hundred and one gradian equals pi divided by two hundred radians. Therefore the direct conversion formula is radians equals gradians multiplied by pi and divided by two hundred.

This factor is preferable to converting through degrees because it states the relationship directly and avoids an unnecessary intermediate rounded value. Familiar checkpoints help verify the scale: one hundred gradians becomes pi over two radians, two hundred becomes pi radians, and four hundred becomes two pi radians. Signed angles retain their direction, so negative gradians produce negative radians.

Values larger than a full turn are also valid and remain larger than two pi, which is useful when an application tracks accumulated rotation instead of normalizing every angle to one revolution.

Check conversions and use the result safely

A good conversion workflow begins with an anchor angle whose value is already known. Check one hundred gradians for a right angle, two hundred for a straight angle, or four hundred for a complete turn. The resulting decimals should correspond to pi over two, pi, and two pi respectively, subject only to the documented twelve-decimal output rounding.

When moving the result into another calculation, use the returned radians number rather than copying a shortened value from explanatory text. Remember that radians are dimensionless in mathematical analysis, but keeping the rad label in interfaces, logs, and variable names prevents accidental mixing with degrees or gradians. This capability converts only from gradians to radians; it does not evaluate trigonometric functions, normalize an angle into a preferred interval, or infer units from a pasted expression.

Negative inputs stay negative, which preserves clockwise orientation when that is the convention of the calling system. Multi-turn inputs are not reduced modulo a full revolution, so they preserve accumulated motion for robotics or animation. If a downstream library expects an angle between zero and two pi, normalize there according to that library’s rules after conversion.

Deterministic code, explicit validation, and no external calls make the result suitable for repeatable tests and automated pipelines.

What you can do with it

Surveying calculations

Convert gon readings from surveying instruments into radians before using trigonometric functions in engineering software.

Mathematics study

Check textbook conversions between the centesimal gradian scale and the radian scale with visible substitution steps.

Robotics and graphics

Translate signed or multi-turn gradian rotations into radians for libraries whose angle interfaces expect radian values.

FAQ

What formula converts gradians to radians?

Multiply gradians by π/200: radians = gradians × π / 200.

How many radians are in 100 gradians?

One hundred gradians equal π/2 radians, returned approximately as 1.570796326795 after twelve-decimal rounding.

Are gons, grades, and gradians the same unit?

Yes. Gon and grade are alternative names for the gradian angle unit; a complete turn contains 400 of them.

Can the calculator accept negative or fractional gradians?

Yes. Any finite number within the published absolute limit is accepted, and its sign and fractional magnitude are preserved in the conversion.

How many radians is a full turn of 400 gradians?

Exactly 2π radians. That full-turn equality is the basis of the conversion: dividing both sides by 400 shows that one gradian is π divided by 200 radians.

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

POSThttps://api.kit.forhosting.com/trig/gradian-to-rad

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/gradian-to-rad \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"gradians":100}'

const res = await fetch("https://api.kit.forhosting.com/trig/gradian-to-rad", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "gradians": 100
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/trig/gradian-to-rad",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "gradians": 100
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/gradian-to-rad", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"gradians":100}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"gradians":100}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/gradian-to-rad", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "gradians": 100
}

Example response

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

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 tool and API share the same calculation code, so identical inputs produce identical JSON without relying on a network service, random value, or current time.

Enter a value and interpret the response

Unit symbols, words, thousands separators, and mixed expressions are rejected because silently extracting a number from ambiguous text could create a convincing but incorrect conversion. The accepted absolute range is one trillion gradians. Numeric output is rounded to twelve decimal places to keep serialized responses stable while preserving ample precision for ordinary trigonometry, surveying, engineering, and educational work. For example, an input of one hundred follows one hundred multiplied by pi divided by two hundred, producing approximately 1.570796326795 radians. Send the required gradians field as a finite JSON number. For practical client compatibility, the solver also accepts a strictly formatted numeric string and the aliases gon, grad, value, angle, or input. A successful response echoes the gradian input, reports radians and result as the same converted value, identifies gon as the source unit and rad as the destination unit, and supplies both a formula and three calculation steps. Missing values, non-numeric strings, infinities, and values outside the declared range return an invalid_input error rather than a fabricated result.

Technical questions

What does the API conversion cost?

Each successful API request costs $0.002. You can also run the same deterministic calculation free in the browser.

Read the full KIT documentation →

Run — free