TV mounting height calculator
With your eyes at 42 inches on the sofa and a screen 27 inches tall, the bottom of the TV goes at 28.5 inches and the center lands at eye level. Enter both measurements in one unit to get the bottom, center and top marks. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Eye level
- 42
- Screen height
- 27
- Half screen
- 13.5
- Mounting height
- 28.5
- Center height
- 42
- Top height
- 55.5
Mounting a television too high is the most common living-room installation mistake: the panel hangs like a cinema hall while the viewer sits on a sofa, and the neck tilts up for the entire film. This TV mounting height calculator takes two positive measurements — viewer eye level from the floor and the visible TV screen height, not the boxed diagonal — and returns the mounting height from the floor to the bottom of the screen so the geometric center of the panel sits exactly at seated or standing eye level. Keep both numbers in one linear system: inches in yield inches out, centimetres in yield centimetres out. When half the screen is as tall as or taller than eye level, the bottom would sit at or below the floor and the task fails instead of returning a negative mark.
How ideal TV mounting height is computed from eye level
Ergonomic viewing, SMPTE and THX home-theatre notes, and most manufacturer wall-mount charts agree on one geometric rule: the centre of the picture should sit at the viewer’s eye height, not at standing head height and not at an arbitrary ‘sixty inches to the middle’ rule of thumb copied from a store display. Then take the visible screen height of the panel — the glass, not the boxed diagonal printed on the carton. A fifty-five-inch sixteen-by-nine television is about twenty-seven inches tall; a sixty-five-inch set is about thirty-two.
The calculator does not convert diagonals for you because aspect ratio, overscan, and soundbar-ready stands all change the number; you send the height you intend to centre. A typical seated living-room case — forty-two inches of eye height and a twenty-seven-inch-tall fifty-five-inch set — yields a mounting height of twenty-eight and a half inches, a centre at forty-two, and a top at fifty-five and a half. Units never convert: the arithmetic is the same in centimetres or millimetres, which is why a mixed pair is treated as one system.
Where a TV mounting height calculator earns its keep
Homeowners hanging a first wall-mount in a living room need a number they can transfer from a sofa measurement to a pencil line on the plaster, not a forum thread that says ‘put the middle at sixty inches’ regardless of who sits where. Custom-install shops, furniture retailers who sell packages of sofa plus television, and property managers refreshing dozens of identical apartments can drop seated eye level and panel height from a takeoff sheet into this calculator and reuse the mounting height across a floor plate.
Interior-design studios can pair the result with a room elevation and show the client the bottom, centre, and top in one response instead of sketching the subtraction by hand.
What you can do with it
Living-room sofa wall mount
Measure seated eye height on the sofa you will actually use, look up the panel’s visible height, and mark the floor-to-bottom mounting height so movie nights do not become a neck-tilt.
Bedroom, kitchen, and standing installs
Use standing eye level (often 60–65 inches) with the same screen height when the television is viewed while dressing, cooking, or using a treadmill rather than from a low sofa.
Installer takeoffs and identical units
Property managers and custom-install shops reuse one eye-level and screen-height pair across a floor plate of identical apartments instead of re-deriving the subtraction on every elevation.
FAQ
Is screen height the same as the TV’s diagonal size?
No. A 55-inch television is the boxed diagonal; a 16:9 55-inch panel is about 27 inches tall.
Should I use sitting or standing eye level?
Use the posture you will actually watch from. A typical sofa is about 40–42 inches (102–107 cm) to the eyes; standing kitchen or gym viewing is often 60–65 inches. The formula does not assume a posture.
What if the TV is taller than twice my eye level?
Centering that panel on the eyes would put the bottom at or below the floor, which is not a mountable height.
How do I measure my eye level for the calculation?
Sit on the sofa you will actually use and measure from the finished floor to your pupils. On a typical sofa that is about 40 to 42 inches, or 102 to 107 cm.
Is the 60-inch rule for the middle of the TV right?
Not for most living rooms. It is a rule of thumb copied from store displays. The center of the picture should sit at the eye height of the person watching, which for someone seated on a sofa is usually lower.
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/image/tv-mounting-height \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"eye_level":42,"screen_height":27}'const res = await fetch("https://api.kit.forhosting.com/image/tv-mounting-height", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"eye_level": 42,
"screen_height": 27
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/image/tv-mounting-height",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"eye_level": 42,
"screen_height": 27
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/tv-mounting-height", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"eye_level":42,"screen_height":27}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"eye_level":42,"screen_height":27}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/tv-mounting-height", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"eye_level": 42,
"screen_height": 27
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "image.tv_mounting_height",
"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_mb | 15 |
max_megapixels | 12 |
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
Zero, negative, missing, or non-finite measurements fail with invalid_input and are not billed.
How ideal TV mounting height is computed from eye level
Sit on the sofa you will actually use, measure from the finished floor to the pupils, and that number is eye_level. With those two positives the identity is a single subtraction: mounting_height equals eye_level minus half of screen_height. That mounting height is the distance from the floor to the bottom edge of the screen, which is the mark an installer actually draws before locating the bracket. The response also returns half_screen, center_height (equal to eye_level), and top_height (eye_level plus half the panel) so a sketch on the wall can show the full rectangle. Standing kitchen or gym installs use a higher eye_level, often around sixty to sixty-five inches, and the same formula.
Input contract, response fields, and validation errors
Both must be strictly positive. POST a JSON body with two required finite numbers: eye_level, the viewer’s eye height from the finished floor to the pupils, and screen_height, the visible panel height in the same linear units. The solver also accepts the aliases eye_height and viewer_eye_level for the first field, and tv_height and height for the second; errors are reported against the canonical names so the web form can mark the right control. On success the body echoes the cleaned eye_level and screen_height, returns half_screen as screen_height divided by two, mounting_height as the floor-to-bottom mark, center_height as the floor-to-centre mark (equal to eye_level), and top_height as the floor-to-top mark. A formula string restates the identity mounting_height equals eye_level minus screen_height over two, and a unit_note reminds clients to keep one linear system. Missing fields, empty strings, non-numeric tokens, NaN, Infinity, zero, and negative values all fail with invalid_input and a message that names the field; those failures are not billed. If the arithmetic would put the bottom of the television at or below the floor — that is, if half of screen_height is greater than or equal to eye_level — the task also fails with invalid_input rather than returning a negative mounting height that no bracket can honour. Example: eye_level forty-two and screen_height twenty-seven returns mounting_height twenty-eight point five. Successful API calls use the published base of $0.002 per item; the free browser path runs the same solve function without consuming prepaid balance.
Where a TV mounting height calculator earns its keep
Keep both measurements positive and finite, keep screen_height less than twice eye_level, pin the rounded mounting_height in your tests, and you get a reproducible floor-to-bottom mark for a weekend install, a showroom tablet, a renovation spreadsheet, or an edge worker without standing up a full home-theatre layout engine for a two-number wall problem.
Technical questions
How do I calculate TV mounting height from eye level?
Send positive finite numbers eye_level (floor to pupils) and screen_height (visible panel height, not the diagonal). The API returns mounting_height = eye_level − screen_height/2, the floor-to-bottom mark that puts the screen center at eye level.
What does the TV mounting height calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.