Camera field of view calculator
A 50 mm lens on a 36 by 24 mm full-frame sensor covers just under forty degrees across and nearly forty-seven on the diagonal. Compare lenses and formats before you pack your kit. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Focal length
- 50
- Sensor
- 36
- Sensor
- 24
- Sensor diagonal
- 43.2666153056
- Horizontal aov deg
- 39.597752709
- Vertical aov deg
- 26.9914665616
- Diagonal aov deg
- 46.793003344
Angle of view tells you how wide a scene a lens will cover on a given sensor: a short focal length on a large sensor frames a broad landscape, while a long lens on a small sensor narrows the cone to a tight detail. Photographers, cinematographers, and product engineers compare those angles when matching lenses across full-frame, APS-C, Micro Four Thirds, and smartphone formats, or when planning shots before packing glass. This capability computes the classical rectilinear field of view from focal length and sensor width and height in one consistent unit, returning horizontal, vertical, and diagonal angles in degrees and radians plus the sensor diagonal so pipelines can pin exact numbers in tests.
Reading degrees, radians, diagonal size, and method labels
Unit_note reminds callers that lengths must match; mixing inches for the sensor with millimetres for the lens would silently distort every angle. Use degrees when briefing a shoot or comparing kit lists; use radians when feeding game engines, computer-vision FOV parameters, or scientific notebooks. Validation failures never invent a partial cone of view: zero focal length is rejected explicitly because the formula would divide by zero, matching the product contract for this calculator.
Planning your kit and practical limits
Call the free in-browser camera field of view calculator for quick lens comparisons, classroom demos, and packing lists without installing optical design software. The model is rectilinear and thin-lens: it does not simulate fisheye mapping, distortion profiles, or focus breathing at finite subject distances, so treat results as the standard geometric AOV used in photography education and marketing tables.
Source inputs follow the same retention rules as other KIT parse items, and authors shipping SDKs can map the degree fields straight into tables that list horizontal, vertical, and diagonal columns the way review sites present field of view.
What you can do with it
Lens and body kit comparison
Photographers enter a candidate focal length with full-frame or crop sensor sizes to see how much wider or tighter each combination frames before a shoot or rental.
Shot planning and virtual production
Previs tools convert camera and lens pairs into horizontal and vertical FOV for set layout, LED wall framing, and matching real glass to digital cameras.
Product pages and education
Retail configurators and optics lessons return diagonal AOV alongside datasheet numbers so students and shoppers understand what a 24 mm or 85 mm lens covers on their sensor.
FAQ
How do I calculate camera field of view from focal length and sensor size?
The response includes horizontal, vertical, and diagonal angles in degrees and radians.
What happens if focal length is zero?
Zero focal length is not allowed because the AOV formula divides by focal length; non-positive values are rejected and not charged.
Do I need degrees or radians?
Both are returned. Use *_aov_deg for human-facing tables and *_aov_rad for math, graphics engines, or scientific pipelines.
Is the camera field of view calculator free?
The browser tool runs free on your device.
Does this handle crop factor or APS-C automatically?
Pass the actual sensor width and height for the format you care about. The calculator does not apply a separate crop multiplier; the physical rectangle is the input.
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/hobby/field-of-view \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"focal_length":50,"sensor_width":36,"sensor_height":24}'const res = await fetch("https://api.kit.forhosting.com/hobby/field-of-view", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"focal_length": 50,
"sensor_width": 36,
"sensor_height": 24
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/field-of-view",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"focal_length": 50,
"sensor_width": 36,
"sensor_height": 24
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/field-of-view", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"focal_length":50,"sensor_width":36,"sensor_height":24}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"focal_length":50,"sensor_width":36,"sensor_height":24}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/field-of-view", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"focal_length": 50,
"sensor_width": 36,
"sensor_height": 24
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.field_of_view",
"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
The free browser tool runs entirely on your device; the prepaid API charges $0.002 per successful item when servers and SDKs need the same deterministic contract.
Inputs, units, and the rectilinear AOV formula
The engine uses the textbook thin-lens formula angle of view equals two times arctangent of dimension over two times focal length. Horizontal AOV uses the width, vertical AOV uses the height, and diagonal AOV uses the Pythagorean sensor diagonal so you see the same three angles that datasheets and lens reviews quote. Full-frame 35 mm format is often thirty-six by twenty-four millimetres; APS-C and smaller formats use smaller rectangles—always pass the physical size you care about rather than a crop-factor multiplier alone. Send three positive numbers that share one length unit—almost always millimetres for photographic work: focal_length for the lens, sensor_width for the long side of the imaging rectangle, and sensor_height for the short side. Aliases such as focal, f, fl, width, height, and frame_width are accepted when documented so forms and SDK demos stay flexible. Missing fields, non-numeric strings, negative sizes, and zero or non-positive focal length all fail with invalid_input and are not charged. Identical inputs always produce identical JSON because the path is pure Math.atan arithmetic with no network, no random seed, and no wall clock.
Reading degrees, radians, diagonal size, and method labels
On success the response echoes focal_length, sensor_width, and sensor_height with stable rounding, then sensor_diagonal as the square root of width squared plus height squared in the same length unit. The six angle fields are horizontal_aov_deg, vertical_aov_deg, diagonal_aov_deg and the matching horizontal_aov_rad, vertical_aov_rad, and diagonal_aov_rad values so UI widgets can show degrees while graphics or simulation code consumes radians without re-deriving the conversion. The formula string restates AOV equals two times atan of dimension over two times focal length for human display, and method is always rectilinear_aov so downstream code can branch without sniffing shapes.
API usage, pricing, kit planning, and practical limits
Pair this endpoint with exposure or crop-factor workflows when the next step is matching brightness or equivalent focal length across bodies.