Solid angle converter
One steradian is 3282.8063500117 square degrees. Convert a solid angle between steradians, square degrees, spat and fractions of a sphere when a datasheet and a sky catalogue describe a field of view differently. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1
- Source unit of 'value'
- sr
- To
- deg2
- Result
- 3,282.8063500117
- From label
- steradians
- To label
- square degrees
- Value sr
- 1
This solid angle converter turns a numeric solid angle from one common unit into another and returns the converted magnitude with canonical unit labels. Conversion always bridges through steradians using fixed geometric factors, so the same input always yields the same result with no network calls, no sampling, and no date-dependent shortcuts. Typical checks include one steradian to square degrees, one spat to steradians, half a sphere to steradians, and one square degree back to steradians.
Where solid angle conversion fits in optics, astronomy, and software
Optics labs often quote detector acceptance in steradians while astronomy catalogs and planetarium software still report fields of view in square degrees, so a single deterministic converter prevents hand-calculator drift when a student, engineer, or instrument designer compares apertures. Radiometry and photometry pipelines normalize source solid angles into steradians before integrating radiance; remote-sensing teams convert instrument footprints from square degrees into fractions of a sphere for coverage reports; teachers assign homework that needs a fast, offline check of spat to steradians without trusting opaque apps that silently change precision.
Developers call the same contract from scripts to seed deterministic test vectors for rendering UIs, to normalize user-entered solid angles before simulation demos, or to satisfy programming-challenge statements that demand exact geometric factors rather than a hand-waved estimate. Product tools use the conversion when a learner types one steradian and the UI must show square degrees and sphere fractions side by side.
Pair it with plane-angle converters when you need ordinary degrees and radians first, and with area or geometry tools when the same form must also handle projected patches on a sphere.
What you can do with it
Optics and detector FOV
Convert between steradians and square degrees when comparing instrument acceptance, apertures, and fields of view across lab notes and datasheets.
Astronomy and coverage reports
Normalize catalog footprints or sky patches from square degrees into sphere fractions or spat for deterministic coverage and survey planning.
FAQ
What does the solid angle converter cost?
It is free in your browser on this page.
What happens if I send an unknown unit?
Unknown or misspelled units are never silently mapped.
Is a sphere the same as a spat?
Numerically yes: both equal 4π steradians for a full sphere. Use spat for the named unit and sphere when you think in fractions of the whole sky or ball.
How many decimal places does the result show?
Ten decimal places by default. You can choose anywhere from 0 to 15, which helps when a report or a data table needs a fixed number of digits.
How many steradians are in a full sphere?
A full sphere is 4π steradians, which is also one spat. Enter 1 with the sphere or spat unit to see it in steradians or square degrees.
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/conv/solid-angle \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1,"from":"sr","to":"deg2"}'const res = await fetch("https://api.kit.forhosting.com/conv/solid-angle", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1,
"from": "sr",
"to": "deg2"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/solid-angle",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1,
"from": "sr",
"to": "deg2"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/solid-angle", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1,"from":"sr","to":"deg2"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1,"from":"sr","to":"deg2"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/solid-angle", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 1,
"from": "sr",
"to": "deg2"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.solid_angle",
"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.
Limits
max_abs_value | 1000000000000000000 |
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
Supported units are steradians, square degrees, spat, and fractions of a sphere, plus everyday aliases such as steradian, deg squared, square_degrees, sp, and full_sphere.
What the solid angle converter returns and which units it understands
A solid angle conversion answers a narrow question: given a magnitude in one solid-angle unit, what is the equivalent magnitude in another unit that people actually use in optics, radiometry, and geometry. This calculator accepts a numeric value, a source unit, and a target unit, then returns the converted result rounded to a stable precision, the canonical from and to identifiers, human-readable labels, the intermediate value in steradians, and the geometric factors used for the bridge. Canonical ids are sr for steradians, deg2 for square degrees, spat for the full-sphere spat, and sphere for a fraction of a sphere where one means the entire sphere. Everyday spellings such as steradian, steradians, square_degree, square_degrees, deg caret two, sp, full_sphere, and fraction_of_sphere normalize to those ids so forms, query strings, and spreadsheets can reuse the same contract without inventing private enums. There is no approximate ray-tracing path and no table of rounded textbook shortcuts: the engine either multiplies and divides by fixed factors inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing value, from, or to; non-finite numbers; magnitudes above the documented ceiling; and any unit string that is not on the supported list.
How factors are defined and how results stay reproducible
Optional scientific notation on the value string is allowed when it parses as a finite decimal; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong field of view. Zero is a valid value and simply yields zero in the target unit. Computation multiplies value by the source factor in steradians, then divides by the target factor: one steradian is the SI base unit; one square degree equals pi over one hundred eighty squared steradians, which is pi squared over thirty-two thousand four hundred; one spat equals four pi steradians by definition of the full sphere; one sphere fraction uses the same four pi steradians so half a sphere is two pi steradians. The preferred fields are value for the solid-angle magnitude, from for the source unit, and to for the target unit, with aliases amount, solid_angle, n, quantity, and omega for the value, unit, from_unit, source, and input_unit for from, and target, to_unit, output_unit, and into for to so heterogeneous clients can share one contract. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for value, result, and value_sr, 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 unit tables yourself.
Where solid angle conversion fits in optics, astronomy, 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.
Integration use cases
Homework and CI fixtures
Generate reproducible solid-angle conversions for worksheets, tutoring software, and unit tests that assert fixed geometric factors.
Technical questions
Which solid-angle units are supported?
Steradians (sr), square degrees (deg2), spat, and sphere fractions (sphere), including common aliases such as steradian, square_degrees, deg^2, sp, and full_sphere.
How are conversion factors defined?
Everything bridges through steradians: 1 deg² = (π/180)² sr, and 1 spat = 1 sphere = 4π sr (the solid angle of a full sphere).