LAB to RGB converter
The LAB color lightness 53.2407941413, a 80.0924595964, b 67.2031965159 comes back as rgb(255, 0, 0), pure red #FF0000. Bring LAB targets from a brand book or print spec onto the screen with the same result every time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- L
- 53.2407941413
- A
- 80.0924595964
- Lab b
- 67.2031965159
- L star
- 53.2407941413
- A star
- 80.0924595964
- B star
- 67.2031965159
- Resistance (Ω)
- 255
This LAB to RGB converter takes three CIE L*a*b* components—lightness L* from zero through one hundred, a* on the green–red axis, and b* on the blue–yellow axis—and returns sRGB channel integers from zero through two hundred fifty-five under the standard D65 white point used on the web. Designers, print engineers, and students use this mapping when a brand or print workflow stores Lab targets but the product UI, CSS, or design tokens need eight-bit red, green, and blue. The engine is fully deterministic: it inverts the CIE Lab pivot into XYZ, multiplies by the inverse D65 sRGB matrix, applies forward sRGB gamma, then rounds and clamps each channel—never calling the network, sampling randomness, or depending on the clock.
What LAB to RGB means and what you get back
CIE L*a*b* rearranges a colour stimulus into a lightness axis L* (zero for black through about one hundred for diffuse white under D65) and two chromatic axes: a* runs green-negative to red-positive, and b* runs blue-negative to yellow-positive. Display and CSS work still need eight-bit sRGB channels, so this calculator reverses the usual graphics pipeline.
First it rebuilds relative XYZ from L*, a*, and b* with the CIE inverse pivot and the D65 reference white, then multiplies by the inverse of the standard D65 sRGB matrix to obtain linear red, green, and blue light. Forward sRGB companding restores the gamma curve used by browsers; each unit channel is scaled by two hundred fifty-five, rounded to the nearest integer, and clamped into zero through two hundred fifty-five.
How the three LAB values are read
Outer whitespace on string numbers is trimmed; scientific notation is allowed when the token is a finite decimal. A bare JavaScript number is accepted only when it is finite and inside the declared range: L* must stay from zero through one hundred, and a* and b* must stay inside plus or minus one hundred sixty.
Values outside those bounds fail with a message that names the field and states the allowed range, rather than being clamped on the Lab side—clamping applies only to the final sRGB channels when the colour is outside the display gamut. Pure white Lab maps to two hundred fifty-five on all three channels; pure black maps to zero; the pure-red Lab triple that comes from the inverse of full red sRGB maps back to two hundred fifty-five, zero, zero within rounding.
Where Lab-to-RGB conversion fits in design, study, and software
Designers meet this mapping when a brand guide or print specification lists Lab targets and a product UI expects CSS rgb() or hex swatches, when a design system documents both Lab references and screen RGB side by side, or when a palette must be previewed on a standard sRGB display after colour-managed edits in Lab. Accessibility and research workflows sometimes compute in Lab for uniformity, then project back to sRGB for delivery.
Students see the inverse path in computer-graphics and colour-science courses that introduce XYZ and Lab after sRGB, in digital photography classes that move between Lab adjustments and channel sliders, and in interview warm-ups that ask for a mental convert of a short triple. Pair it with RGB-to-Lab when you need the forward map, and with multi-format colour tools when you need hex or CMYK packaging around the same numbers.
What you can do with it
Print Lab targets to screen RGB
Turn CIE L*a*b* brand or proof values into sRGB channels and hex for CSS, tokens, and stakeholder previews.
Homework and teaching demos
Check student Lab-to-sRGB work and live-demo XYZ and D65 inverse without opaque calculator apps.
FAQ
What does the LAB to RGB converter cost?
It is free in your browser on this page.
What do L*, a* and b* mean in a LAB color?
L* is lightness, from black up to diffuse white. a* runs from green on the negative side to red on the positive side, and b* runs from blue on the negative side to yellow on the positive side.
Which RGB color is LAB 53.2407941413, 80.0924595964, 67.2031965159?
It is rgb(255, 0, 0), pure red, written as #FF0000. That LAB triple is exactly what full red on screen turns into, so converting it back returns the same red.
What happens if a LAB color is outside what a screen can show?
Each channel is limited to the 0–255 range, so you still get a usable color, and the result is flagged as out of gamut so you know it was clipped and is only an approximation.
Which white point does the conversion use?
D65, the standard daylight white used by sRGB screens and the web. If your LAB values were measured under another white point, convert them to D65 first or the colors will drift.
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/color/lab-rgb \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"l":53.24,"a":80.09,"lab_b":67.2}'const res = await fetch("https://api.kit.forhosting.com/color/lab-rgb", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"l": 53.24,
"a": 80.09,
"lab_b": 67.2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/lab-rgb",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"l": 53.24,
"a": 80.09,
"lab_b": 67.2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/lab-rgb", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"l":53.24,"a":80.09,"lab_b":67.2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"l":53.24,"a":80.09,"lab_b":67.2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/lab-rgb", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"l": 53.24,
"a": 80.09,
"lab_b": 67.2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.lab_rgb",
"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
l_min | 0 |
l_max | 100 |
a_min | -160 |
a_max | 160 |
lab_b_min | -160 |
lab_b_max | 160 |
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
Components outside the declared ranges are rejected with a clear invalid_input error; colours that lie outside the sRGB gamut are clamped to the nearest displayable channel set and flagged with out_of_gamut so callers can see the clip.
What Lab-to-RGB conversion means and what the response contains
Lab b* is always named lab_b or b_star in the output so it never collides with the RGB blue channel field b. There is no silent accept of Infinity, NaN, or empty strings: missing or out-of-range components fail with invalid_input.
How l, a, and lab_b are read and how RGB stays reproducible
The preferred fields are l for L*, a for a*, and lab_b for b*, but aliases L, L_star, and lightness for lightness, a_star and capital A for a*, and b_star, b, and capital B for b* are accepted so spreadsheets, query strings, and typed forms can reuse the same contract without renaming columns. After validation, conversion uses only closed-form arithmetic on the inverse pivot, the fixed inverse matrix, and the IEC gamma curve, then rounds XYZ components to a fixed decimal width so JSON goldens and CI assertions stay stable across platforms. 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 Lab inverse and sRGB gamma yourself.
Where Lab-to-RGB conversion fits in design, study, and software
Print and packaging teams reverse Lab measurements or proof values into approximate screen previews so stakeholders can see a rough on-monitor match even when the true colour is slightly out of gamut—the out_of_gamut flag tells them the preview was clamped. 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 or design review to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic test fixtures
Generate reproducible RGB results for unit tests, property checks, and CI assertions on colour helpers.
Technical questions
What range is allowed for L*, a*, and b*?
L* (field l) must be from 0 to 100 inclusive. a* and lab_b (b*) must each be between −160 and 160. Values outside those ranges, non-finite numbers, and missing fields are rejected with invalid_input.
What white point does this use?
Illuminant D65 with reference white Xn=0.95047, Yn=1.0, Zn=1.08883, matching standard sRGB and web colour practice. The response includes white_point: "D65".
What does out_of_gamut mean?
Some Lab colours cannot be represented in sRGB. Channels are clamped to 0–255 and out_of_gamut is set to true so you know the displayable RGB is an approximation of the requested Lab.
Why is Lab b* called lab_b?
The output field b is the blue RGB channel. Lab b* is accepted and returned as lab_b and b_star so it never overwrites the RGB blue channel.