Nearest Crayola color
#EE204D is the crayon Red exactly, with a distance of 0 in the classic box of 64 colors. Match a color sampled from a photo or worksheet to a crayon students can actually pick up. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hex
- #EE204D
- Hex
- #ee204d
- Resistance (Ω)
- 238
- G
- 32
- B
- 77
Teachers, craft sellers, classroom designers, and brand teams often start from a hex color sampled off a photo or a style sheet and then need the closest classic Crayola crayon they can actually buy or name in a lesson. This tool takes a single CSS hex value—three or six hexadecimal digits, with or without a leading hash—and returns the nearest crayon from a fixed sixty-four-color classic Crayola table by Euclidean distance in eight-bit red-green-blue space. When the hex already matches a published crayon exactly, the response marks exact true and the distance is zero. When it sits between crayons, you still get a stable closest name, that crayon’s official hex and channels, and a numeric distance so lesson plans, inventory pickers, and print-prep scripts can decide how close is close enough. Invalid hex strings fail with a clear validation error instead of inventing a crayon.
How the nearest classic crayon is chosen
Every classic Crayola crayon in this table is a fixed name plus a published red-green-blue triple from zero through two hundred fifty-five. The palette is the familiar sixty-four-count assortment that people mean by a classic box: the original eight of Red, Orange, Yellow, Green, Blue, Violet (Purple), Brown, and Black, plus White and Gray, plus the well-known classroom names such as Carnation Pink, Scarlet, Cerulean, Macaroni and Cheese, Granny Smith Apple, Tickle Me Pink, Robin’s Egg Blue, Timberwolf, and Wild Strawberry.
Fluorescent neon variants and retired specialty boxes are left out on purpose so the result is a crayon a teacher can still find in a standard pack. Your input is normalized: optional leading hash, lowercased hex digits, and three-digit shorthand expanded by doubling each nibble so that f zero zero becomes f f zero zero zero zero. The algorithm then measures Euclidean distance in RGB space: the square root of the sum of squared channel differences between your color and each crayon triple.
The crayon with the smallest distance wins. When two crayons sit at the same numeric distance, the alphabetically first name is kept so the result never flips between runs. Distance zero means an exact palette hit and the exact flag is true; a positive distance means a nearest-neighbor approximation you can still use in a shopping list, a lesson key, or a craft-kit spec.
Where nearest-crayon lookup shows up in real work
Elementary art rooms and homeschool kits often start from a color sampled off a worksheet or a photo and need the closest named crayon so students can follow a key without mixing custom paints. Craft sellers and party-favor shops map brand hex values from invitations or logos onto a physical crayon they can pack, then print the official name on a label. Curriculum writers who generate coloring-page answer keys need a stable oracle rather than a free-form model guess that might invent a crayon that is not in the box.
Designers who still talk in Crayola names with non-designer stakeholders can translate a style-token hex into a name everyone already knows from childhood. Inventory and procurement scripts can score a requested color against the classic table and flag a large distance when no crayon is close enough and a custom marker should be substituted instead.
If you later need the nearest CSS named color rather than a crayon, multi-format conversion across HEX, RGB, HSL, LAB, and CMYK, dominant-color extraction from images, or WCAG contrast checks, treat those as separate search intents and landings rather than overloading this dedicated nearest-Crayola-color page.
What you can do with it
Name a sampled hex for the art room
Turn a hex sampled from a worksheet, photo, or slide into the closest classic crayon name students can actually pick from the box.
Map brand colors onto physical crayons
Match invitation or logo hex values to a packable crayon so craft kits and party favors use a real, named stick of wax.
FAQ
How is the nearest Crayola crayon chosen?
The tool parses your hex into 8-bit RGB, then picks the classic 64-color Crayola crayon with the smallest Euclidean RGB distance. Ties keep the alphabetically first name.
Which hex formats are accepted?
Three-digit and six-digit hex codes, with or without a leading #.
What does exact true mean?
Your hex matches a classic crayon’s published RGB values exactly, so distance is zero. Otherwise exact is false and distance is the Euclidean gap to the nearest crayon.
Is this the same as nearest CSS color name?
No. This landing matches classic Crayola crayon names from a fixed 64-color box. For CSS keywords such as tomato or rebeccapurple use the hex-to-color-name landing instead.
What does it cost?
The browser tool is free and runs locally.
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/nearest-crayola \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hex":"#EE204D"}'const res = await fetch("https://api.kit.forhosting.com/color/nearest-crayola", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hex": "#EE204D"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/color/nearest-crayola",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hex": "#EE204D"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/color/nearest-crayola", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hex":"#EE204D"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hex":"#EE204D"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/color/nearest-crayola", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"hex": "#EE204D"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "color.nearest_crayola",
"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
How the nearest classic crayon is chosen
The entire path is deterministic floating-point arithmetic with no random seeds, no wall-clock timestamps, and no network calls, so identical hex inputs always produce identical JSON.
What you send and what you get back
Send one string field named hex. Accepted shapes are six-digit codes such as hash E E two zero four D, three-digit shorthand such as hash f zero zero, and the same strings without a leading hash. Spaces around the value are trimmed. Classic checks include official Red as hash E E two zero four D resolving to Red with exact true; pure web red hash f f zero zero zero zero resolving near Scarlet with a positive distance; and bare six-digit codes without a hash resolving the same as their hashed form. The transport aliases color and value are accepted as well, so older forms and design-token dumps can call the same contract. Non-hex characters, empty strings, four-digit or eight-digit alpha forms, and non-string types fail with invalid_input and are not charged. On success the response echoes a normalized lowercase six-digit hex with a leading hash, integer channels r, g, and b for the input, the winning crayon name, that crayon’s crayola_hex plus crayola_r, crayola_g, and crayola_b channels, a cleaned floating distance, a boolean exact flag, the palette_size of the classic table, and a short formula note describing Euclidean RGB distance with alphabetical tie-breaking. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where nearest-crayon lookup shows up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Bulk hex tables for lesson keys
Convert large hex lists from theme JSON into stable nearest crayon names for coloring-page keys and curriculum answer sheets.