Synthetic division calculator
Dividing x^3 - 6x^2 + 11x - 6 by x - 2 gives x^2 - 4x + 3 with remainder 0, so 2 is a root and the division is exact. Enter the coefficients and r to get the quotient and the remainder. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Coefficients
- 1, -6, 11, -6
- Resistance (Ω)
- 2
- Degree
- 3
- Divisor
- x - 2
- Divisor coefficients
- 1, -2
- Quotient
- 1, -4, 3
Synthetic division is the fast classroom algorithm for dividing a dense univariate polynomial by a monic linear factor of the form x minus r. Given the coefficient list highest degree first and the value r, this capability runs the classical synthetic tableau, returns the quotient coefficient array one degree lower than the dividend, and reports the remainder as a single number. When the remainder is zero, r is a root and the quotient is an exact factor, which is the bridge between the factor theorem and polynomial factorization. Non-linear divisors are rejected with invalid input rather than silently falling back to long division, so the contract matches what synthetic division can legally compute.
What synthetic division computes and how to send coefficients
The monic linear divisor is x minus r; you may send r directly, or send a two-coefficient divisor array that represents any non-zero linear polynomial a x plus b, from which the engine recovers r equals minus b over a. Synthetic division then produces a quotient of degree n minus one whose coefficients are the interior row of the classical tableau, plus a single remainder equal to p of r by the remainder theorem.
If that remainder is zero, the dividend factors exactly as (x minus r) times the quotient, which is exactly the factor theorem used in algebra courses. Constant-only dividends are rejected because there is no genuine division step; extremely high degrees are capped for isolate safety.
Running the synthetic tableau and reading quotient plus remainder
Bring the leading coefficient straight down; multiply by r and add that product to the next dividend coefficient; repeat until every coefficient has been folded. The numbers written in the bottom row before the last cell are the quotient coefficients highest degree first; the final cell is the remainder. The same process is Horner evaluation of p at r when you only keep the last cell, which is why a zero remainder proves that r is a root without a separate evaluation pass.
Missing coefficients, a missing r when no divisor is given, contradictory r and divisor pairs, and non-finite entries all fail the same way and are not charged.
What you can do with it
Homework and tutoring verification
Students and graders confirm quotient coefficients and remainder for cubic and quartic dividends divided by x − r, including clear errors when a non-linear divisor is submitted.
Factor theorem and rational-root drills
Curriculum tools test candidate roots by synthetic division and show exact factorization when the remainder is zero, without installing a computer-algebra package.
FAQ
What if the divisor is not linear?
Synthetic division only supports monic linear factors x − r (or an equivalent two-coefficient linear divisor). Non-linear divisors are rejected and not charged.
What does a zero remainder mean?
By the factor theorem, r is a root of the dividend and the quotient is an exact polynomial factor.
Is the synthetic division calculator free?
The browser tool runs free on your device.
Can I send the divisor as coefficients instead of r?
Yes. Provide divisor as a length-2 array [a, b] for a x + b. The engine recovers r = −b/a.
How do I do synthetic division step by step?
Bring the leading coefficient down, multiply it by r and add the result to the next coefficient; repeat to the end. With 1, -6, 11, -6 and r of 2 the bottom row is 1, -4, 3, and the last cell, 0, is the remainder.
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/algebra/synthetic-division \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"coefficients":[1,-6,11,-6]}'const res = await fetch("https://api.kit.forhosting.com/algebra/synthetic-division", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"coefficients": [
1,
-6,
11,
-6
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/synthetic-division",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"coefficients": [
1,
-6,
11,
-6
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/synthetic-division", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"coefficients":[1,-6,11,-6]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"coefficients":[1,-6,11,-6]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/synthetic-division", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"coefficients": [
1,
-6,
11,
-6
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.synthetic_division",
"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
What synthetic division computes and how to send coefficients
Write the dividend as a_n x to the n plus a_{n-1} x to the n-1 down to the constant a_0, and pack those numbers into one array highest degree first so the first entry is the leading coefficient and the last is the constant term. Degree must be at least one, and the leading coefficient must be non-zero: a zero leading term is invalid input so callers stay responsible for declaring the intended degree.
Running the synthetic tableau and reading quotient plus remainder
This capability always returns cleaned finite numbers, a human-readable polynomial string, a matching quotient polynomial string, the monic divisor text, the optional original divisor coefficients when you supplied them, a boolean factors_exactly flag, and a short identity string that restates dividend equals divisor times quotient plus remainder. Non-linear divisor arrays—for example a quadratic factor—raise invalid_input with an explicit message that only linear factors are supported, because general polynomial division is a different algorithm with a different SEO intent.
API usage, pricing, classroom workflows, and practical limits
Use the free in-browser tool for homework checks, lecture demos, and quick factor-theorem checks without installing Maxima, SymPy, or a local CAS. Send a JSON body with the required coefficients array of finite numbers highest degree first, plus either the numeric field r or a linear divisor coefficient array; aliases coeffs, dividend, root, and zero are accepted where documented. On success the response echoes the cleaned dividend, degree, r, divisor label, quotient array, remainder, factors_exactly, display strings, and the method label synthetic_division. Use the prepaid API when a tutoring platform, coding-assessment sandbox, curriculum generator, or algebra pipeline needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Degree is bounded for Worker isolate safety, and extremely large coefficient magnitudes can suffer ordinary double-precision cancellation, so prefer well-scaled classroom and engineering inputs. Pair this endpoint with a root finder when you only know candidate roots, or call it repeatedly to peel rational roots during manual factorization drills.
Integration use cases
Lightweight algebra pipelines
Scripts that deflate known linear factors call a stable JSON endpoint instead of reimplementing the synthetic tableau in every language or service.
Technical questions
How do I run synthetic division with this API?
Send JSON with coefficients highest degree first (for example [1, -6, 11, -6] for x³ − 6x² + 11x − 6) and r for the divisor x − r (for example r: 2). The response includes quotient coefficients and remainder.