ForHosting KIT · Math

Multiplying radicals calculator

Multiply two roots and get the product in simplest form: √8 times √2 is 4. Roots with different indices are first brought to a common index, then every perfect power is pulled out of the root. 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

Radicand a: 8
Index a: 2
Radicand b: 2
Index b: 2

You get

Coefficient: 4
Index: 1
Radicand: 1
Expression: 4

Multiplying radicals is a core algebra skill: the product of two roots is another root, and that product is then rewritten in simplest form. This multiplying radicals calculator accepts the radicand and the index of each factor, applies the identity that the n-th root of a times the m-th root of b equals the L-th root of a to the power L over n times b to the power L over m, where L is the least common multiple of the two indices, and then extracts every perfect L-th power from the combined radicand. The response is the simplified triple of coefficient, index, and remaining radicand, plus a display string and a numeric product you can pin in tests. Any non-finite value is rejected the same way.

What the product of two radicals means and how it simplifies

A radical ⁿ√a is the principal real n-th root of the radicand a. When two such roots are multiplied, the product rule for radicals says they combine under a common index. If the indices are already equal, ⁿ√a · ⁿ√b equals ⁿ√(a·b) and you only need to simplify the single resulting root.

If the indices differ, rewrite both factors with L equal to the least common multiple of n and m: ⁿ√a becomes ᴸ√(a^{L/n}) and ᵐ√b becomes ᴸ√(b^{L/m}), so the product is ᴸ√(a^{L/n} · b^{L/m}). Simplifying then means peeling out every perfect L-th power as an integer coefficient and leaving an L-power-free radicand. The remaining index can shrink when every leftover exponent shares a common factor with L: sixth root of 324 is cube root of 18 after dividing exponents and index by two.

Signs are tracked separately because an even power would otherwise hide a negative radicand: the cube root of negative eight times the square root of four is negative four, not positive four. When the leftover radicand is one, the product is a rational number and the calculator returns index one with radicand one, so clients can treat a fully simplified integer such as twelve as a plain coefficient.

What you can do with it

Classroom and homework checks

Let students enter two radicands and indices and verify the simplified product against the common-index method used in textbooks.

Exam and LMS auto-grading

Mark multiplying-radicals items with a deterministic oracle that rejects a negative radicand with an even index and never invents a complex root.

Notebooks that reduce nested roots

Multiply and simplify two real radicals in calibration or geometry scripts without importing a full computer-algebra library.

FAQ

How do I multiply two radicals with the same index?

Send the two radicands and the shared index. The product is the same-index root of the product of the radicands, then simplified by extracting perfect powers (for example √8 · √2 = √16 = 4).

How do I multiply radicals that have different indices?

Send both indices. The calculator rewrites the factors with L = lcm(n, m) so ⁿ√a · ᵐ√b = ᴸ√(a^{L/n} · b^{L/m}), then extracts perfect L-th powers. √8 · ∛2 becomes 2 · ⁶√32.

Why is a negative radicand with an even index rejected?

Even-index roots of negative numbers are not real. Odd-index negatives are accepted and the sign is carried on the coefficient.

What does the simplified result contain?

A fully rational product uses index 1 and radicand 1.

Can I multiply the cube root of a negative number?

Yes. An odd root of a negative number is negative, and the sign is carried into the coefficient: the cube root of −8 times the square root of 4 is −4, not 4.

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/math/multiplying-radicals

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/multiplying-radicals \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"radicand_a":8,"index_a":2,"radicand_b":2,"index_b":2}'

const res = await fetch("https://api.kit.forhosting.com/math/multiplying-radicals", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "radicand_a": 8,
    "index_a": 2,
    "radicand_b": 2,
    "index_b": 2
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/multiplying-radicals",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "radicand_a": 8,
    "index_a": 2,
    "radicand_b": 2,
    "index_b": 2
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/multiplying-radicals", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"radicand_a":8,"index_a":2,"radicand_b":2,"index_b":2}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"radicand_a":8,"index_a":2,"radicand_b":2,"index_b":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/multiplying-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

{
  "radicand_a": 8,
  "index_a": 2,
  "radicand_b": 2,
  "index_b": 2
}

Example response

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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_abs_radicand`	1000000000000
`min_index`	2
`max_index`	24

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

A negative radicand with an even index is not a real number and fails with invalid_input instead of a complex placeholder.

Input contract, response shape, and error behaviour

Indices must be integers from two through twenty-four; two is a square root and three is a cube root. Odd-index negatives are legal: the cube root of a negative number is negative, and the sign is folded into the coefficient of the product. POST a JSON body with four required finite numbers: radicand_a and index_a for the first radical, radicand_b and index_b for the second. Each radicand may arrive as a JSON number or as a numeric string, including a rational that converts exactly to a fraction. Aliases a and n for the first factor and b and m for the second are accepted so scripts can reuse common textbook names. Missing fields, empty strings, and non-finite values fail with invalid_input naming the field. On success the body echoes the four inputs, returns coefficient, index, and radicand of the simplified product, an expression string such as 2√6 or 2[6]√32, an unsimplified display of the original factors, a product_value rounded to twelve decimal places for stable goldens, and a formula string restating the common-index identity. Example: radicand_a eight, index_a two, radicand_b two, index_b two is the square root of eight times the square root of two, which simplifies to four.

Where a multiplying-radicals API earns its keep

Classrooms and tutoring platforms use a multiplying radicals calculator so learners can check the product rule and the extraction of perfect powers without losing a factor of two when they combine square roots of eight and eighteen. Exam-prep generators need a deterministic oracle that marks a negative radicand with an even index as invalid instead of silently returning NaN that a buggy grader might treat as success. Failed validation does not consume balance. Science and engineering notebooks often reduce nested roots that appear after multiplying characteristic lengths or wave amplitudes; calling a tiny parse endpoint avoids pulling a full computer-algebra system for two indices and two radicands. Keep requests inside the published magnitude and index limits, pin the rounded product_value and the expression string in tests, and you get reproducible simplified products for homework, LMS plugins, and edge workers without standing up symbolic math infrastructure of your own.

Technical questions

What does the multiplying 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.

Read the full KIT documentation →

Run — free