Binary multiplication calculator
Multiply two binary numbers and see every shift-and-add row: 1011 times 110 gives 1000010, built from one skipped row and two added ones. Each row shows the shifted multiplicand and the running total. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Multiplicand
- 1011
- Multiplier
- 110
- Product
- 1000010
- Equation
- 1011 × 110 = 1000010
This binary multiplication calculator multiplies two unsigned base-2 integers and shows how the answer is assembled. For every bit in the multiplier, it shifts the multiplicand to the correct place, identifies whether that row is added or skipped, and reports the accumulator after the step. The final response includes normalized operands, every partial product, the completed binary product, and a compact equation. Because calculation uses binary string arithmetic instead of floating-point numbers, the result stays exact even for inputs much longer than ordinary machine integers.
Enter two binary integers and read the result
Provide the multiplicand and multiplier as strings made entirely from 0 and 1. An optional 0b prefix is accepted on either operand, and insignificant leading zeros are removed before the calculation is displayed. The calculator treats both values as unsigned integers, so signs, decimal points, separators, and embedded spaces are rejected instead of being guessed.
The response starts with the normalized operands and ends with product, equation, and method fields. Each row records the bit position, the multiplier bit, the shifted multiplicand, whether the operation is add or skip, the row's partial product, and the accumulator after processing it. This makes the output useful both as a quick answer and as an auditable explanation of how that answer was obtained.
Understand the shift-and-add partial products
Binary long multiplication is especially direct because every multiplier digit is either zero or one. At bit position zero, the multiplicand is unchanged. At position one it is shifted left once by appending one zero, which multiplies its value by two.
Position two appends two zeros and multiplies it by four, and the same pattern continues for every higher position. When the current multiplier bit is one, that shifted value becomes a partial product and is added to the running accumulator. When the bit is zero, the row contributes zero and the operation is marked skip.
The calculator still includes skipped rows because they explain alignment and prevent a sparse answer from hiding where zeros occurred in the multiplier. Binary addition itself proceeds from right to left with a carry, so no decimal conversion or floating-point approximation is involved. Reading those values in sequence shows the complete algorithm: shift according to place value, select according to the bit, add the selected row, and repeat until no multiplier bits remain.
Use exact binary multiplication in lessons and systems
The structured output fits several kinds of work. In a digital logic lesson, the rows connect positional notation to the shift registers, adders, and control decisions used by a simple hardware multiplier. In programming exercises, they provide reference values for testing a custom bitwise multiplication routine without reducing the explanation to a single opaque product.
In debugging, the running accumulator makes an off-by-one shift easy to locate: compare rows until the first accumulator differs, then inspect that bit position and its selected partial product. Inputs are bounded to keep response size predictable, since the multiplier creates one row per bit, but arithmetic within that bound is exact and deterministic.
What you can do with it
Teach binary long multiplication
Show learners how each multiplier bit selects a shifted partial product and changes the running sum.
Check digital logic exercises
Compare expected shift-and-add rows with a hardware multiplier, emulator, or HDL simulation trace.
FAQ
What input format is accepted?
Use unsigned strings containing only 0 and 1. You may include an optional 0b prefix, but signs, spaces between digits, and fractional points are not accepted.
Why are zero-bit rows included?
A zero multiplier bit contributes no value, but its row preserves the place alignment and shows explicitly why the shifted multiplicand was skipped.
Does the calculator convert through decimal numbers?
No. It adds binary strings directly, so the calculation does not lose precision through floating-point conversion.
Which direction are partial products listed?
They begin with bit position zero, the rightmost and least significant multiplier bit, then proceed left toward higher positions.
Why does each shift multiply the row by two?
Because binary is positional. Appending one zero at position one doubles the value, two zeros at position two multiply it by four, and the pattern continues for every higher bit of the multiplier.
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/elec/binary-multiplication \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"multiplicand":"1011","multiplier":"110"}'const res = await fetch("https://api.kit.forhosting.com/elec/binary-multiplication", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"multiplicand": "1011",
"multiplier": "110"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/elec/binary-multiplication",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"multiplicand": "1011",
"multiplier": "110"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/binary-multiplication", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"multiplicand":"1011","multiplier":"110"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"multiplicand":"1011","multiplier":"110"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/binary-multiplication", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"multiplicand": "1011",
"multiplier": "110"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "elec.binary_multiplication",
"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.
Limits
max_bits | 512 |
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
Enter two binary integers and read the result
Between them is a partial_products list ordered from the least significant multiplier bit toward the most significant bit. That ordering mirrors the way pencil-and-paper multiplication is normally performed: inspect the rightmost bit, create its row, then move left one position at a time.
Understand the shift-and-add partial products
The accumulator_after value captures the sum immediately after each row.
Use exact binary multiplication in lessons and systems
The same input always returns the same JSON, with no network request, random value, timestamp, or machine-dependent numeric rounding. You can run the browser calculator freely for interactive work or call the API for $0.002 per request when generating worksheets, validating emulator output, checking HDL test vectors, or adding reproducible binary arithmetic steps to another application.
Integration use cases
Test exact arithmetic code
Generate deterministic products and intermediate accumulators for unit tests of binary arithmetic implementations.
Technical questions
How much does an API calculation cost?
Each API request costs $0.002. The interactive browser version can run locally without an API call.