Distributive property calculator
The distributive property calculator expands a factor multiplied by a sum, showing the result of multiplying that factor by every term inside the parentheses.
Run — free
Enter an expression such as 3x(2x - 5 + y), and receive the separated products together with one clean expanded expression. Coefficients are calculated exactly, including decimals and fractions, while matching variable powers are combined automatically. It is a focused way to check algebra homework, prepare worked examples, or add dependable symbolic expansion to an application without relying on a general-purpose computer algebra system.
How to enter an expression
Write one factor next to one parenthesized sum. The factor may appear before the parentheses, as in 3x(2x - 5 + y), or after them, as in (a + 4b) * -2x. An explicit multiplication sign is optional at the edge of the parentheses. Within a monomial, you may use integer, decimal, or fractional coefficients, variable names, multiplication signs, and non-negative integer powers. For example, 1/2x^2 is a valid factor. The expression inside the parentheses must contain at least two terms separated by plus or minus signs. This calculator is deliberately specific: it performs one clear distributive step, so nested groups, functions, and division by variables are rejected instead of being interpreted unpredictably. That narrow contract makes input mistakes visible and keeps the returned algebra suitable for teaching, automated exercises, and validation. If an expression contains several layers of parentheses, distribute one layer at a time and submit the resulting expression again when the next layer has the required shape.
What the calculator does to each term
The algorithm first separates the outside factor from the signed terms in the parenthesized sum. It then multiplies the factor by every term independently, which is exactly the distributive rule a(b + c) = ab + ac. Numeric coefficients are multiplied as reduced rational numbers rather than floating-point approximations. This means a decimal such as 0.25 and a fraction such as 1/4 behave consistently, and a result such as 6/8 is simplified to 3/4. When the same variable occurs in the factor and an inside term, their exponents are added: x^2 multiplied by x^3 becomes x^5. Variables are ordered consistently in the output, making repeated calls easy to compare. The response includes the normalized factor, the normalized inside terms, every multiplied product, the number of terms, and the final expanded expression. It does not combine like terms after distribution, because preserving one output product per input term makes the distributive step transparent and auditable.
Using the result with confidence
Use the expanded expression as a checked intermediate step rather than treating symbolic algebra as a black box. A student can compare each item in the products list with a handwritten multiplication and quickly locate a missed sign or coefficient. A teacher can generate consistent examples whose arithmetic remains exact. A software workflow can inspect the structured fields instead of scraping a formatted equation. The implementation is deterministic: the same valid input always returns the same values, with no network request, random choice, or time-dependent behavior. It also enforces practical bounds on expression length, term count, and exponent size so malformed input cannot trigger unbounded work. The browser version runs the same pure solver used by the API, so an expression checked interactively follows the same algebraic rules when automated later. Browser use is free, while an API request uses the displayed base price of $0.002. If validation fails, the error explains whether the expression is missing, has unsupported syntax, contains the wrong parenthesis structure, or exceeds a documented bound.
What you can do with it
Check algebra homework
Compare each multiplied product with handwritten work and catch a missed negative sign before simplifying further.
Create worked examples
Generate stable, exact expansions for lessons, worksheets, tutoring notes, or answer keys.
Validate symbolic input
Add a bounded distributive step to an educational application and consume structured products instead of parsing display text.
FAQ
What expressions can I expand?
You can expand one monomial factor multiplied by one parenthesized sum of two or more monomial terms.
Does it support negative terms?
Yes. Signs are preserved and multiplied correctly for both the outside factor and every term in the sum.
Can it calculate with fractions and decimals?
Yes. Both are converted to exact reduced rational coefficients, avoiding floating-point rounding errors.
Does it combine like terms?
No. It returns one product for each original term so the distributive step remains visible; combining like terms is a separate simplification operation.
How much does the API cost?
Each API request costs $0.002. The calculator can also run free in your browser.
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/distribute-expression \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"expression":"3x(2x - 5 + y)"}'const res = await fetch("https://api.kit.forhosting.com/algebra/distribute-expression", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"expression": "3x(2x - 5 + y)"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/distribute-expression",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"expression": "3x(2x - 5 + y)"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/distribute-expression", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"expression":"3x(2x - 5 + y)"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"expression":"3x(2x - 5 + y)"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/distribute-expression", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"expression": "3x(2x - 5 + y)"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.distribute_expression",
"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. |