Hexagonal pyramid surface area
A hexagonal pyramid with a base side of 2 and a slant height of 3 has a total surface of about 28.392: 18 for the six triangular faces, the rest for the hexagonal base. Enter both lengths and get all three areas. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Base side
- 2
- Slant height
- 3
- Base area
- 10.3923048454
- Lateral surface area
- 18
- Surface area
- 28.3923048454
A regular hexagonal pyramid stands on a regular hexagon and rises to an apex directly above its center, so its surface is one hexagonal base plus six congruent isosceles triangular faces. Given the side length of the hexagonal base and the slant height — the altitude of each triangular face measured from the midpoint of a base edge to the apex — this calculator returns the hexagonal base area, the lateral surface area of the six triangles, and the total surface area using the textbook closed-form formulas. It is the parametrization you meet in solid-geometry exercises, where the slant height is given directly rather than the perpendicular height of the solid.
How the surface area is computed
Label the side length of the regular hexagonal base as a and the slant height as l. The slant height is not the perpendicular height of the pyramid: it is the altitude of one triangular lateral face, running from the midpoint of a base edge up the face to the apex, and it is exactly the quantity given in most textbook statements of this problem.
Each lateral face is a triangle with base a and height l, hence area (1/2) a l, and six congruent faces give a lateral surface area of (1/2) times the base perimeter times the slant height: (1/2)·6a·l, which simplifies to 3 a l. Because the path uses only multiplication and a single square root of three, it is deterministic, constant time, and free of iterative solvers or approximations.
Where this calculation shows up in real work
Secondary-school and college solid-geometry courses constantly ask for the surface area of a regular hexagonal pyramid given the base side and the slant height, because that pairing exercises the lateral-area formula half perimeter times slant without a Pythagorean detour; a trusted calculator with a strict positive-input gate speeds homework grading and removes spreadsheet mistakes where someone uses a square-base perimeter or forgets the hexagonal base area entirely.
Architecture, roofing, and fabrication workflows measure slant heights directly on the drawing or the physical template — the distance from eave midpoint to ridge point along the panel — so cladding, paint, and panel takeoffs for hexagonal tent peaks, pavilion roofs, monument caps, and decorative planters map naturally onto this parametrization without deriving the vertical height first. Packaging and point-of-sale designers working with hexagonal pyramid displays get deterministic material estimates from the same two measurements taken off a die line.
Game, graphics, and CAD tools that store regular pyramid primitives can echo method plus the two inputs so debug property panels stay self-describing. If you need the volume, the perpendicular-height parametrization, a frustum, or a different base polygon, treat those as separate search intents rather than overloading this landing.
What you can do with it
Homework and exam checks
Compute the total surface area of a regular hexagonal pyramid from base side and slant height, and reject non-positive inputs with a clear error.
Cladding and material takeoffs
Turn the eave-to-ridge slant measured on a hexagonal roof or tent peak into lateral and total surface figures for panels, paint, and fabric.
FAQ
What exactly is the slant height here?
It is the altitude of each triangular lateral face: the distance from the midpoint of a base edge to the apex measured along the face. It is not the perpendicular height of the pyramid; the two are related by l = √(h² + 3a²/4).
Can I pass the values as strings?
Non-numeric, empty, NaN, or Infinity values are rejected.
How do I calculate the surface area of a hexagonal pyramid?
Add the area of the hexagonal base to the area of the six triangular faces. With a base side of 2 and a slant height of 3, the faces give 18, the base six times the square root of three, and the total is about 28.392.
How is the lateral area of a hexagonal pyramid found?
Each face is a triangle with the base side as its base and the slant height as its height, so its area is half their product. Six faces make three times the side times the slant height, which is 18 for a side of 2 and a slant of 3.
What if I know the vertical height instead of the slant height?
Convert it first: add the square of the height to three quarters of the square of the base side, then take the square root. This calculator works only from the base side and the slant height of the faces.
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/math/hexagonal-pyramid-surface-area \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"base_side":4,"slant_height":5}'const res = await fetch("https://api.kit.forhosting.com/math/hexagonal-pyramid-surface-area", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"base_side": 4,
"slant_height": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/hexagonal-pyramid-surface-area",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"base_side": 4,
"slant_height": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/hexagonal-pyramid-surface-area", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"base_side":4,"slant_height":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"base_side":4,"slant_height":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/hexagonal-pyramid-surface-area", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"base_side": 4,
"slant_height": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.hexagonal_pyramid_surface_area",
"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
Any input that is not a strictly positive finite number is rejected with a clear invalid_input error instead of a silent nonsense area.
How the surface area is computed
The base is a regular hexagon, which decomposes into six equilateral triangles of side a, so its area is base_area equals (3√3/2) a². The total surface area is the sum of the two parts: surface_area equals (3√3/2) a² plus 3 a l. A classic check is a equals two and l equals three: base_area equals 6√3, lateral equals eighteen, and total equals 6√3 plus eighteen, about 28.392. Extremely large magnitudes can still overflow the IEEE-754 double range; when any partial result is non-finite the request fails with a clear overflow message instead of returning Infinity in JSON, so downstream consumers never ingest a silently broken number.
What you send and what you get back
There is no optional perpendicular height, lateral edge, or apex offset — this landing is the regular centered hexagonal pyramid from side and slant height only; if you hold the perpendicular height instead, convert it first with l equals √(h² + 3a²/4) or use a height-parametrized calculator. Provide two required finite numbers: base_side is the side length of the regular hexagonal base and must be strictly positive; slant_height is the face altitude from base-edge midpoint to apex and must also be strictly positive. Zero, negative, missing, empty, non-numeric, NaN, and Infinity values are rejected with invalid_input and are not charged. On success the JSON response echoes base_side and slant_height, then returns base_area, lateral_surface_area, surface_area, and method set to regular_hexagonal_pyramid_surface_from_slant so logs and teaching UIs can document the algorithm. API pricing is the published base of $0.002 per successful item.
Where this calculation shows up in real work
Because this capability is a pure parse engine, failed validation does not consume balance and successful runs stay at $0.002 per item.
Integration use cases
Deterministic geometry fixtures
Feed stable base-side/slant-height pairs into unit tests, CAD property panels, and synthetic benchmarks without reimplementing the formula.
Technical questions
What formulas does this calculator use?
Base area = (3√3/2) a² for the regular hexagonal base; lateral surface area = (1/2) × perimeter × slant height = 3 a l; total surface area = base + lateral. The response includes method: "regular_hexagonal_pyramid_surface_from_slant".
What happens if base_side or slant_height is zero or negative?
The request fails with invalid_input. Both values must be strictly greater than zero; the error message names the offending field.
How much does an API call cost?
The published base price is $0.002 per successful item. Requests that fail validation are not charged, and the browser tool is free.