ForHosting KIT · Developer Utilities

Telescope exit pupil calculator

A telescope's exit pupil is the small disk of light that leaves the eyepiece and enters your eye.

● BetaFree · in your browser

Use it from WebAPIEmailTelegramApp soon

Its diameter is found by dividing the clear objective aperture by the telescope's magnifying power. This calculator gives observers, equipment planners, students, and astronomy applications a direct, reproducible result from those two values. Enter the aperture in millimetres to receive millimetres, or use any other length unit consistently. The calculation is deterministic, validates both values, and returns structured data suitable for a quick observing decision or an automated equipment comparison.

What exit pupil diameter means at the eyepiece

The exit pupil is the bright circular image of the telescope objective that appears just behind the eyepiece. Hold your eye back from an eyepiece aimed at a bright, safe scene and you can often see this floating disk directly. Its diameter helps describe how concentrated the collected light is when it reaches your eye. A larger exit pupil generally produces a brighter extended image and can make low-power sweeping comfortable, while a smaller exit pupil accompanies higher power and a dimmer view of extended objects. To calculate it, divide the clear objective aperture by magnifying power. A 200 millimetre telescope working at 100x therefore has a 2 millimetre exit pupil. Aperture and exit pupil share the same length unit because magnification is dimensionless. Use the clear working aperture rather than a tube's outside diameter, and enter magnification as the actual optical power of the current telescope and eyepiece combination. The result describes beam geometry; it does not by itself predict image quality, contrast, seeing, or whether a particular target will be visible.

How to enter aperture and magnifying power correctly

Provide objective_aperture and magnifying_power as positive finite numbers. Common aliases are accepted for convenient integrations: aperture or aperture_diameter for the objective, and magnification or power for the magnifying power. If your telescope aperture is specified in millimetres, the returned exit_pupil_diameter is also in millimetres. If you use inches, the result is in inches, though millimetres are customary for visual astronomy and easier to compare with a human eye pupil. Magnifying power has no length unit: enter 80 for 80x, not the text 80x. Zero, negative, missing, infinite, and non-numeric values are rejected because they cannot represent a physical aperture or usable magnification in this calculator. The arithmetic is exactly objective aperture divided by magnifying power, followed by stable numeric rounding for reproducible JSON. This capability does not derive power from telescope and eyepiece focal lengths, apply a Barlow multiplier, subtract a central obstruction, or estimate the observer's eye pupil. Calculate the actual magnification first when necessary, then use that result here with the instrument's clear aperture.

Choosing useful observing combinations and interpreting limits

Exit pupil is valuable when comparing eyepieces because it normalizes magnification against telescope aperture. Low-power combinations may create an exit pupil larger than the observer's dilated eye pupil, allowing some of the beam to fall outside the eye and effectively wasting aperture. Very small exit pupils can reveal floaters, make focusing more demanding, and leave extended objects uncomfortably dim, although the practical threshold varies with the target, observer, optics, and atmospheric conditions. Rather than treating one number as universally ideal, use the result to compare combinations: wide-field scanning often favors a larger beam, many deep-sky observations use moderate exit pupils, and lunar or planetary work may tolerate smaller ones when the image remains sharp. The calculator reports the geometric diameter only. It does not certify a maximum useful power, account for eye relief, field of view, transmission losses, central obstruction effects, aberrations, or seeing. Browser calculations run locally, while an API request costs $0.002 for each successful item. Both paths use the same pure algorithm, so equipment tables, classroom exercises, observing plans, and automated catalog tools receive consistent answers from identical inputs.

What you can do with it

Compare eyepieces for an observing session

Calculate the exit pupil for each actual magnification and choose combinations suited to wide-field, deep-sky, lunar, or planetary viewing.

Check whether low power wastes aperture

Compare a large calculated exit pupil with the observer's measured or estimated dark-adapted eye pupil before selecting a very low-power eyepiece.

Build consistent astronomy equipment tables

Generate deterministic exit-pupil values for telescope and eyepiece comparison sheets, education tools, product catalogs, or observing-planner software.

FAQ

What formula does the telescope exit pupil calculator use?

Exit pupil diameter equals objective aperture divided by magnifying power: D_exit = D_aperture / M.

Which unit is the exit pupil returned in?

It uses the same length unit as objective_aperture. Enter millimetres to receive millimetres, which is the usual astronomy convention.

Is magnifying power the same as eyepiece focal length?

No. Magnifying power is a dimensionless ratio such as 100x. If you only know focal lengths, calculate telescope magnification first.

Does a larger exit pupil always give a better view?

No. A beam larger than your eye pupil can waste collected light, while a very small beam may be dim. The useful range depends on the target and conditions.

What does the API calculation cost?

Each successful API item costs $0.002. The browser calculator runs locally for free, and invalid requests are rejected before a result is returned.

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

POSThttps://api.kit.forhosting.com/optics/telescope-exit-pupil

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-exit-pupil \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"objective_aperture":200,"magnifying_power":100}'

const res = await fetch("https://api.kit.forhosting.com/optics/telescope-exit-pupil", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "objective_aperture": 200,
    "magnifying_power": 100
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/optics/telescope-exit-pupil",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "objective_aperture": 200,
    "magnifying_power": 100
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/optics/telescope-exit-pupil", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"objective_aperture":200,"magnifying_power":100}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"objective_aperture":200,"magnifying_power":100}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/optics/telescope-exit-pupil", 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_aperture": 200,
  "magnifying_power": 100
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "optics.telescope_exit_pupil",
  "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

Per request$0.002

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.

Read the full KIT documentation →