ForHosting KIT · Science

Rydberg equation calculator

An electron falling from level 3 to level 2 in hydrogen emits the Balmer H-alpha line at 656.112276418 nm in vacuum. Enter the upper and lower levels to get the emitted wavelength in metres and nanometres, the wavenumber and the spectral series. 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

N initial: 3
N final: 2

You get

Wavelength m: 0.0000006561
Wavelength nm: 656.112276418
Wavenumber per m: 1,524,129.38447
Rydberg constant per m: 10,973,731.56816

The Rydberg equation predicts the wavelength of the photon a hydrogen atom emits when its electron falls from a higher principal quantum number to a lower one. Classic homework checks such as Balmer H-alpha (three down to two) and Lyman-alpha (two down to one) are therefore a single call.

From energy levels to a line in the spectrum

A hydrogen electron can only sit on certain energy levels, numbered 1, 2, 3 and upwards. When it drops from a higher level to a lower one, the atom gives off a photon whose wavelength depends only on those two numbers. The Rydberg equation captures that link: one over the wavelength equals the Rydberg constant times the difference between one over the final level squared and one over the starting level squared. The constant used is the CODATA value for an infinitely heavy nucleus, 10 973 731.568 16 per metre. Larger jumps release more energy and so give shorter wavelengths. Lines that end on level 1 form the Lyman series, those ending on level 2 the Balmer series and those ending on level 3 the Paschen series.

How to read the result, and the usual slips

Enter the upper level first and the lower level second. A drop from 3 to 2 gives 656.112276418 nm, the H-alpha line of the Balmer series, and the result also shows the wavenumber and the series name. The most common mistake is swapping the two levels: that describes absorption, not emission, and is rejected. Levels must be whole positive numbers, so 2.5 or 0 are refused rather than rounded. Remember too that the answer is a vacuum wavelength and comes in both metres and nanometres, so check which unit your table or textbook uses before you compare.

What you can do with it

Exam and LMS auto-grading

Mark Rydberg-equation items with a deterministic oracle that rejects non-integer levels and any pair that would not emit a photon.

Lab notebooks and line-spectrum primers

Tabulate Balmer, Lyman, and Paschen wavelengths from two quantum numbers without importing a quantum-chemistry library.

FAQ

Which Rydberg constant does the calculator use?

Reduced-mass hydrogen R_H is a different constant and is out of scope.

What happens if an energy level is not a positive integer?

Zero, negative, and non-integer values are not allowed hydrogen energy levels and are not billed.

Can I calculate absorption lines?

No, it handles emission only, so the starting level must be above the final one. Absorption uses the same formula with the two levels swapped, and that order is rejected here.

Which series does a transition belong to?

It depends on the level the electron lands on: level 1 gives the Lyman series, level 2 the Balmer series and level 3 the Paschen series. The result names the series for you.

Is the wavelength measured in air or in vacuum?

In vacuum. The calculator returns the vacuum wavelength of the line, in metres and in nanometres, together with the wavenumber per metre.

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/phys/rydberg-equation

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/phys/rydberg-equation \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"n_initial":3,"n_final":2}'

const res = await fetch("https://api.kit.forhosting.com/phys/rydberg-equation", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "n_initial": 3,
    "n_final": 2
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/phys/rydberg-equation",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "n_initial": 3,
    "n_final": 2
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/rydberg-equation", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"n_initial":3,"n_final":2}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"n_initial":3,"n_final":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/rydberg-equation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "n_initial": 3,
  "n_final": 2
}

Example response

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

Limits

max_n 10000

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 Rydberg equation calculator takes those two positive integers — the initial (upper) energy level and the final (lower) energy level — and returns the vacuum wavelength of the emitted line from one over lambda equals R times one over n_final squared minus one over n_initial squared. Zero, negative, and non-integer levels are rejected with invalid_input, as is any pair that would not emit because the initial level is not strictly above the final.

What the Rydberg equation computes from two hydrogen levels

The Rydberg equation is the closed-form relation that predicts the vacuum wavelength of light emitted when a hydrogen electron drops from one bound energy level to a lower one. The constant R used here is the CODATA Rydberg constant R infinity, 10 973 731.568 16 inverse metres, the infinite-nuclear-mass value quoted in tables as the Rydberg constant. Absorption is the same formula with the two levels swapped and is rejected here because this landing is emission only. Written as one over lambda equals R times the quantity one over n_final squared minus one over n_initial squared, it is the formula students meet when they first connect Bohr levels to line spectra. n_initial is the principal quantum number of the starting (upper) level and n_final is the principal quantum number of the ending (lower) level; both must be positive integers, and an emission photon exists only when n_initial is strictly greater than n_final. Classic checks are immediate: n_final equals two and n_initial equals three is the Balmer H-alpha line in the red; n_final equals one and n_initial equals two is Lyman-alpha in the vacuum ultraviolet; n_final equals three and n_initial equals four sits in the Paschen infrared series. Named hydrogen series are identified from the lower level alone: Lyman, Balmer, Paschen, Brackett, Pfund, and Humphreys for n_final of one through six. This calculator evaluates that single identity and returns the wavelength in metres and nanometres together with the wavenumber. It does not treat helium-plus or other hydrogen-like ions, which scale with nuclear charge squared, nor fine structure, the Lamb shift, the reduced-mass hydrogen constant versus R infinity, or air wavelengths versus vacuum.

Input contract, response shape, and error behaviour

Pair the numbers with your own Grotrian diagram if you need a sketch; this capability solves the Rydberg closed form only and does not emit plots, step-by-step prose beyond the formula field, or a photon energy in electronvolts. POST a JSON body with two required fields: n_initial, the upper principal quantum number, and n_final, the lower principal quantum number. Each must be a positive integer from one through ten thousand, and n_initial must be strictly greater than n_final so the electron actually drops and a photon is emitted. Aliases initial_level, initial, ni, and n_i are accepted for n_initial; final_level, final, nf, and n_f mean the same as n_final. JSON numbers that are exact integers, and decimal-free numeric strings such as "3", are valid. Values such as zero, minus one, 2.5, empty strings, and non-numeric text fail with invalid_input naming the offending field, because they are not positive integer energy levels. If both levels are valid integers but n_initial is not greater than n_final, the task also fails with invalid_input: that pair would be no transition or an absorption, not the emission this endpoint computes. Those failures are not billed. On success the body echoes n_initial and n_final; wavelength_m, the vacuum wavelength in metres; wavelength_nm, the same length in nanometres for spectroscopy notebooks; wavenumber_per_m, equal to one over lambda; rydberg_constant_per_m, the R infinity used; formula as a short ASCII identity; and series when n_final is one through six (Lyman through Humphreys).

Where a Rydberg equation calculator earns its keep

Exam-prep generators and LMS plugins need a deterministic oracle that marks wrong a submitted decimal level, a zero, or a pair where the electron would have to climb rather than fall, instead of silently returning a non-physical negative wavelength. Failed validation does not consume balance. Classrooms and tutoring platforms use a Rydberg equation calculator so learners can check hydrogen emission wavelengths for arbitrary n_initial and n_final without mixing up which quantum number sits in the first term of the difference and which sits in the second. Spectroscopy primers and first-year lab notebooks often tabulate Balmer and Lyman lines in nanometres next to the two integers that produced them; calling a tiny parse API avoids pulling a full quantum-chemistry stack for one high-school identity. Keep both quantum numbers inside the published ceiling of ten thousand, pin the rounded wavelength_nm in tests, and you get reproducible hydrogen emission wavelengths for homework, grading pipelines, and edge workers without standing up a symbolic algebra system of your own.

Integration use cases

Classroom and homework checks

Let students submit n_initial and n_final and verify the hydrogen emission wavelength in metres and nanometres against textbook Rydberg methods.

Technical questions

How do I calculate the hydrogen emission wavelength from two energy levels?

Send positive integers n_initial (upper) and n_final (lower) with n_initial greater than n_final. The API returns λ from 1/λ = R (1/n_final² − 1/n_initial²) as wavelength_m and wavelength_nm.

Why must n_initial be greater than n_final?

Emission requires the electron to drop to a lower level. Equal levels are not a transition; a climb would be absorption. Both cases are rejected as invalid_input.

What does the Rydberg equation 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