ForHosting KIT · Developer Utilities

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.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

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.

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.

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.

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.

POSThttps://api.kit.forhosting.com/algebra/distribute-expression

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.

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)"}'
{
  "expression": "3x(2x - 5 + y)"
}
{
  "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.

Per request$0.002

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

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →