LUT blend intensity preview
The LUT blend intensity preview calculator shows the color produced when a lookup-table grade is applied at less than full strength.
Run — free
Supply the original pixel color, the color returned by the LUT at full strength, and an intensity percentage. The calculator interpolates the red, green, and blue channels and returns a reusable hex value, an RGB object, and an RGB string. It is useful for preview tools, editing interfaces, test fixtures, and any workflow that needs a clear numerical model of a partial color grade without processing an entire image or video frame.
Represent the source and fully graded colors
Begin with two measurements of the same pixel or representative color. The base color is the value before color grading, while the LUT color is the value after the lookup table has been applied at full strength. Enter each value as a three-digit or six-digit RGB hex color. Short hex is expanded before calculation, and returned colors use normalized uppercase six-digit notation. The relationship between these values matters: this calculator does not run a LUT file, inspect an image, or infer what a grade should produce. It blends color values that you already know. That makes it especially suitable for interface previews, pipeline tests, and design discussions where a full-strength LUT result has already been sampled. Use values from the same color space and transfer convention. Mixing a display-referred sRGB base sample with a linear-light LUT result may yield a valid numerical blend but an unsuitable visual prediction. For dependable comparisons, capture both endpoints from the same stage of the color pipeline, with matching encoding, range, and channel order. The result then describes a precise point between those endpoints rather than an ambiguous conversion between unlike representations.
Choose the LUT intensity and understand the calculation
Intensity specifies how much of the fully graded value contributes to the preview. Zero percent returns the base color unchanged, one hundred percent returns the LUT color, and fifty percent places every channel halfway between its two endpoint values. Internally, the percentage is divided by one hundred to obtain a factor. For each RGB channel, the calculator adds the factor-weighted difference between the LUT channel and the base channel to the base channel. The resulting channel is rounded to the nearest integer because ordinary eight-bit RGB colors cannot represent fractional channel values. This is straight linear interpolation of the encoded RGB numbers, often called a channel lerp. It mirrors the simple strength or opacity control used by many preview interfaces, and it is deterministic across repeated calls. It is not a simulation of every grading application. Some editors blend in linear light, use higher-precision buffers, apply perceptual transforms, or position the mix at another point in the processing graph. If your production system follows one of those models, treat this result as a UI preview or test reference and confirm the final rendering in that system. Values below zero or above one hundred are rejected rather than silently clamped, so configuration mistakes remain visible.
Use the output in preview and validation workflows
The response includes normalized endpoint colors, the submitted intensity, its zero-to-one factor, and the blended result in three convenient forms. Use the hex value for CSS controls, swatches, documentation, and compact storage. Use the RGB object when downstream code needs separate numeric channels. Use the RGB string when constructing a browser style or displaying an immediately recognizable value to an operator. The method field records that the calculation used linear RGB interpolation, which helps distinguish this result from a perceptual or linear-light blend in logs and fixtures. A common preview workflow samples several meaningful pixels before and after a LUT, calls the calculator for each pair at the editor's selected strength, and paints small comparison swatches. A validation workflow can instead store endpoint inputs and expected intermediate results to test an intensity slider, preset migration, or rendering service. Remember that a single color does not summarize an entire LUT: lookup tables can affect shadows, midtones, highlights, and hues differently. Repeat the calculation for enough representative samples to assess the grade. For API automation, each request costs $0.002. The function performs no upload, network lookup, random choice, or time-dependent operation, so identical inputs always produce identical output.
What you can do with it
Preview a strength slider
Calculate the swatch shown while a user adjusts a LUT intensity control without rendering a complete frame.
Test grading UI math
Create deterministic expected colors for endpoint, midpoint, and custom-percentage tests in an editing interface.
Compare preset strengths
Generate representative color samples for several strengths when documenting or reviewing a grading preset.
FAQ
What happens at zero percent intensity?
The result equals the base color exactly because none of the fully graded LUT value contributes to the blend.
What happens at one hundred percent intensity?
The result equals the supplied LUT color exactly.
Are intensities outside 0 to 100 clamped?
No. They return an invalid input error so an incorrect slider value or configuration is not hidden.
Does this apply a .cube or other LUT file?
No. It blends a known base color with a known full-strength LUT result; it does not parse or execute a LUT file. Each fractional channel is rounded to the nearest integer for an eight-bit RGB result.
What does an API request cost?
Each request costs $0.002.
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/video2/color-grade-lut-intensity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"base_color":"#406080","lut_color":"#D08020","intensity":40}'const res = await fetch("https://api.kit.forhosting.com/video2/color-grade-lut-intensity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"base_color": "#406080",
"lut_color": "#D08020",
"intensity": 40
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video2/color-grade-lut-intensity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"base_color": "#406080",
"lut_color": "#D08020",
"intensity": 40
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video2/color-grade-lut-intensity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"base_color":"#406080","lut_color":"#D08020","intensity":40}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"base_color":"#406080","lut_color":"#D08020","intensity":40}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video2/color-grade-lut-intensity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"base_color": "#406080",
"lut_color": "#D08020",
"intensity": 40
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video2.color_grade_lut_intensity",
"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
max_mb | 500 |
max_minutes | 60 |
max_megapixels | 3.9 |
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. |