Rhombus calculator
Enter the two diagonals of a rhombus, or one side and an angle, and get the rest: diagonals of 6 and 8 give a side of 5, an area of 24 and a perimeter of 20. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- First diagonal length
- 6
- Second diagonal length
- 8
- Calculation mode
- diagonals
- Side
- 5
- Angle deg
- 106.2602047083
- Area
- 24
This calculator turns the two classic rhombus inputs into the metrics you need for homework, design, and code: area, perimeter, and side length, plus the complementary diagonals or angle so every answer is self-consistent. From diagonals it uses the half-product formula for area and Pythagoras on the half-diagonals for the side; from side and angle it multiplies side squared by the sine of the angle and recovers both diagonals with half-angle identities.
How the closed forms are evaluated: diagonals mode and side-angle mode
In diagonals mode the engine requires both d1 and d2 to be finite and strictly greater than zero; a zero or negative diagonal is rejected immediately because it cannot form a non-degenerate rhombus and the half-product area formula would otherwise hide the defect. Area is half the product of the diagonals.
The four half-diagonal legs meet at the center in four right triangles, so the side equals the square root of the sum of the squares of d1 over two and d2 over two, and the perimeter is four times that side.
The included angle in degrees is recovered from the placement of the diagonals on the coordinate axes: side vectors leaving a vertex yield a cosine equal to the difference of the squared half-diagonals over the squared side, and arccos of the clamped value returns a unique angle in the open interval from zero to one hundred eighty degrees. Area is side squared times the sine of the angle in radians.
The diagonals follow from the half-angle identities: d1 equals two times side times the sine of half the angle, and d2 equals two times side times the cosine of half the angle, both of which stay positive inside the open angle interval. Optional precision only rounds the published fields; the internal solve always uses full double precision before that final rounding step.
What you can do with it
Homework and exam preparation
Compute rhombus area, perimeter, and side from textbook diagonals or from side and included angle, and verify that non-positive diagonals are rejected.
Tiles, CAD, and simulation
Size diamond tiles, braced lattices, or isometric cells from known diagonals or from edge length and angle in design and game tools.
FAQ
What does the rhombus calculator cost?
It is free in your browser on this page.
Can I use side and angle instead of diagonals?
Do not mix that mode with d1 and d2 in the same request.
How is area calculated?
From diagonals: area = (d1 × d2) / 2. Both paths are exact closed forms in floating-point arithmetic.
How is the side found from the diagonals?
The diagonals cross at right angles and cut each other in half, forming four right triangles. With diagonals of 6 and 8 the halves are 3 and 4, so Pythagoras gives a side of 5 and a perimeter of 20.
What happens if a diagonal is zero or negative?
The calculator stops with an error straight away. A zero or negative diagonal cannot form a real rhombus, and the area formula would otherwise hide the mistake.
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/geom/rhombus \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"d1":6,"diagonal1":1}'const res = await fetch("https://api.kit.forhosting.com/geom/rhombus", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"d1": 6,
"diagonal1": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geom/rhombus",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"d1": 6,
"diagonal1": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geom/rhombus", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"d1":6,"diagonal1":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"d1":6,"diagonal1":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/rhombus", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"d1": 6,
"diagonal1": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geom.rhombus",
"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
Enter two positive finite diagonals, or a positive side with an included angle between the sides; the engine rejects zero, negative, or non-finite diagonals with invalid_input instead of returning a silent NaN. Through the API a successful request costs $0.002; validation failures are not charged.
What a rhombus calculator returns and which inputs it accepts
A rhombus is a quadrilateral with four equal sides; opposite angles are equal, consecutive angles are supplementary, and the diagonals bisect each other at right angles. Those properties give two practical measurement paths that textbooks and CAD packages use every day: measure the two diagonals, or measure one side and one included angle. This tool exists to turn either pair into a single deterministic response without forcing you to remember whether area is half the product of the diagonals, how to rebuild the side from the right triangles formed by the half-diagonals, or how sine of the vertex angle scales the square of the side. If you need an ellipse from semi-axes, a triangle SSA solver, or polygon area by the shoelace formula, use a tool dedicated to those problems; the search intent here is rhombus area, perimeter, and side from diagonals or from side and angle, with a clear answer or an honest error when a diagonal is not positive. Preferred inputs for diagonals mode are the scalars d1 and d2 as JSON numbers; aliases diagonal1, diagonal_1, and p map to the first diagonal, and diagonal2, diagonal_2, and q map to the second. For side-and-angle mode the preferred fields are side and angle, with aliases a, s, and length for the side, and theta, included_angle, or the Greek letter for the angle. The response always reports mode, both diagonals, side, angle_deg, area, perimeter, an is_square flag when the diagonals match, and formula strings for the main identities so a student or a log line can verify the result without reading the source. Missing a complete mode, mixing both modes, a non-positive diagonal, a non-positive side, or an angle not strictly inside the open interval from zero to one hundred eighty degrees all raise invalid_input with a message that names the failing field. That discipline keeps automated tests stable, makes caching safe, and prevents a script from treating a collapsed segment as a real rhombus.
How the closed forms are evaluated: diagonals mode and side-angle mode
In side-and-angle mode the engine requires a positive finite side and an angle strictly between zero and one hundred eighty degrees when angle_unit is degrees, or strictly between zero and pi when the unit is radians. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the half-product area or the side-from-diagonals square root yourself.
Where rhombus metrics fit in study, design, and code
Students meet the rhombus when a textbook asks for area from diagonals, when an exam demands the side length given two diagonal measures, or when analytic geometry homework wants perimeter after an included angle is stated with the common side. Teachers can pre-generate answer keys that list area and perimeter for integer diagonals, and that refuse zero or negative diagonals instead of printing NaN. Flooring and tile work often sizes diamond patterns from the two diagonals of a single tile, while fabric and paper craft measure one edge and a fold angle; knowing that a requested diagonal is not positive is as valuable as the number itself. Surveying and CAD workflows place rhombi as construction geometry for lattices and braced frames, and game or simulation teams use area and side for diamond hitboxes, isometric cells, and level kits that should stay deterministic across platforms. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with other free geometry endpoints when you need ellipse metrics, chord length, or triangle solvers for a lab of deterministic tools, and with documentation that shows both diagonals and the finished metrics so the numbers and the picture stay aligned for learners and reviewers. Whether you arrived searching for a rhombus calculator or for diamond area from diagonals, the contract is the same: positive diagonals or a valid side and angle in, finite metrics or a clear invalid_input out.
Integration use cases
Deterministic geometry fixtures
Generate reproducible rhombus metrics for unit tests, contest validators, and CI assertions without hand-rolled half-product or half-angle logic.
Technical questions
What if a diagonal is zero or negative?
The handler returns invalid_input with a message that the diagonal must be a positive finite number.
Can I control rounding?
Yes. Set precision (aliases decimals, dp) to an integer from 0 to 15; the default is 10 decimal places on all numeric fields.