Luminous energy converter
Switch light totals between the units your report uses: 1 lumen-hour is exactly 3600 lumen-seconds, and a talbot is one lumen-second. Seven luminous energy units share one exact path, for flash notes, greenhouse logs and lab work. 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
- lm_h
- Target unit
- lm_s
- Result
- 3,600
- From label
- lumen-hour
- To label
- lumen-second
- Lumen seconds
- 3,600
A luminous energy converter turns a quantity written in one photometric energy unit into another without hunting conversion tables or rewriting spreadsheet formulas.
Supported units and how the conversion is computed
Factors follow SI photometry and exact time prefixes: one talbot equals one lumen-second by definition, one lumen-minute is sixty lumen-seconds, one lumen-hour is three thousand six hundred lumen-seconds, one kilolumen-second is one thousand lumen-seconds, one kilolumen-hour is three million six hundred thousand lumen-seconds, and one millilumen-second is one thousandth of a lumen-second. Because the intermediate is always lumen-seconds, converting A to B and B to A is consistent up to the published rounding of twelve decimal places, and there is no pairwise matrix that can drift out of sync.
Luminous intensity in candela, bare luminous flux without a time product, illuminance in lux, luminance, and radiometric energy in joules are intentionally out of scope so lighting engineers, camera exposure workflows, photobiology labs, and physics students get predictable luminous-energy-only results under one clear convention.
Where converting luminous energy helps
Use the free in-browser luminous energy converter when you need a quick lumen-second-to-talbot, talbot-to-lumen-hour, or lumen-hour-to-kilolumen-hour check while reading a photometric report, flash exposure note, greenhouse lighting log, lab procedure, theatrical cue sheet, or homework problem. Open the page, enter the number and units, and copy the result without installing a spreadsheet, a unit library, or a desktop calculator pack. Source inputs follow the same retention rules as other KIT parse items, and results are safe to cache because the algorithm is fully deterministic.
Authors shipping mobile apps or chatbots can map the result and formula fields directly into cards that show both the number and the conversion path students, technicians, and lighting engineers expect on paper.
What you can do with it
Flash and camera exposure metrology
Convert lumen-seconds and millilumen-seconds so flashmeters, lab notes, and sensor specs share one SI luminous-energy view without hand-written factors.
FAQ
How many lumen-seconds is one talbot?
Exactly 1 lm·s. The talbot is defined as one lumen-second.
What happens if I send an unknown unit?
The message names the field and lists supported units. Validation failures are not charged.
Is the luminous energy converter free?
The browser tool runs free on your device.
How many lumen-seconds are in a lumen-hour?
There are 3600, because a lumen-hour is one lumen kept for an hour of 3600 seconds. The same lumen-hour also equals 60 lumen-minutes.
Can I convert luminous energy into joules?
No. Joules belong to radiometric energy, a different quantity, and are left out on purpose together with candela, lux and luminance. Only luminous energy units are converted here.
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/luminous-energy \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1,"from":"lm_s","to":"lm_h"}'const res = await fetch("https://api.kit.forhosting.com/conv/luminous-energy", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1,
"from": "lm_s",
"to": "lm_h"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/luminous-energy",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1,
"from": "lm_s",
"to": "lm_h"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/luminous-energy", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1,"from":"lm_s","to":"lm_h"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1,"from":"lm_s","to":"lm_h"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/luminous-energy", 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": "lm_s",
"to": "lm_h"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.luminous_energy",
"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
The browser tool runs free on your device; the prepaid API charges $0.002 per successful item when pipelines need the same contract from servers and automation.
Supported units and how the conversion is computed
The converter accepts seven luminous energy families under stable canonical codes: lm_s for the SI lumen-second, talbot for the talbot (exactly one lumen-second under modern photometry), lm_min for the lumen-minute, lm_h for the lumen-hour, klm_s for the kilolumen-second, klm_h for the kilolumen-hour, and mlm_s for the millilumen-second. Friendly aliases such as lumen-second, lumen seconds, lm·s, lm s, talbots, T, lumen-minute, lumen hour, lumen-hours, kilolumen-second, kilolumen hour, millilumen-second, and common compact spellings are normalized case-insensitively so forms and APIs can pass either short codes or full names. Every request multiplies the input value by the exact lumen-seconds-per-unit factor for the source, then divides by the lumen-seconds-per-unit factor for the target.
Request shape, response fields, and unknown-unit errors
The error message names the bad field and lists the supported set so clients can correct forms without guessing. Negative values are allowed when you need signed or relative luminous-energy differences in analysis pipelines; zero converts cleanly to zero in every target unit. Send a JSON body with three required fields: value as a finite number, from as the source unit string, and to as the target unit string. Aliases amount and quantity are accepted for value; unit_from and source for from; unit_to and target for to. On success the response echoes the canonical from and to codes, human-readable from_label and to_label strings, the converted result, the intermediate lumen_seconds quantity, the dimensionless factor from source to target, a short formula line suitable for UI display, the method tag luminous_energy_si, and the fixed list of units_supported. Missing value, non-finite numbers such as NaN or Infinity, missing unit fields, 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 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. Millilumen-second-scale pulse exposures and kilolumen-hour lamp-life figures share the same code path, so extreme magnitude pairs remain well-defined as long as IEEE double precision can represent the intermediate lumen-second product.
Browser use, API pricing, and everyday workflows
Switch to the prepaid API when a lighting design plugin, photobiology LIMS, camera metrology tool, horticultural lighting dashboard, product configurator, or instrumentation pipeline must convert luminous energy 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 luminous intensity or flux tools when a product pipeline needs several photometric measure families, or call it alone when search traffic is specifically for luminous energy conversion—lumen-seconds, talbots, lumen-hours, lumen-minutes, and SI multiples—rather than a general unit switchboard.
Integration use cases
Horticultural and architectural lighting logs
Normalize lumen-hours and kilolumen-hours in grow schedules, fixture runtime logs, and design reports when drawings mix SI time products and legacy labels.
Legacy talbot records and homework
Convert talbots and lumen-seconds for historical photometric tables and class problems with a prepaid, deterministic API and clear invalid_input on unknown units.
Technical questions
Which luminous energy units does this converter support?
Lumen-second (lm_s), talbot, lumen-minute (lm_min), lumen-hour (lm_h), kilolumen-second (klm_s), kilolumen-hour (klm_h), and millilumen-second (mlm_s). Full names and common aliases are accepted; unknown units raise invalid_input.
How do I convert 1 lumen-hour to lumen-seconds?
Send JSON with value: 1, from: "lm_h", to: "lm_s". The response result field is 3600, plus a lumen_seconds intermediate and a readable formula.