Simplify radicals calculator
The square root of 72 simplifies to 6√2, because 72 is 6 squared times 2. Enter a positive whole number and get the exact form a√b, with every square factor pulled out and the prime factors listed. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 72
- A
- 6
- B
- 2
- Original
- √72
- Simplified
- 6√2
Simplifying a radical of a positive integer means rewriting the square root of n in the exact form a times the square root of b, where a is a positive integer and b is square-free. Students meet this rewrite in Algebra 1 when a worksheet asks them to simplify the square root of seventy-two and expect six times the square root of two, not a rounded decimal. This simplify radicals calculator factors n, pulls every squared prime factor into the outside coefficient a, and leaves the leftover square-free integer b under the radical.
What it means to write √n as a√b with b square-free
Simplifying a square-root radical is the exact rewrite that turns the square root of a positive integer n into the product a times the square root of b, written a√b, where a is a positive integer and the leftover radicand b is square-free. Square-free means that no perfect square other than one divides b: every prime that remains under the radical appears with exponent one.
The identity is algebraic, not numeric: n equals a squared times b, therefore the square root of n equals a times the square root of b. Evaluation would replace the root with a rounded decimal that cannot be added exactly to another radical later; simplification keeps the exact form a teacher expects on an Algebra 1 worksheet.
Classic examples include the square root of seventy-two becoming six times the square root of two, because seventy-two factors as two cubed times three squared, so one two and one three come out as the coefficient six and a single two stays under the radical. The square root of fifty becomes five times the square root of two. The square root of twelve becomes two times the square root of three.
When n is already square-free, as with seven, ten, or fifteen, the coefficient a is one and b equals n. When n is a perfect square, b is one and the simplified result is the ordinary integer a, as in the square root of thirty-six equals six.
How n is read, factored, and split into coefficients a and b
Send one required field n, the positive integer under the square root. Internally the engine factors n by trial division, then for each prime power p to the e it extracts p to the floor of e over two into a and leaves p to the remainder of e modulo two inside b. That is the same textbook process of pulling every squared factor out from under the radical, not a floating-point square root with a rounding tolerance.
Failed validation is not billed. Use this contract when you need the two coefficients rather than a decimal approximation, and pin both a and b in automated checks so a pretty-printer cannot drift from the algebraic rewrite that Algebra 1 actually grades.
Where a simplify-radicals calculator earns its keep
Algebra classrooms and tutoring platforms use a simplify radicals calculator so learners can check the extracted coefficient and the leftover square-free radicand without losing a squared factor by hand. Exam-prep generators need a deterministic oracle that rejects zero, negatives, and fractions instead of inventing a principal square root in the complexes or returning a silent empty list. Teachers can pre-generate answer keys for modest radicands without trusting opaque calculator apps that silently switch to decimals.
Failed validation does not consume balance. Keep requests inside the documented limits, pin both coefficients in tests, and you get reproducible simplified radicals for homework, LMS plugins, and edge workers without standing up symbolic math infrastructure of your own.
What you can do with it
Algebra 1 homework checks
Let students submit a positive integer n and verify that √n rewrites as a√b with the leftover radicand square-free, matching the textbook form.
Exam and LMS auto-grading
Mark simplify-the-radical items with a deterministic oracle that returns a and b, rejects non-positive input, and never invents extra square factors.
FAQ
What happens if n is not a positive integer?
Zero, negatives, fractions, empty values, and non-integers are rejected. Failed validation is not billed.
What does it mean when b equals 1?
The leftover radicand is 1, so n was a perfect square.
How is square-free leftover b computed?
The engine factors n by trial division. For each prime power p^e it extracts p to the floor of e over 2 into a and leaves p when e is odd inside b. Then n = a² · b and b has no squared prime factor.
What if the number has no square factor?
Then nothing can come out of the root: the coefficient is 1 and the number stays under the radical unchanged. That is the case for 7, 10 or 15, which contain no square factor at all.
Why keep the root instead of a decimal?
Because the exact form can still be combined with other radicals later, while a decimal is already rounded. A worksheet that asks for the square root of 72 expects 6√2, not an approximation.
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/math/simplify-radicals \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":72}'const res = await fetch("https://api.kit.forhosting.com/math/simplify-radicals", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 72
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/simplify-radicals",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 72
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/simplify-radicals", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":72}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":72}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/simplify-radicals", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"n": 72
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.simplify_radicals",
"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
min_n | 1 |
max_n | 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
Inputs that are not positive integers are rejected with invalid_input instead of a guessed decimal root. Successful API calls are billed at $0.002; invalid input is not charged.
How n is read, factored, and split into coefficients a and b
Aliases value and radicand are accepted so spreadsheets, typed forms, and query strings can reuse the same contract. The field may arrive as a JSON integer or as a signed digit string; missing n, empty strings, fractions, scientific notation, zero, negatives, and values outside the published magnitude limit all fail with invalid_input naming the field. On success the body echoes n, returns the outside coefficient a and the square-free leftover b, flags is_perfect when b is one, lists the prime factors of n, and supplies original and simplified radical strings plus the identity formula.
Where a simplify-radicals calculator earns its keep
Engineering notebooks and CAS-lite scripts often reduce exact geometric lengths, such as the diagonal of a rectangle or the hypotenuse of a Pythagorean triple, to a coefficient times a square-free radical before further symbolic work; calling a tiny parse endpoint avoids pulling a full computer-algebra library for a one-integer problem.
Integration use cases
Exact radical fixtures in software
Normalize integer square roots to a times a square-free leftover in tests, notebooks, and pretty-printers without standing up a full computer-algebra system.
Technical questions
How do I simplify a radical with this calculator?
Send a positive integer n (aliases value or radicand). The API factors n, pulls every squared prime into coefficient a, leaves square-free b under the radical, and returns a, b, plus original and simplified strings such as √72 and 6√2.
What does the simplify radicals calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.