Clamp color to gamut
Bring out-of-range RGB values back inside the 0 to 255 scale: red 300, green −20 and blue 127.5 become 255, 0 and 127.5, and you see which channels changed. Nothing gets rounded along the way. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Resistance (Ω)
- 300
- G
- -20
- B
- 127.5
- Resistance (Ω)
- 255
- G
- 0
- Rgb
- rgb(255, 0, 127.5)
- Channels changed
- r, g
Clamp color to gamut when RGB data arrives with channels below zero or above two hundred fifty-five. This deterministic tool validates red, green, and blue, then corrects each channel independently to the nearest boundary of the standard eight-bit range. Values already inside the range pass through unchanged, including fractional values, because clamping controls bounds rather than precision. The response shows the corrected channels, a ready-to-read RGB string, whether anything changed, and exactly which channels were fixed.
What clamping an RGB color to gamut means
An eight-bit RGB color normally expresses red, green, and blue on an inclusive scale from zero to two hundred fifty-five. Data outside those limits cannot be represented directly in that range: a red channel of three hundred is too high, while a green channel of minus twenty is too low. Clamping fixes that specific problem by mapping every value below zero to zero, every value above two hundred fifty-five to two hundred fifty-five, and leaving every value between the boundaries unchanged.
Each channel is handled independently, so correcting red never changes green or blue. This tool returns the clamped values as r, g, and b, plus an rgb function string that displays the same result. Clamping is deliberately narrower than color conversion, gamut mapping between color spaces, or perceptual compression.
It does not transform HSL, Lab, Display P3, or CMYK, and it does not attempt to preserve perceived hue after a color-space conversion. Its job is the practical one implied by numeric RGB bounds: validate three channels and force them into the valid zero-to-two-hundred-fifty-five interval in a transparent, reproducible way.
Validation, fractional channels, and deterministic results
Every channel is required and must be a finite number. Scientific notation is accepted when it resolves to a finite number. After validation, the algorithm applies min of two hundred fifty-five and max of zero and the channel value.
That formula has no hidden threshold, locale rule, or platform-dependent branch. Fractional values already inside the range remain fractional: one hundred twenty-seven point five stays one hundred twenty-seven point five. This is intentional because clamp and round are different operations, and silently rounding could damage data that a later renderer or interpolation step understands.
The implementation uses no network request, current date, random number, mutable shared state, or external model.
Where RGB gamut clamping belongs in a workflow
Color values often cross system boundaries where assumptions differ. Clamping is useful at the boundary where such values must become ordinary RGB channels for a canvas, stylesheet, thumbnail generator, device protocol, or stored design token. Place it after the calculation that may overshoot and before the consumer that requires bounded channels.
The returned changed fields can feed logging or quality metrics: accept the corrected color for resilience while recording that upstream data needed repair. Do not use clamping as a substitute for investigating systematically broken inputs, and do not treat it as a perceptual gamut mapper for wide-gamut color spaces; those jobs require different information and algorithms. For interactive work, run the same pure implementation directly in the browser.
What you can do with it
Stabilize rendering pipelines
Clamp arithmetic output before passing colors to a canvas, stylesheet generator, or image renderer.
FAQ
What happens to a channel below zero?
It becomes 0. Other channels are evaluated independently and remain unchanged when they are already in range.
What happens to a channel above 255?
It becomes 255, the upper boundary of the supported RGB channel range.
Are fractional RGB values rounded?
No. Finite fractional values from 0 through 255 are preserved because this capability clamps bounds and does not round precision.
Which values are rejected instead of clamped?
Missing channels, words, empty entries and anything that is not a finite number are refused. Plain numbers written as text and scientific notation are accepted when they resolve to a real number.
How do I know which channels were corrected?
The result says whether anything changed and lists the fixed channels in order. For red 300, green −20 and blue 127.5, only red and green are listed, because blue was already inside the range.
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/clamp-gamut \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"r":300,"g":-20,"b":127.5}'const res = await fetch("https://api.kit.forhosting.com/color/clamp-gamut", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"r": 300,
"g": -20,
"b": 127.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/clamp-gamut",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"r": 300,
"g": -20,
"b": 127.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/clamp-gamut", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"r":300,"g":-20,"b":127.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"r":300,"g":-20,"b":127.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/clamp-gamut", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"r": 300,
"g": -20,
"b": 127.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.clamp_gamut",
"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
Use the browser tool for quick cleanup or the API at $0.002 per request for repeatable color pipelines, imports, tests, and design-system automation.
What clamping an RGB color to gamut means
It also returns a changed boolean and an ordered channels_changed list, making it easy for a caller to distinguish clean input from repaired input without comparing the values itself.
Validation, fractional channels, and deterministic results
The preferred input fields are r, g, and b; the descriptive aliases red, green, and blue are accepted as well. Strictly numeric strings are accepted for forms, CSV-derived records, and query values, but empty strings, words, booleans, arrays, objects, Infinity, and NaN are rejected with invalid_input. Negative zero becomes zero through the clamp operation, avoiding an awkward signed-zero representation in the returned JSON. The changed flag becomes true only if at least one numeric value crosses a boundary, while channels_changed lists the affected short names in stable red, green, blue order.
Where RGB gamut clamping belongs in a workflow
A shader calculation may overshoot after adding light, an image-analysis export may contain a small negative component, a spreadsheet formula may produce two hundred fifty-five point two, or an animation interpolator may briefly travel beyond its intended endpoint. In test suites, assert both the bounded channels and channels_changed so later refactors cannot introduce wrapping, rounding, or whole-color rejection by accident. For automated imports and services, each successful API request costs $0.002.
Integration use cases
Repair imported RGB records
Bound overshooting spreadsheet, CSV, or API channels before saving them as standard RGB data.
Create deterministic test fixtures
Verify boundary behavior and track exactly which RGB channels a pipeline had to correct.
Technical questions
What does the API request cost?
A successful API request costs $0.002. You can also run the same deterministic operation in your browser.
Which inputs are rejected?
Missing, empty, nonnumeric, and non-finite channels are rejected with invalid_input. All three RGB channels are required.