ForHosting KIT · Science

Physical size from angular diameter

The Moon spans 31.5 arcminutes at 384400 km, which makes it 3522.248963449756 km across. Enter any angular diameter in radians, degrees, arcminutes or arcseconds plus a distance, and get the physical size. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Angular size: 31.5
Distance: 384,400
Angular unit: Arcmin

You get

Angular size rad: 0.0091629786
Physical size: 3,522.2489634498
Length units: same as distance

When you know how large an object looks on the sky and how far away it is, the small-angle relation turns that angular diameter into a physical size in the same length units as the distance. No ephemerides, catalogs, or network lookups are required—only two positive numbers and an optional angular unit. Use it for homework checks, quick mission design estimates, outreach demos, and any pipeline that needs a repeatable diameter figure without spreadsheets or ad-hoc scripts.

What the small-angle relation computes

For an object much smaller than its distance, the physical diameter is approximately the product of the angular diameter in radians and the distance. That is the classic small-angle formula: physical size equals theta times distance, with theta in radians. The approximation comes from replacing sine or tangent of a small angle with the angle itself in radians, which is excellent for planets, moons, stars, and most resolved solar-system bodies as seen from Earth.

Angular size can be given in radians, degrees, arcminutes, or arcseconds; the tool converts to radians before multiplying. Distance can be in kilometers, astronomical units, light-years, or any other length scale you choose—the returned physical size uses exactly those same units. You do not get a unit conversion service here: if distance is in kilometers, diameter is in kilometers.

Values above a few degrees still run the same formula, but you should treat large angles with care because the small-angle assumption weakens. This calculator never invents distances or angles from catalogs; it only applies the arithmetic once you supply both positive inputs, so the quality of the answer depends on the quality of your measurements or ephemeris data.

What you can do with it

Homework and lab angular-size checks

Compute physical diameter from measured angular size and a known distance before students finalize lab notebooks or problem sets.

Planetary and lunar outreach estimates

Turn apparent planetary arcs and almanac distances into kilometer-scale diameters for talks, blogs, and public observing nights.

FAQ

What if angular size or distance is zero or negative?

Both fields must be strictly positive; non-positive geometry is rejected before any result is returned, and failed tasks are not charged.

Which angular units are supported?

Radians (rad), degrees (deg), arcminutes (arcmin), and arcseconds (arcsec).

What unit is the physical size given in?

Exactly the unit you used for the distance. Enter the distance in kilometres and the diameter comes out in kilometres; enter it in astronomical units and you get astronomical units. Nothing is converted between length units.

How do I work out the Moon's diameter from its angular size?

Enter 31.5 arcminutes as the angular size and 384400 km as the distance. The small-angle product gives 3522.248963449756 km, a classic check for lab notebooks and public observing nights.

Does the formula still work for large angles?

It runs the same way, but treat results above a few degrees with care. The method replaces the sine or tangent of a small angle with the angle itself, which is excellent for planets, moons and stars seen from Earth.

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

POSThttps://api.kit.forhosting.com/astro/physical-size-from-angular

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/physical-size-from-angular \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"angular_size":31.5,"distance":384400}'

const res = await fetch("https://api.kit.forhosting.com/astro/physical-size-from-angular", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "angular_size": 31.5,
    "distance": 384400
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/astro/physical-size-from-angular",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "angular_size": 31.5,
    "distance": 384400
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/physical-size-from-angular", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"angular_size":31.5,"distance":384400}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"angular_size":31.5,"distance":384400}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/physical-size-from-angular", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "angular_size": 31.5,
  "distance": 384400
}

Example response

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

Technical notes

This capability multiplies the angular size converted to radians by the distance: a transparent, deterministic formula used in planetary science, stellar astronomy, and classroom labs. Browser and API share one pure function so demos and production stay aligned.

Inputs, outputs, and validation rules

Convert parallax, radar ranging, or ephemeris distances into a single length unit before calling if you need chemically or metrically absolute sizes rather than relative bookkeeping on mismatched scales. Send two required numbers: angular_size for the apparent diameter and distance for the range to the object. Both must be finite and strictly positive; zero or negative values fail with invalid_input because a non-positive angle or distance is not a meaningful geometric baseline, and failed requests are not charged. Optional angular_unit selects rad, deg, arcmin, or arcsec and defaults to arcmin when omitted. A classic check is the Moon near mean distance: about thirty-one point five arcminutes at three hundred eighty-four thousand four hundred kilometers, which yields a diameter of a few thousand kilometers under the small-angle product.

Where teams plug diameter estimates into workflows

Amateur observers convert measured lunar or planetary arcs into kilometers when they already trust a distance figure from almanacs. Mission designers and outreach teams sketch rough body sizes from instrument fields of view without standing up a full geometry stack. Documentation writers embed live examples so readers can change angle and range without leaving the page. Educational product teams expose the free browser form on study pages and call the API from graders that score homework at scale. Because each successful call is a single analytic item priced at $0.002, batch scripts can sweep grids of angular measurements or curriculum problem banks without model cost or subscription overhead. Prefer this endpoint when you already know angular diameter and distance and only need the transparent small-angle product—not full orbit propagation, limb-darkening photometry, or catalog cross-matching, which need richer inputs and different capabilities.

Integration use cases

Automated grading and study tools

Score student diameter answers or power interactive astronomy pages with a deterministic JSON result.

Technical questions

How is physical size calculated?

Angular size is converted to radians, then multiplied by distance: physical_size = angular_size_rad × distance. That is the small-angle diameter relation used throughout observational astronomy.

What units should I use for distance?

Any length unit works—kilometers, AU, light-years, or meters—as long as you interpret physical_size in that same unit. The tool does not convert length units.

How much does each API call cost?

$0.002 per successful request. The browser tool above runs free locally; the API draws from your prepaid KIT balance only when the task succeeds.

Read the full KIT documentation →

Run — free