CRC-32 checksum
The nine characters 123456789 give the CRC-32 value cbf43926, the same check ZIP archives and PNG images use, so you can compare your result with any standard tool. Change a single character and the hex value changes. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- 123456789
- Crc32
- cbf43926
- Crc32 int
- 3,421,780,262
- Bytes
- 9
- Algorithm
- CRC-32/ISO-HDLC
CRC-32 is the cyclic redundancy check almost everyone meets when verifying ZIP archives, PNG images, or network frames: a 32-bit residual computed with a fixed polynomial so that even small bit flips change the hex digest. You get an eight-digit lowercase hex string, the matching unsigned integer, the UTF-8 byte length, and an empty flag when the source string has zero length. No network call, no random salt, and no wall clock enter the computation.
How CRC-32 turns text into eight hex digits
A cyclic redundancy check treats your message as a long binary polynomial and divides it by a fixed generator polynomial, keeping only the remainder. For CRC-32 that remainder is thirty-two bits wide, so it is shown as eight hexadecimal digits and as a whole number. This tool uses the reflected polynomial EDB88320, starts the register with all bits set and flips all bits again at the end, which are the exact settings of the ZIP and PNG checksum. Your text is first encoded as UTF-8, so the bytes that enter the calculation are the ones a file or a network frame would really carry.
When to use it and what it cannot do
CRC-32 is the quick way to confirm that a file, an image or a frame arrived without accidental damage, and to show students how a one-character edit changes the result. To check that your own code matches, the nine characters 123456789 must give cbf43926. Watch for look-alikes: Castagnoli CRC-32C and the MPEG-2 variant share the name but not the result. Above all, CRC-32 is not a cryptographic hash. It is designed against accidental corruption, not to resist deliberate forgery, so never use it to prove that a file is genuine.
What you can do with it
Classroom and support demos
Show students and operators how a one-character edit changes the hex CRC without installing local utilities or cryptographic libraries.
FAQ
Is CRC-32 a cryptographic hash?
No. CRC-32 detects accidental corruption quickly; it is not designed to resist deliberate collision or forgery. Use SHA-family tools when you need a cryptographic digest.
What is the CRC-32 of an empty text?
It is 00000000. Empty input is allowed here, and the result also flags it as empty, so a blank entry is easy to tell apart from a real checksum.
Is this the same as CRC-32C?
No. This is the ZIP and PNG profile, also listed as CRC-32/ISO-HDLC or PKZIP. Castagnoli CRC-32C, used by some storage systems, and the MPEG-2 variant use different settings and give different values.
What happens to emoji and accented letters?
They count with their real bytes, because the text is first encoded as UTF-8, just as most file formats and web transfers store text.
Why does changing one character alter the CRC so much?
The remainder of the polynomial division is highly sensitive to the original bits, so even a small edit or a single flipped bit produces a different eight-digit value. That is what makes CRC-32 good at catching accidental corruption.
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/crc32 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"123456789"}'const res = await fetch("https://api.kit.forhosting.com/enc/crc32", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "123456789"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/crc32",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "123456789"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/crc32", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"123456789"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"123456789"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/crc32", 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": "123456789"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.crc32",
"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
This CRC-32 checksum tool accepts plain text, serializes it as UTF-8, and runs the standard IEEE profile used by PKZIP, PNG, and ISO-HDLC—the same path that yields the famous check value cbf43926 for the ASCII string one-two-three-four-five-six-seven-eight-nine.
What CRC-32 means and which polynomial this tool uses
A cyclic redundancy check treats your message as a binary polynomial and divides it by a fixed generator polynomial, keeping a short remainder that is highly sensitive to changes in the original bits. For CRC-32 the remainder is thirty-two bits wide, usually shown as eight hexadecimal digits. This capability implements the reflected IEEE polynomial often written as zero-x-E-D-B-eight-eight-three-two-zero in software, with initial value all ones and a final exclusive-or of all ones. That exact parameter set is the ZIP and PNG CRC, also catalogued as CRC-32 slash ISO-HDLC or CRC-32 slash PKZIP in reverse-engineering tables. It is not Castagnoli CRC-32C used by some storage systems, not the MPEG-2 non-reflected variant, and not a cryptographic hash: CRC-32 is designed for fast integrity checks against accidental corruption, not for resisting deliberate forgery. Input text is first encoded as UTF-8 so multi-byte characters such as accented letters or emoji contribute their real on-the-wire bytes, matching how most file formats and HTTP bodies treat strings. The well-known validation vector is the nine-digit ASCII payload one through nine, which must produce hexadecimal c-b-f-four-three-nine-two-six; empty input must produce eight zeros. If a third-party tool disagrees with this endpoint on the same UTF-8 bytes, it is almost always using a different polynomial, a different init or xor-out, or hashing a different encoding of the same characters.
Input contract, response fields, and empty input behaviour
Empty string is allowed on purpose: many CRC libraries document the zero-length residual as zero, and pipelines that hash optional fields need a stable answer instead of a hard failure. Algorithm is always the label CRC-32 slash ISO-HDLC and polynomial is always the string zero-x-E-D-B-eight-eight-three-two-zero so OpenAPI examples and support replies can quote the profile without ambiguity. There is no mode switch for other CRC widths or polynomials: if you need CRC-16, Adler-32, or a cryptographic digest, use a dedicated capability so each landing page matches a single search intent. POST a JSON body with the required field text set to the string you want to checksum. Aliases input, value, s, string, and content are accepted so older forms and short clients still bind. Finite numbers and big integers are stringified; objects, arrays, booleans, null, Infinity, and NaN raise invalid_input and are not billed. When the source length is zero the response sets empty to true, crc32 to eight zero digits, crc32_int to zero, and bytes to zero. For non-empty input empty is false, bytes equals the UTF-8 length (which can exceed the JavaScript character length for multi-byte glyphs), crc32 is the lowercase eight-digit hex residual without a zero-x prefix, and crc32_int is the same value as an unsigned thirty-two-bit integer useful in languages that prefer numbers over strings.
Where a CRC-32 checksum API earns its keep
Developers paste short configuration fragments, protocol samples, and filename stems into a CRC-32 checksum calculator when they need a compact integrity tag that matches ZIP and PNG tooling without installing a local utility. Support engineers recompute residuals from ticket text to confirm that a pasted dump was not truncated in transit. Education labs use the same endpoint to show that changing one character flips many hex digits, illustrating error detection without introducing cryptographic machinery. Keep payloads under the documented character ceiling, treat the hex field as the canonical paste target, and you get reproducible ZIP-compatible CRC-32 values for docs, SDKs, edge workers, and classroom demos without standing up a separate hash service.
Integration use cases
ZIP and PNG-compatible integrity tags
Compute the IEEE CRC-32 of short text so residuals match PKZIP, PNG, and ISO-HDLC tooling when pasting into tickets, firmware notes, or config checks.
CI golden vectors and empty-input fixtures
Pin 123456789 → cbf43926 and empty → 00000000 so continuous integration catches polynomial or UTF-8 encoding drift immediately.
Technical questions
How do I compute a CRC-32 checksum of text?
Send JSON with text set to your string. The crc32 field returns eight lowercase hex digits for the IEEE / ZIP / PNG residual over the UTF-8 bytes; crc32_int is the same value as an unsigned integer.
Which CRC-32 polynomial does this use?
The standard IEEE reflected polynomial 0xEDB88320 with init and xor-out 0xFFFFFFFF—the profile used by ZIP, PNG, and ISO-HDLC (check value cbf43926 for 123456789).
What happens with empty input?
Empty text is valid. The response sets empty to true, crc32 to 00000000, crc32_int to 0, and bytes to 0. Missing or non-string text raises invalid_input.
What does the CRC-32 checksum tool cost?
The browser widget is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.