ForHosting KIT · Science

Anti-reflection coating thickness calculator

Gives the thickness a single-layer AR coating must reach: at 550 nm with a coating index of 1.38, just under 100 nm, for an optical thickness of 137.5 nm. The calculation steps are listed alongside. 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

Design wavelength: 550
Coating refractive index: 1.38

You get

Thickness: 99.6376811594
Optical thickness: 137.5
Quarter wavelength: 137.5

Single-layer antireflection coatings on glass, silicon, and other optics are almost always designed as a quarter-wave layer at a chosen vacuum wavelength so that reflections from the air–film and film–substrate interfaces cancel by destructive interference. Designers, coaters, and students therefore need a reliable way to turn a design wavelength and a film refractive index into the physical thickness the deposition process must hit. This anti-reflection coating thickness calculator accepts the design wavelength λ and the coating refractive index n, applies the classic quarter-wave relation t equals λ divided by four n, and returns the physical thickness in the same length unit as λ together with the optical thickness and a short step list you can show next to the answer.

What a quarter-wave antireflection coating is and why thickness is λ/(4n)

When light reflects from two successive interfaces that bound a thin film, the path difference between the two reflected beams depends on the optical thickness of the film—the product of the physical thickness t and the film refractive index n. For normal incidence and a design vacuum wavelength λ, setting the optical thickness n·t equal to one quarter of λ makes the two reflected waves differ by half a wavelength in phase (after accounting for a possible phase flip at a low-to-high index reflection).

That half-wave phase difference produces destructive interference in the reflected beam when the two reflections have similar amplitude, which is exactly the goal of a single-layer antireflection coating on glass or other transparent substrates. Solving n·t = λ/4 for the physical thickness immediately yields t = λ/(4n). The formula is unit-consistent: if you enter λ in nanometres, t comes back in nanometres; if you work in micrometres or metres, keep the same unit on both sides.

The coating index n is dimensionless and must be evaluated at the design wavelength because real materials are dispersive. Typical single-layer films for visible glass use magnesium fluoride near n ≈ 1.38, while infrared designs may use other low-index fluorides or oxides. This calculator does not choose the optimal index for zero reflection (ideally near the square root of the substrate index); it only converts a chosen λ and n into the quarter-wave thickness your coater or process recipe needs.

Who needs a coating thickness calculation

Optical coating shops and thin-film process engineers use a quarter-wave thickness calculator when locking deposition recipes for single-layer AR on lenses, windows, and sensors—especially when the design wavelength shifts between product lines (for example 550 nm photopic peak versus 1064 nm laser or 1550 nm telecom). Teaching labs and optics courses need a deterministic oracle that students can call from a notebook without re-deriving the phase condition by hand every time.

Instrument manufacturers and MES systems embed the same formula when generating set-points for quartz-crystal monitors or ellipsometry feedback loops that track physical thickness. Failed validation does not consume balance. Keep requests small, pin the rounded thickness in tests, and you get reproducible quarter-wave thicknesses for coating recipes, LMS plugins, and edge workers without standing up a full thin-film stack optimizer.

What you can do with it

Coating recipe set-points

Convert a design wavelength and film index into quarter-wave physical thickness for single-layer AR deposition on glass or silicon.

Optics lab and homework checks

Let students verify t = λ/(4n) for MgF₂ and other films against textbook problems without manual arithmetic errors.

MES and monitor targets

Feed deterministic thickness targets into process control scripts when the design line or material index changes between product SKUs.

FAQ

What units does the calculator use?

Any consistent length unit for wavelength and thickness (nm, µm, m, …). The refractive index is dimensionless. The response does not convert units; label them in your UI.

How thick should an AR coating be for 550 nm light?

With a coating index of 1.38, the quarter-wave layer is just under 100 nm thick: 550 divided by 4 times 1.38. Its optical thickness is 137.5 nm, exactly a quarter of the design wavelength.

What is the formula for a quarter-wave antireflection coating?

Physical thickness equals the design wavelength divided by four times the coating's refractive index, t = λ/(4n). The result comes out in the same length unit you used for the wavelength.

Why does a quarter-wave layer reduce reflection?

Light reflected from the top and the bottom of the film ends up half a wavelength apart, so the two reflected waves cancel by destructive interference when their strengths are similar.

What is the difference between physical and optical thickness?

Optical thickness is the physical thickness multiplied by the refractive index. For a quarter-wave design it always equals one quarter of the wavelength, 137.5 nm for 550 nm light.

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/optics/antireflection-coating-thickness

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/antireflection-coating-thickness \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"design_wavelength":550,"coating_refractive_index":1.38}'

const res = await fetch("https://api.kit.forhosting.com/optics/antireflection-coating-thickness", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "design_wavelength": 550,
    "coating_refractive_index": 1.38
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/optics/antireflection-coating-thickness",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "design_wavelength": 550,
    "coating_refractive_index": 1.38
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/optics/antireflection-coating-thickness", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"design_wavelength":550,"coating_refractive_index":1.38}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"design_wavelength":550,"coating_refractive_index":1.38}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/optics/antireflection-coating-thickness", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "design_wavelength": 550,
  "coating_refractive_index": 1.38
}

Example response

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

Invalid wavelengths or non-positive indices fail with invalid_input and are not billed.

Input contract, response shape, and error behaviour

Each value must be strictly positive: zero or negative wavelength is not physical for a design line, and a non-positive refractive index is not a valid absolute film index for this formula. Numbers are rounded to twelve decimal places for stable goldens across runtimes. POST a JSON body with two required finite numbers: design_wavelength (aliases wavelength, lambda, wl), the design vacuum wavelength in any length unit you prefer, and coating_refractive_index (aliases n, refractive_index, n_coating, index), the film refractive index at that wavelength. Both fields may arrive as JSON numbers or numeric strings. Missing fields, empty strings, non-numeric values, NaN, and Infinity fail with invalid_input naming the field. On success the body echoes the rounded design_wavelength and coating_refractive_index, returns thickness (physical film thickness t), optical_thickness (n·t, equal to λ/4 by construction), quarter_wavelength (λ/4), a formula string restating t = λ/(4·n), a human-readable message, and a steps array that walks through the substitution. Example: λ = 550 and n = 1.38 (a common visible design on MgF₂-coated glass) yields thickness ≈ 99.637681159420 nanometres if you treat 550 as nanometres. Pair the response with your own unit labels; the API intentionally leaves units implicit so one endpoint serves nm, µm, and SI workflows without conversion tables.

Technical questions

How do I calculate quarter-wave AR coating thickness?

Send a positive design_wavelength λ and a positive coating_refractive_index n. The API returns physical thickness t = λ/(4n) in the same length unit as λ, plus optical thickness n·t = λ/4.

Does this pick the ideal coating index for zero reflection?

No. Ideal single-layer AR often targets n ≈ √n_substrate for amplitude matching. This tool only computes the quarter-wave thickness for the n and λ you supply.

What if wavelength or n is zero or negative?

The task fails with invalid_input. Both design_wavelength and coating_refractive_index must be strictly positive finite numbers.

What does the anti-reflection coating thickness calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free