Degrees to gradians converter
A right angle of 90° is exactly 100 gradians. Enter degrees and get gons with the exact ten-ninths factor, anchored on a full turn of 360° being 400 gradians, with no detour through radians or pi. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Degrees
- 90
- Result
- 100 gon
- Converted
- 100
- Deg
- 90
- Gradians
- 100
A degrees-to-gradians converter turns a familiar sexagesimal angle into the centesimal grade scale used in surveying, some European engineering curricula, and instruments that divide a right angle into one hundred equal parts. The conversion rests on fixed full-turn anchors—three hundred sixty degrees equal four hundred gradians—so each degree is exactly ten ninths of a gradian without routing through pi or approximate floating tables.
Why degrees and gradians meet at degrees × (10/9)
Degrees remain the default angle unit in everyday geometry, most school trigonometry, maps, and computer graphics APIs. Gradians—also called gons or grades—split a full turn into four hundred equal parts so that a right angle is exactly one hundred gradians. Surveyors and some civil-engineering traditions prefer that decimal split because one hundred gradians per right angle maps cleanly onto percentage grades and calculator modes labeled GRAD.
Both scales are linear and fixed by the same geometric anchor: a complete revolution is three hundred sixty degrees or four hundred gradians. That means a three-hundred-sixty-degree span equals a four-hundred-gradian span, so each degree is exactly ten ninths of a gradian. Scaling by ten ninths yields the exact map gradians equals degrees times ten ninths.
Approximate mental shortcuts such as multiply by one point one, or conversions that first go through radians with truncated pi, drift on multi-revolution angles and on fractional-degree field notes.
Practical tips, checks, and related searches
Prefer sending bare numbers when you control the client; string numbers are accepted only when they match a strict finite numeric pattern without degree symbols, unit letters, thousand separators, or currency marks. Round-trip sanity checks are easy: convert the textbook right angle ninety degrees and confirm you receive exactly one hundred gradians after rounding, convert one hundred eighty and confirm two hundred gradians, or convert three hundred sixty and confirm four hundred gradians for a full turn.
When teaching, pair the exact path with a calculator GRAD mode so students see that the same angle reading appears under both labels. Stay inside the absolute range so the linear map cannot overflow into a non-finite result the solver must reject. This landing targets people searching for degrees to gradians, convert deg to gon, or an exact ten ninths angle calculator; it is not a general multi-unit angle hub, not a gradians-to-degrees primary form, and not a radians or turns converter.
Prefer this capability when the input is already in degrees and you only need gradians; if you must convert among many angular units in one call, use a broader angle converter instead.
What you can do with it
Surveying and civil notes
Turn degree bearings from maps or total-station exports into gon readings for instruments and field books that use the centesimal grade scale.
Homework and exam checks
Students convert classroom degree angles to gradians and compare hand work against deterministic steps before submitting trigonometry worksheets.
Engineering CAD and calculator modes
Design pipelines map DEG-mode angles into GRAD-mode setpoints without approximate pi routes that drift on multi-turn or fractional-degree values.
FAQ
What formula converts degrees to gradians?
gradians = degrees × (10/9). The 10/9 factor is exact because a full turn is 360° or 400ᵍ, so 1° = 10/9 gradians.
Is 10/9 exact or approximate?
Exact. This tool uses the standard linear map from the 360°/400ᵍ full-turn anchors, not a rough multiply-by-1.1 estimate or a radians intermediate.
Is the degrees to gradians converter free?
The browser tool is free and runs locally.
Who uses gradians instead of degrees?
Mainly surveyors and some European civil-engineering courses, plus instruments that split a right angle into one hundred equal parts. Calculators offer the unit as their GRAD mode.
Why not just multiply degrees by 1.1?
Because the exact factor is ten ninths, slightly more than 1.1. The shortcut drifts on fractional field notes and grows worse on angles of several turns, while the exact factor keeps every reading true.
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/conv/degrees-to-gradians \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"degrees":90}'const res = await fetch("https://api.kit.forhosting.com/conv/degrees-to-gradians", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"degrees": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/degrees-to-gradians",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"degrees": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/degrees-to-gradians", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"degrees":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"degrees":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/degrees-to-gradians", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"degrees": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.degrees_to_gradians",
"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
Invalid or missing input fails with a clear invalid_input error instead of inventing a number.
How to call the API and what comes back
Absolute values must stay within the published limit of one trillion. Send a JSON body with one required finite number field named degrees. Aliases deg, d, value, angle, and input are accepted so SDK clients and form posts can use the name that fits the product. On success the response echoes rounded degrees and deg, sets gradians, result, and converted to the same rounded gradian magnitude, unit to the token gon, from_unit to deg and to_unit to gon, factor to the rounded ten ninths scale, formula to the string gradians equals degrees times open parenthesis ten slash nine close parenthesis, message to a short English summary, and steps to an ordered array of substitution lines that show the full-turn anchors and the multiply. Failed validation—missing fields, non-finite numbers, bare plus or minus signs, non-numeric strings, values outside absolute limits, or a non-finite converted result—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, checks, and related searches
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately omit degrees or pass text.
Technical questions
Can I convert gradians back to degrees?
This capability is degrees → gradians only. Use degrees = gradians × (9/10) on your side, or a bidirectional angle converter for other units.
What happens on missing or non-numeric input?
The API returns invalid_input naming the problem (for example a missing degrees field). Failed tasks are not charged.