Image scale calculator
Turn a camera's pixel size and a telescope's focal length into arcseconds per pixel: a 3.76 µm pixel behind an 800 mm telescope covers just under one arcsecond of sky. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Pixel size
- 3.76
- Focal length
- 800
- Pixel size um
- 3.76
- Focal length mm
- 800
- Image scale
- 0.9694455
- Image scale arcsec per pixel
- 0.9694455
This image scale calculator converts a camera pixel size in micrometres and a telescope or lens effective focal length in millimetres into the classical plate scale in arcseconds per pixel. The closed form is fully deterministic: S equals two hundred six point two six five times pixel size over focal length, so larger pixels and shorter focal lengths yield coarser sky sampling. Amateur and professional setups use this number to plan sampling against seeing, to match a science camera to a spectrograph slit, and to estimate field of view once the array width is known. Well-known checks include a three point seven six micrometre pixel on an eight hundred millimetre telescope near zero point nine seven arcseconds per pixel, and a five point eight six micrometre pixel on a one thousand millimetre system near one point two one arcseconds per pixel. The engine uses only finite arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where image scale fits in study, observing, and software
Students meet plate scale when a textbook moves from geometric optics to angular measure on the sky, when a lab asks them to match a CMOS camera to a school telescope, or when they compare sampling under different reducers and Barlows without full instrument software. Teachers can pre-generate answer keys for modest pixel and focal-length pairs without trusting opaque calculator apps that silently switch between arcseconds and milliarcseconds.
Developers call the same contract from scripts to seed deterministic test vectors for imaging simulators, to normalize user-entered sensor specs before mission or observatory demos, or to satisfy programming-challenge statements that demand arcsec per pixel rather than a hand-waved field of view. Contest practice often needs a fast, offline source of plate scales so solutions can be checked without graphing calculators under time pressure.
Product and education tools use the formula when a learner types a pixel size in micrometres and a focal length in millimetres and the UI must show sampling next to comparisons with famous camera and telescope combinations.
What you can do with it
Homework and plate-scale checks
Compute S from textbook pixel size and focal length pairs and verify arcsec/pixel before astronomy or optics problems.
Observatory and education software
Normalize user-entered μm and mm into arcsec/pixel for planners, demos, and interactive lessons.
FAQ
What does the image scale calculator cost?
It is free in your browser on this page.
Does this include atmospheric seeing?
No. It returns only the geometric plate scale from pixel pitch and focal length. Seeing, binning, and optical aberrations are out of scope.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
How do I calculate arcseconds per pixel?
Multiply the pixel size in micrometres by 206.265 and divide by the focal length in millimetres. A 3.76 µm pixel on an 800 mm telescope gives just under one arcsecond per pixel.
What image scale should I aim for?
Compare the result with the seeing at your site. A scale much smaller than the seeing oversamples the atmosphere, while one much larger undersamples fine detail and wastes the resolution your telescope can deliver.
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/astro/image-scale-pixel \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pixel_size":3.76,"focal_length":800}'const res = await fetch("https://api.kit.forhosting.com/astro/image-scale-pixel", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pixel_size": 3.76,
"focal_length": 800
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/image-scale-pixel",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pixel_size": 3.76,
"focal_length": 800
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/image-scale-pixel", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pixel_size":3.76,"focal_length":800}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pixel_size":3.76,"focal_length":800}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/image-scale-pixel", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"pixel_size": 3.76,
"focal_length": 800
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.image_scale_pixel",
"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
What image scale means and what the response contains
Image scale, often called plate scale in classical astronomy, is the angular sky size covered by one detector pixel once light is focused by a telescope or camera lens. Under the small-angle approximation the angle in radians is the linear pixel pitch divided by the effective focal length when both lengths share the same unit; converting that angle to arcseconds and expressing the pitch in micrometres and the focal length in millimetres yields the familiar textbook formula S equals two hundred six point two six five times p_μm over f_mm. That single number tells you how finely the sky is sampled: values much smaller than typical local seeing oversample the atmosphere, while values much larger undersample fine structure and waste resolution. This calculator returns the normalized pixel_size and pixel_size_um you supplied, the focal_length and focal_length_mm, the primary image_scale and image_scale_arcsec_per_pixel fields in arcseconds per pixel, an arcsec_per_mm companion for field-of-view planning, the fixed arcsec_factor of two hundred six point two six five, a unit string arcsec/pixel, the method tag plate_scale_206265, the precision used, and a short formula reminder. There is no ray-trace, no atmospheric model, and no random sampling of optical modes: the engine either builds exact floating-point S inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing pixel size or focal length, non-finite values, magnitudes above the documented ceilings, non-positive pixel size, and zero or negative focal length—because division by f is undefined.
How pixel size and focal length are read and how S stays reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong scale. Pixel size must likewise be positive so the product has a physical meaning for a real detector element. The preferred fields are pixel_size for the detector pitch in micrometres and focal_length for the effective focal length in millimetres, but aliases pixel_size_um, pixel_um, and p for the first, and focal_length_mm, fl, and f for the second, are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Focal length must be strictly positive and non-zero: if f is zero, negative, or negative zero, the request fails with invalid_input because image scale S equals two hundred six point two six five times p over f is undefined for a zero or negative focal length. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. 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 plate-scale formula yourself.
Where image scale fits in study, observing, and software
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 telescope-resolution or angular-size tools when you need related astronomy steps, and with other physics endpoints when you are building a small lab of free, deterministic science helpers.
Integration use cases
Deterministic test fixtures
Generate reproducible image scales for unit tests, property checks, and CI assertions on imaging modules.
Technical questions
How is image scale defined?
S = 206.265 · p_μm / f_mm, giving arcseconds per pixel when pixel size is in micrometres and focal length is in millimetres.
What happens if the focal length is zero or negative?
The input is rejected with invalid_input. Zero or non-positive focal length makes S = 206.265·p/f undefined.