Fourth root calculator
The fourth root of 16 is exactly 2, and the fourth root of 10 is 1.778279410039. Enter any non-negative number and get the value that, used four times as a factor, gives it back, with a note when it is a perfect fourth power. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 16
- Fourth root
- 2
- Integer root
- 2
Send 16 and you get exactly 2; send 10 and you get 1.778279410039, computed with a Newton-refined double square root so the last digit is stable across machines. The response also tells you whether the input is a perfect fourth power — an integer that equals some whole number raised to the fourth power — and, when it is, which integer root produces it. Negative and non-finite inputs are rejected with a clear error instead of a quiet NaN.
What a fourth root actually is
The fourth root calculator answers one question: which non-negative number, multiplied by itself four times, gives this value? That number is written ∜x and called the principal fourth root. Zero maps to zero.
The fourth root is also the square root of the square root — ∜x = √(√x) — which is exactly how the computation begins, and it grows very slowly: ∜10,000 is only 10, and ∜1,000,000,000 is under 178. That slow growth is why fourth roots show up wherever a quantity scales with the fourth power of something else, from beam stiffness to the luminosity of stars.
How the result is computed and rounded
The algorithm is deterministic and needs no network, no lookup table and no randomness. It first applies two nested square roots, then one Newton–Raphson refinement step, y ← (y + x/y³)/2, which cancels the double rounding error the nested square roots can introduce for very large or very small inputs. The final root is rounded to twelve decimal places so that the exact same bytes come back on any machine — an unrounded float like 0.1 + 0.2 would differ between CPUs.
Perfect fourth powers get special treatment: when the input is a safe integer, the nearest integer to the computed root is raised to the fourth power in exact integer arithmetic, and only if that equals the input does the response flag it as a perfect fourth power and return the exact integer root. So 81 reports an integer root of 3, while 80 does not, even though their floating-point roots are close.
What you can do with it
Reverse a fourth-power scaling law
Recover the original quantity from a model where the output grows with the fourth power, such as radiant energy versus temperature or deflection versus beam depth.
Check for perfect fourth powers
Test whether an integer equals some whole number to the fourth power and get that integer root back — useful in number-theory checks and puzzle validation.
Normalize heavily skewed features
Apply a fourth-root transform to machine-learning features with extreme right tails before feeding them to a model.
FAQ
Which fourth root is returned?
Always the principal (non-negative real) root. A positive number also has a negative real root and two complex roots; those are not returned.
How accurate is the result?
The root is computed with two square roots plus one Newton refinement step and rounded to twelve decimal places, so the same input returns byte-identical output on any machine.
What is a perfect fourth power?
An integer equal to some whole number raised to the fourth power, like 16 (2⁴) or 81 (3⁴). When your input is one, the response flags it and returns the exact integer root.
How do I calculate a fourth root by hand?
Take the square root twice. The fourth root is the square root of the square root, so ∜16 is √4, which is 2. The calculator starts the same way and then refines the result.
Why can't I take the fourth root of a negative number?
Because no real number multiplied by itself four times gives a negative result. Negative inputs are rejected with a clear message instead of a meaningless answer, and zero simply returns zero.
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/fourth-root \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":16}'const res = await fetch("https://api.kit.forhosting.com/math/fourth-root", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/fourth-root",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/fourth-root", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/fourth-root", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 16
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.fourth_root",
"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.
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 fourth root API computes the principal fourth root of any non-negative number: the single non-negative real value y such that y⁴ equals your input.
What a fourth root actually is
Every positive number has exactly two real fourth roots, one positive and one negative; the principal root is the non-negative one, which is the convention this endpoint follows and the one used by the <code>Math</code> functions of every major programming language.
Inputs, errors and where it fits
Everything else — integers, decimals, very small fractions, very large magnitudes up to the limits of double precision — returns a root in milliseconds, with nothing ever stored or logged. Teams use it inside larger pipelines: normalizing features that scale with fourth powers, reversing fourth-power models in physics and engineering, or checking whether a count is a perfect fourth power in number-theory tooling. The endpoint accepts a single numeric field, <code>value</code>, also reachable through the aliases <code>n</code>, <code>number</code> and <code>x</code>. Two kinds of input are rejected with a structured <code>invalid_input</code> error: negative numbers, because their fourth root is not a real number, and non-finite values such as NaN or Infinity, which have no meaningful root. The identical code runs free in your browser on this page, so you can verify a value by hand and only pay when you automate the call.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.
What happens with a negative input?
It is rejected with an invalid_input error, because the fourth root of a negative number is not a real number.
What about NaN or Infinity?
Both are rejected with an invalid_input error. The input must be a finite number.