Telescope magnification calculator
A 1000 mm objective with a 25 mm eyepiece gives 40x. Enter both focal lengths in the same unit to see how much larger a distant object appears, and how each eyepiece changes the power. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Objective focal length
- 1,000
- Eyepiece focal length
- 25
- Magnification
- 40
Angular magnification tells you how much larger a distant object appears through a telescope compared with the unaided eye. For a simple astronomical telescope used in normal adjustment—objective and eyepiece forming an afocal system—the classical result is M equals the objective focal length divided by the eyepiece focal length. Amateur astronomers swapping eyepieces, students checking homework on refractors and reflectors, educators building answer keys, and software that needs a stable numeric contract all hit the same two-number formula.
What telescope angular magnification returns and which two inputs you need
Doubling the objective length or halving the eyepiece length doubles M; that is why longer tubes and shorter oculars climb the power ladder on commercial mounts. Search intent clusters around phrases such as telescope magnification calculator, angular magnification from focal lengths, eyepiece power calculator, refractor magnification, and how much power is my telescope. People want a numeric M they can write on a lab sheet, compare against a manufacturer chart, or embed in a pipeline—not only a reminder that M equals f over f.
Keep both inputs in the same length units—millimetres with millimetres, inches with inches—because the engine does not convert units and only the ratio matters for M.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate power check while shopping for an eyepiece, verifying a school refractor lab, estimating maximum useful magnification against aperture rules of thumb, or teaching why short oculars raise power. Remember that useful magnification is also limited by aperture, seeing, and eyepiece design—this calculator reports the geometric angular ratio only, not whether the view will be sharp or dim. Results are fully deterministic: the same two inputs always yield the same magnification.
There is no language model, no external optics service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials.
What you can do with it
Eyepiece swap power charts
Amateur astronomers and retailers compute M for each eyepiece focal length against a fixed objective, building clear power tables without spreadsheet formulas.
FAQ
What happens if eyepiece focal length is zero?
Zero eyepiece focal length is rejected by contract and those calls are not charged.
Is the telescope magnification calculator free?
The browser tool runs free on your device.
Does this include Barlow lenses or true field of view?
No. This capacity returns only the geometric angular magnification from the two focal lengths. Barlow factors, FOV, and exit pupil are separate calculations.
What magnification do I get with a 1000 mm telescope and a 25 mm eyepiece?
40x. Divide the objective focal length by the eyepiece focal length: 1000 divided by 25 is 40, so a distant object looks forty times larger than with the unaided eye.
Do both focal lengths have to be in the same unit?
Yes. Use millimetres with millimetres or inches with inches. The calculator does not convert units, and only the ratio between the two lengths matters for the magnification.
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/optics/telescope-magnification \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"objective_focal_length":1000,"eyepiece_focal_length":25}'const res = await fetch("https://api.kit.forhosting.com/optics/telescope-magnification", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"objective_focal_length": 1000,
"eyepiece_focal_length": 25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/optics/telescope-magnification",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"objective_focal_length": 1000,
"eyepiece_focal_length": 25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/optics/telescope-magnification", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"objective_focal_length":1000,"eyepiece_focal_length":25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"objective_focal_length":1000,"eyepiece_focal_length":25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/optics/telescope-magnification", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"objective_focal_length": 1000,
"eyepiece_focal_length": 25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "optics.telescope_magnification",
"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
This capacity accepts finite objective and eyepiece focal lengths in matching length units, rejects zero eyepiece focal length with a clear invalid_input error, and returns magnification, formula, and method as deterministic JSON.
What telescope angular magnification returns and which two inputs you need
For a Keplerian or Newtonian-style telescope treated as an afocal pair in normal adjustment, angular magnification M is the ratio of the objective focal length f_objective to the eyepiece focal length f_eyepiece. Delivering objective_focal_length, eyepiece_focal_length, magnification, formula, and method as JSON makes the result easy to paste into notes, diff in automated tests, or reuse across languages without reimplementing the division.
How this calculator validates input and applies M = f_objective / f_eyepiece
Numeric strings that parse to finite numbers are accepted so forms and CSV-style pipelines can pass values without an extra cast. Zero eyepiece focal length is always rejected per the product contract because division by zero is undefined. Sign is preserved: matching positive lengths yield positive M as textbooks expect for ordinary visual use; atypical sign combinations are still pure ratios for advanced sign-convention drills. There is no Barlow factor, no field-stop geometry, and no atmospheric seeing model; this is ideal two-element angular magnification from the two known focal lengths. Send a JSON body with required objective_focal_length and eyepiece_focal_length. Aliases f_objective, fo, objective, and f_obj map to the objective; aliases f_eyepiece, fe, eyepiece, and f_eye map to the eyepiece. Every provided field must be finite: missing fields, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any result is returned, and failed validation is not charged. Zero objective focal length is also rejected so the API never returns a meaningless zero-power result. After validation, magnification is computed as f_objective divided by f_eyepiece. Results are rounded to a stable decimal precision so the same input always yields the same JSON across JavaScript engines.
Practical use, limits, pricing, and delivery channels
Each successful request is one billable item at $0.002; failed validation does not consume balance. Wire the endpoint into equipment planners, contest answer checkers, museum exhibit kiosks, or preprocessing steps where you already prefer explicit domain errors—such as rejecting zero eyepiece focal length—over opaque black-box widgets that cannot explain why a bad input was refused.
Integration use cases
Homework and lab telescope drills
Students and graders confirm angular magnification for given f_objective and f_eyepiece, with clear rejection when eyepiece focal length is zero.
Deterministic fixtures for optics apps
Pipelines that seed unit tests or interactive telescope demos call a pure M=f_obj/f_eye oracle instead of reimplementing the ratio in every language.
Technical questions
How do I compute telescope angular magnification with this API?
Send a JSON body with objective_focal_length and eyepiece_focal_length to optics.telescope_magnification. The response returns magnification, formula, and method.
Which formula does the telescope magnification calculator use?
Angular magnification for a simple afocal telescope: M = f_objective / f_eyepiece. Both lengths must use the same units.