Numerical aperture converter
Move between the ways optics catalogs describe a light cone: an NA of 0.5 in air is an f-number of 1, a 30-degree half-angle and a 60-degree full cone, and you can raise the immersion index for oil or water. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 0.5
- Source unit
- na
- Target unit
- f_number
- Result
- 1
- N
- 1
- From label
- numerical aperture
- To label
- f-number
A numerical aperture converter turns optical NA, working f-number, acceptance half-angle, full cone angle, and cone solid angle into one another without spreadsheet macros or hand-written arcsin tables. Relations follow classical optics: NA equals n times sin of the half-angle, f-number equals n over two times NA, full angle is twice the half-angle, and solid angle is two pi times one minus cosine of the half-angle.
Supported representations and the optics equations used
This converter accepts seven canonical codes that cover the quantities people search for when they type numerical aperture converter or NA to f-number. Optional field n is the refractive index of the immersion medium and defaults to one for air; oil-immersion or water-immersion work simply raises n while the same formulas apply. Because every path shares one intermediate, converting A to B and B to A stays consistent up to the published twelve-decimal rounding, and there is no pairwise factor matrix that can drift out of sync across releases.
Everyday uses with microscopes and optical fibers
Use the free in-browser numerical aperture converter when you need a quick NA to f-number check, an acceptance half-angle from a fiber datasheet, or a full cone angle from a microscope objective NA while reading a catalog, lecture slide, or lab notebook. Open the page, enter the number and units, optionally set immersion index n, and copy the structured result without installing a photonics package, a CAS, or a desktop unit library.
Source inputs follow the same retention rules as other KIT parse items, and results are safe to cache because the algorithm is fully deterministic.
What you can do with it
Microscope objective crosswalks
Convert published objective NA to working f-number and acceptance half-angle when comparing dry and oil-immersion lenses with a shared immersion index n.
Fiber and connector acceptance
Turn multimode fiber NA into full acceptance angle or solid angle for launch condition notes, coupling budgets, and connector specs without hand tables.
FAQ
How do I convert numerical aperture to f-number?
Optionally set n for immersion (default 1). The result uses f# = n / (2 · NA).
Is the numerical aperture converter free?
The browser tool runs free on your device.
How is immersion refractive index handled?
Oil or water immersion uses a larger n in NA = n·sin(θ) and f# = n/(2·NA).
What acceptance angle does an NA of 0.5 give?
In air, an NA of 0.5 means a half-angle of 30 degrees, a full cone of 60 degrees and a solid angle of 0.841787214477 steradians. The matching working f-number is 1.
Which quantities can I convert between?
Seven: numerical aperture, working f-number, half-angle in degrees or radians, full cone angle in degrees or radians, and the solid angle of the cone in steradians. Any of them can be the starting point.
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/numerical-aperture \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":0.5,"from":"na","to":"f_number"}'const res = await fetch("https://api.kit.forhosting.com/conv/numerical-aperture", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 0.5,
"from": "na",
"to": "f_number"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/numerical-aperture",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 0.5,
"from": "na",
"to": "f_number"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/numerical-aperture", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":0.5,"from":"na","to":"f_number"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":0.5,"from":"na","to":"f_number"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/numerical-aperture", 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": 0.5,
"from": "na",
"to": "f_number"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.numerical_aperture",
"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
Enter a positive value, a source unit, a target unit, and optionally the immersion refractive index, then receive deterministic JSON with the converted result plus the full NA family for labeling UIs.
Supported representations and the optics equations used
Use na for dimensionless numerical aperture, f_number for the working f-number also written f-hash or f-stop in catalogs, half_angle_deg and half_angle_rad for the maximum acceptance half-angle theta of the light cone, full_angle_deg and full_angle_rad for the full cone opening alpha equal to two theta, and solid_angle_sr for the solid angle of that cone in steradians. Friendly aliases such as NA, numerical aperture, f-number, fstop, theta deg, acceptance angle, steradian, and sr normalize case-insensitively so forms and APIs can pass either short codes or plain names. Every request converts the input into an intermediate NA using NA equals n times sine of theta or NA equals n over two times f-number, then maps that intermediate into the target unit with the inverse relations, including solid angle Omega equals two pi times one minus cosine of theta.
Request shape, response fields, and invalid input errors
The error message names the bad field and lists the supported set so clients can correct forms without guessing. Send a JSON body with three required fields: value as a finite positive number, from as the source unit string, and to as the target unit string. Optional n accepts refractive index when you leave air; aliases amount and quantity work for value, unit_from and source for from, unit_to and target for to, and refractive_index, index, or medium_n for n. On success the response echoes canonical from and to codes, human-readable labels, the converted result, the intermediate na, the working f_number, half_angle_rad and half_angle_deg, full_angle_deg, solid_angle_sr, a short formula string, the method tag optical_na, and the fixed list of units_supported. Missing value, non-finite numbers such as NaN or Infinity, non-positive values, missing unit fields, NA that exceeds n, half-angles above ninety degrees, and any token that does not map to a supported unit fail with invalid_input and are not charged after the engine rejects the request. Identical inputs always yield identical JSON because the path is pure floating-point arithmetic with no randomness, no remote lookup, and no dependence on the wall clock, which makes the endpoint safe to pin in continuous-integration goldens and SDK contract tests for microscope objectives, multimode fiber acceptance, and lens f-number crosswalks.
Browser use, API pricing, and everyday optics workflows
Switch to the prepaid API when an instrument firmware helper, optics CAD plugin, fiber-link planner, curriculum generator, e-commerce objective filter, or metrology pipeline must convert numerical aperture quantities at scale under a stable KIT contract at $0.002 per successful item; validation failures that raise invalid_input do not consume balance after rejection. Pair this endpoint with critical-angle or telescope-magnification tools when a product pipeline needs several classical optics families, or call it alone when search traffic is specifically for numerical aperture conversion among NA, f-number, and acceptance angle rather than a general physics switchboard. Authors shipping mobile apps or lab chatbots can map the na, f_number, half_angle_deg, and formula fields directly into cards that show both the number and the relation students, technicians, and optical engineers expect on paper.
Integration use cases
Lens catalogs and homework checkers
Normalize f-number and NA labels in camera or lab optics problems with a prepaid, deterministic API and clear invalid_input on unknown units.
Technical questions
What acceptance angle units are supported?
Half-angle in degrees or radians (half_angle_deg, half_angle_rad), full cone angle in degrees or radians (full_angle_deg, full_angle_rad), and cone solid angle in steradians (solid_angle_sr).
What happens if I send an unknown unit?
The request fails with invalid_input. The message names the bad unit and lists supported codes such as na, f_number, half_angle_deg, and solid_angle_sr. Validation failures are not charged.