Crockford Base32 encoder & decoder
“Hello” becomes 91JPRV3F in Crockford Base32, an alphabet without I, L, O or U, so serial numbers and support codes survive being read aloud or retyped. An optional check symbol catches a mistyped character. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello
- Calculation mode
- Encode
- Result
- 91JPRV3F
- Length
- 8
- Input bytes
- 5
- Alphabet
- Crockford
Crockford Base32 is a practical encoding alphabet designed for people who read and type identifiers by hand. It drops the symbols that most often cause mix-ups—I, L, O, and U—so a serial number, short token, or support code survives email clients, paper notes, and phone read-backs. This Crockford Base32 encoder and decoder converts UTF-8 text to that alphabet and back, accepts the usual human tolerances (lowercase, hyphens, O as zero, I and L as one), and can append or verify Crockford’s optional modulo-37 check symbol when you need transcription error detection.
What Crockford Base32 is and how it differs from RFC 4648 Base32
Standard Base32 (RFC 4648) uses A–Z and 2–7 with equals-sign padding. That alphabet is fine for wire formats and MIME, but it is awkward for humans: capital I looks like one, capital O looks like zero, and U appears in places where spoken codes get muddy. Douglas Crockford’s Base32 alphabet keeps thirty-two symbols—digits zero through nine plus A through Z with I, L, O, and U removed—so every remaining glyph is easy to print, read aloud, and type.
Decoding is deliberately forgiving: hyphens may separate groups for readability, letter case does not matter, the letter O is treated as digit zero, and the letters I and L are treated as digit one. There is no equals-sign padding; incomplete trailing five-bit groups are still emitted as a final symbol on encode, matching common Crockford implementations for short strings. An optional check symbol drawn from a thirty-seven-symbol set (the thirty-two data symbols plus asterisk, tilde, dollar, equals, and U) is the remainder of the symbol-string value modulo thirty-seven.
Append it when labels will be retyped; verify it on decode when check is true.
Where a Crockford Base32 encoder earns its keep
Product and operations teams use Crockford Base32 for short public identifiers that support staff must read over the phone without spelling I versus one for every character. Warehousing and asset tags benefit from hyphenated groups and an optional check symbol that catches a single mistyped digit before a wrong bin is picked. Developers building ULID-style or custom compact tokens want an encoder that matches the Crockford alphabet people expect, not RFC 4648’s 2–7 set, and a decoder that accepts the messy paste from chat or PDF.
Classroom and interview exercises on human-friendly encodings need a deterministic oracle that rejects U in data and explains check mismatches instead of returning garbage.
What you can do with it
Human-readable support and ticket codes
Encode short references so agents can read them aloud without I/L/O confusions; decode pastes that include hyphens or lowercase.
FAQ
What alphabet does Crockford Base32 use?
Digits 0–9 and letters A–Z excluding I, L, O, and U (thirty-two symbols). Decode accepts lowercase, hyphens, O as 0, and I/L as 1.
How is this different from RFC 4648 Base32?
RFC 4648 uses A–Z and 2–7 with '=' padding. Crockford drops ambiguous letters, uses 0–9 plus a different letter set, skips padding, and offers an optional check symbol.
What happens if I send an invalid character?
U is not valid in the data alphabet (it may appear only as a check symbol).
What is the Crockford check symbol and when should I add it?
It is one extra character: the remainder of the code's value divided by 37, taken from the 32 data symbols plus *, ~, $, = and U. Add it to labels people will retype; when you decode with the check turned on, a wrong final character makes the decode fail.
Can I decode a code that has hyphens or lowercase letters?
Yes. Hyphens between groups are ignored, letter case does not matter, the letter O is read as zero and the letters I and L as one, so a messy paste from a chat or a PDF still decodes. The letter U is rejected inside the data.
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/enc/base32-crockford \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base32-crockford", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base32-crockford",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base32-crockford", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base32-crockford", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Hello"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base32_crockford",
"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
The same pure parse logic powers the free browser tool and the billed API path, so homework scripts, inventory labels, and production workers never disagree on a character. Malformed input fails with invalid_input and a clear message naming the bad symbol or check mismatch instead of silent corruption.
What Crockford Base32 is and how it differs from RFC 4648 Base32
This capability implements that human-first contract over UTF-8 text with deterministic bit packing, so the same input always yields the same Crockford string and the reverse decode restores the original bytes when the payload is valid UTF-8.
Input contract, response shape, and error behaviour
Empty text encodes to an empty result. Length is capped so oversized pastes fail early. Failed validation is not billed. POST a JSON body with required string field text and optional mode and check. Mode is encode or decode and defaults to encode; aliases op, operation, and direction are accepted. Check is a boolean defaulting to false; when true on encode the API appends the Crockford check symbol and returns it as check_symbol, and when true on decode the trailing character must match the modulo-thirty-seven remainder or the task fails with invalid_input. On encode success the body includes mode, the original text, result (the Crockford string), length, input_bytes, alphabet Crockford, charset summary, check flag, and standard label. On decode success you get mode, text, result (UTF-8 string), length, output_bytes, the same alphabet metadata, and when check was requested check_verified plus the check_symbol that passed. Decoding without check treats the entire string as data after stripping hyphens and applying O/I/L aliases; any character outside the data alphabet—including a bare U in the payload—raises invalid_input naming the position and character. Invalid mode or non-boolean check values also fail with invalid_input. Pair encode then decode in your tests with check both true and false so goldens pin the alphabet, aliases, and check math across runtimes.
Where a Crockford Base32 encoder earns its keep
Keep payloads modest, pin result strings in automated tests, and you get reproducible Crockford Base32 for labels, support codes, and edge workers without standing up a custom alphabet library of your own.
Integration use cases
Asset tags with optional check symbol
Print Crockford labels with check=true so a single mistype fails verification before inventory moves to the wrong location.
Token and ID pipelines
Generate and verify Crockford Base32 payloads in scripts and workers with the same pure logic as the free browser tool.
Technical questions
What does the check option do?
On encode, check=true appends a modulo-37 check symbol from the thirty-seven-symbol set. On decode, check=true requires that trailing symbol and rejects mismatches.
What does the Crockford Base32 encoder cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.