ForHosting KIT · Images

Compare color space gamut coverage and uses

Color space names appear in camera settings, monitor specifications, image exports, cinema deliverables, and television standards, yet a simple widest-to-smallest ranking can hide important differences.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

This comparator places any two supported spaces side by side. It reports rounded chromaticity-triangle area relative to sRGB, explains whether one triangle contains the other or whether each reaches colors the other misses, and summarizes the workflow where each is normally used. The deterministic result is intended for quick technical orientation, not device certification or color conversion.

Read gamut as a shape, not only a percentage

A color gamut is the set of colors represented by a color space under its specification. On a chromaticity diagram, the red, green, and blue primaries form a triangle. Comparing those triangles is a useful way to understand relative reach. This tool expresses each triangle's rounded area with sRGB set to one hundred percent, making broad scale differences easy to recognize. A larger number means more total diagram area, but it does not necessarily mean that every color in the smaller numerical result exists inside the larger one. Adobe RGB and DCI-P3 show why. Adobe RGB reaches farther toward cyan and green, whereas DCI-P3 reaches farther toward saturated red and yellow. The triangles overlap substantially, but neither completely contains the other. For that reason, read the relationship sentence together with the percentage values. The figures provide an overall comparison; the shape description identifies the hue regions responsible for the difference. This avoids turning one convenient metric into a misleading promise about all colors available in an editing, display, print, or mastering workflow.

Choose a space that matches the destination

sRGB is the dependable default for websites, interfaces, ordinary image exchange, and delivery to unknown consumer displays. Its relatively modest gamut favors compatibility when color management is uncertain. Adobe RGB is associated with photography and print because its additional cyan-green reach can preserve useful colors in some scenes and printing processes. DCI-P3 was defined for digital cinema presentation. Display P3 shares its primary chromaticities but uses different white-point and transfer characteristics, so the names are related without being interchangeable in every technical detail. Rec.2020 belongs to ultra-high-definition television and HDR workflows. Its very wide triangle is often used as a container even when a current display cannot reproduce the complete gamut. Selecting the widest space automatically is therefore not a sound delivery policy. The file format, embedded profile, receiving software, color-management path, and final device must interpret the encoded values consistently. Choose the space supported by the intended destination, preserve source profiles during editing, and perform conversions with color-managed software instead of merely assigning a different profile name.

Know the limits of a standards comparison

The result compares named color-space definitions, not the measured behavior of a particular camera, scanner, monitor, projector, printer, ink, or paper. A display advertised with a percentage of DCI-P3 may cover a different portion of that space depending on the test method, brightness, calibration, tolerance, and viewing conditions. The comparison also does not evaluate bit depth, dynamic range, transfer functions, encoding precision, white point, tone mapping, or profile quality. Those properties can strongly affect an image while leaving the primary triangle unchanged. A wide-gamut file cannot create colors absent from the source, and an unmanaged application can show wide-gamut content with incorrect saturation. Treat the rounded figures as geometric orientation, not as a certification value or a conversion recipe. When choosing hardware, consult independent measurements of the actual device and confirm the measurement basis. When mastering or exporting content, follow the exact delivery specification, use an appropriate rendering intent, and inspect clipping or soft-proof warnings. This comparator is most useful at the beginning of that work because it gives a concise, consistent explanation of relative reach and typical purpose.

What you can do with it

Choose an export target

Compare an editing space with the expected delivery space before exporting photographs or graphics.

Interpret display specifications

Understand broad differences among sRGB, Adobe RGB, P3-oriented, and Rec.2020 coverage claims.

Document a media workflow

Add a concise explanation of gamut reach and customary use to production notes.

FAQ

What does the comparison cost?

The API costs $0.002 per comparison, while the browser version runs locally at no charge.

Does a larger area mean one gamut contains the other?

Not always. Adobe RGB and DCI-P3 extend farther in different hue regions, so neither fully contains the other.

Is Display P3 identical to DCI-P3?

No. They share primary chromaticities but differ in white-point and transfer characteristics.

Can every Rec.2020 display show the entire gamut?

No. Rec.2020 is often a wide container, while physical displays may reproduce only part of it.

Can this result certify a monitor or printer?

No. Certification requires measurements of the actual device under defined conditions.

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

POSThttps://api.kit.forhosting.com/image/color-space-gamut-compare

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/image/color-space-gamut-compare \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"color_space_a":"sRGB","color_space_b":"DCI-P3"}'

const res = await fetch("https://api.kit.forhosting.com/image/color-space-gamut-compare", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "color_space_a": "sRGB",
    "color_space_b": "DCI-P3"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/color-space-gamut-compare",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "color_space_a": "sRGB",
    "color_space_b": "DCI-P3"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/color-space-gamut-compare", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"color_space_a":"sRGB","color_space_b":"DCI-P3"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"color_space_a":"sRGB","color_space_b":"DCI-P3"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/color-space-gamut-compare", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "color_space_a": "sRGB",
  "color_space_b": "DCI-P3"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.color_space_gamut_compare",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	15
`max_megapixels`	12

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.

Read the full KIT documentation →