Why can't every L*a*b* value be converted to a valid hex color?

L*a*b* was designed to represent every color humans can perceive, a much larger space than any physical display can reproduce. sRGB (and therefore hex colors) can only represent a subset of that space, so some Lab coordinates simply fall outside what a screen can show; this tool clamps those out-of-gamut results to the nearest representable RGB value instead of failing.

How do I know if my result was clamped?

The tool explicitly flags when the computed RGB values fell outside the normal 0-255 range before clamping, so you can tell whether the displayed hex color is an exact conversion or an approximation of an out-of-gamut Lab coordinate.

What Lab values produce pure white and pure black?

lab(100, 0, 0) produces white, #FFFFFF, and lab(0, 0, 0) produces black, #000000, matching the D65 reference white point's own definition at the top of the lightness scale.

Why does this need L* between 0 and 100 but no fixed range for a*/b*?

L* is defined to run from 0 (black) to 100 (white) by construction, but a* and b* have no fixed theoretical bound, extreme values usually just mean the resulting color falls further outside the sRGB gamut and gets clamped more aggressively.

LAB to Hex Color Converter - Convert CIE Lab to Hex Online

Overview

Introduction

L*a*b* coordinates show up in color-management software, print-matching workflows, and color-science tooling, and sooner or later you need to see what a given Lab coordinate would actually look like as a displayable hex color.

This tool runs the full inverse pipeline, Lab to XYZ to linear RGB to sRGB, to compute that hex color, clamping the result when the requested Lab coordinate falls outside what a screen can display.

What Is LAB to Hex Color Converter?

A Lab-to-hex converter takes L* (lightness, 0-100), a* (green-red axis), and b* (blue-yellow axis) and reverses the standard sRGB-to-Lab pipeline to recover red, green, and blue channel values.

Because Lab's addressable space is larger than sRGB's, this is fundamentally a gamut-mapping operation for some inputs: the tool computes the mathematically exact linear RGB values first, then clamps anything outside 0-1 before converting to a hex byte.

How LAB to Hex Color Converter Works

L* and a*/b* are first converted back into normalized XYZ coordinates via the inverse of the Lab nonlinear function (a cube, or a linear ramp near black, mirroring the forward conversion's piecewise cube root), then scaled by the D65 reference white's X, Y, Z.

XYZ is converted to linear RGB via the inverse of the sRGB-to-XYZ matrix, each channel is gamma-encoded back into sRGB, and finally clamped to 0-1 and scaled to a 0-255 byte before hex-encoding.

When To Use LAB to Hex Color Converter

Use this when you have Lab coordinates, from a color-science tool, a physical color measurement, or a Delta E calculation, and need to preview or use them as an actual hex color.

It's especially useful for spot-checking whether a Lab value you're working with is even representable on a normal screen, via the clamped flag.

Often used alongside Hex Color to LAB Converter, Hex Color to HSL Converter and RGBA to Hex Color Converter.

Features

Advantages

Implements the full, standard inverse Lab pipeline rather than a simplified approximation.
Explicitly reports when a result had to be clamped, so you know when you're looking at an approximation of an out-of-gamut color.
Live swatch preview shows the resulting (possibly clamped) color immediately.

Limitations

Out-of-gamut Lab values are clamped per-channel after conversion, which is a simple but not perceptually optimal gamut-mapping strategy (it can shift both hue and lightness slightly compared to more sophisticated mapping algorithms).
Only produces a 6-digit hex color; Lab itself has no alpha/transparency concept.

Examples

Reference white

Input

L*=100, a*=0, b*=0

Output

#FFFFFF

By construction, this is exactly the D65 reference white point this whole pipeline is built around.

Round-tripping pure red's Lab value

Input

L*=53.24, a*=80.09, b*=67.2

Output

#FF0000

These are the standard Lab coordinates for sRGB red; converting them back recovers the original hex color exactly.

Best Practices & Notes

Best Practices

Check the clamped flag before trusting a result as an exact conversion, especially for large |a*| or |b*| values.
When you specifically need a color inside the sRGB gamut, prefer picking Lab coordinates you know are achievable (e.g. derived from an existing hex color) rather than arbitrary extreme values.

Developer Notes

Implements the exact inverse of the forward sRGB->Lab pipeline (inverse Lab nonlinearity, inverse XYZ matrix, inverse gamma) and clamps final linear RGB to [0, 1] before byte conversion when out of range; a small floating-point tolerance prevents harmless rounding noise (e.g. 1.0000000592 instead of exactly 1.0) from being misreported as clamped.

LAB to Hex Color Converter Use Cases

Previewing what a Lab coordinate from a color-science calculation or physical measurement actually looks like on screen
Round-tripping a hex color through Lab (via the companion Hex Color to LAB Converter tool) and back to confirm the pipeline is lossless for in-gamut colors
Checking whether a given Lab value is representable in sRGB at all

Common Mistakes

Assuming every Lab coordinate has an exact sRGB equivalent; many combinations of a*/b* at a given L* simply don't exist in the sRGB gamut and will be clamped.
Providing a* or b* on the wrong sign convention (mixing up which direction is 'positive'); positive a* is toward red, positive b* is toward yellow, not the other way around.

Tips

Use the Hex Color to LAB Converter tool first to see what Lab coordinates a known hex color has, a good way to calibrate what 'realistic' a*/b* ranges look like.
If the clamped flag is set and the color looks off, try reducing the magnitude of a*/b* toward zero to move the requested color back inside the sRGB gamut.

LAB to Hex Color Converter