CRC Calculator
Compute CRC32, CRC16 or CRC8 with any polynomial, init, reflection and xorout — entirely on this device.
How the pasted characters become the bytes that are checksummed.
This page checksums pasted input only. CRC32 a file with the File Checksum Verifier
Parameters
Pick a published parameter set, or edit any field below for a custom one.
Used by zip, gzip, PNG, Ethernet, SATA
CRC detects accidental corruption — it is not a cryptographic hash and never a password or tamper-proofing tool.
32-bit · poly 04c11db7 · init ffffffff · reflect in on · reflect out on · xorout ffffffff
Same polynomial reversed edb88320
The checksum appears here as you type.
Hex only, case-insensitive; a leading 0x is not accepted here.
Every published parameter set over the same bytes, in catalogue order.
Press ? for shortcuts
Do it offline:$ printf '%s' 'hello' | python3 -c "import sys,zlib;print(format(zlib.crc32(sys.stdin.buffer.read()),'08x'))"
How to use it
- Paste the bytes you need a checksum for, then tell the tool whether the box holds UTF-8 text, hex bytes or Base64 bytes.
- Choose a model. The twelve named rows cover zip and PNG, iSCSI and Btrfs, Modbus RTU, XMODEM, USB, SMBus and 1-Wire sensors.
- Nothing fits? Switch to Custom and set width, polynomial, init, xorout and the two reflection switches yourself; the readout prints your polynomial in both bit orders.
- Paste a value you already hold to see which model produced it, copy either result row, or share a link carrying the result and your parameters.
A CRC is pinned down by six parameters: register width, polynomial, starting value, whether input bits and output bits are reflected, and a final XOR. Pick one of twelve named models — four CRC-32 variants, six CRC-16, two CRC-8 — or type your own six values, and the checksum updates as you type, in hex and unsigned decimal. Paste text, hex bytes or Base64 bytes; nothing leaves this device.
Examples
123456789cbf43926Those nine ASCII digits are the standard self-test input: every entry in the RevEng catalogue publishes its answer as a check value, and CRC-32 answers cbf43926 — 3421780262 as an unsigned decimal. Diff any implementation against this row first.
hello34f6A Modbus RTU frame carries this value low byte first, so f6 34 is what you would see on the wire. CRC-16/ARC uses the same polynomial 8005 and differs only in its starting register — 0000 rather than ffff — yet answers 34d2 here.
00000000Zero bytes is a legitimate input rather than an error: the register simply starts at init, gets reflected if the model says so, and meets the final XOR. That is why nothing at all gives 00000000 under CRC-32, ffff under CRC-16/MODBUS and 00 under CRC-8/MAXIM-DOW.
68656c6c6f3610a686Read as hex these ten characters are the five bytes of the word hello, so CRC-32 answers 3610a686 — the value the command line below prints. Typing the same ten characters as text checksums ten bytes instead and lands nowhere near it.
Every example on this page is executed against the same engine that powers the tool, on every build.
Gotchas worth knowing
What a CRC is for
CRC detects accidental corruption — it is not a cryptographic hash and never a password or tamper-proofing tool.
Reflection changes the answer, not the polynomial
CRC-16/KERMIT and CRC-16/XMODEM both divide by 1021 from a zero register, but Kermit feeds bytes least-significant bit first and reflects the result: 2189 against XMODEM's 31c3 on the nine digits. Two switches, two protocols, one polynomial.
A final XOR can be the only difference
CRC-16/USB and CRC-16/MODBUS share width, polynomial, init and both reflections; USB inverts the register on the way out. On the nine digits that is b4c8 against 4b37 — worth checking before you conclude your bit order is wrong.
Polynomials get written in two directions
04c11db7 and edb88320 are the same CRC-32 polynomial, one normal and one bit-reversed, and datasheets pick either. Type the reversed spelling into the normal field and you get a working but different checksum — fc4f2be9 on the nine digits — so the readout always shows both bit orders of whatever you entered.
Odd widths and wide registers
Widths run from 3 to 64 bits. A width that is not a multiple of four still prints as whole hex digits, masked to the register, so a 5-bit result reads as two characters. Above 32 bits the input ceiling drops to 256 KB, announced before it computes.
Common errors
Polynomial is not valid hex: `g` at position 2 — use hex digits 0-9 and a-f only.- The field behind this one held 1g21, a mistyped 1021, and positions count from one. Every hex field here tolerates a 0x prefix, uppercase digits and surrounding spaces; a letter past f is the one thing it cannot guess at.
Init needs 17 bits but the width is 16 — trim it to 4 hex digits.- 1ffff has five hex digits, and a 16-bit register holds four. Usually it means the width was lowered after the starting value was pasted from a 32-bit model — the same check guards the final XOR field.
Width must be between 3 and 64 bits — `128` is out of range.- Under 3 bits no useful polynomial exists, and 64 bits covers every model this tool targets — CRC-64/XZ is the widest. Wider registers such as CRC-82/DARC exist in the RevEng catalogue.
Polynomial `8004` is even (bit 0 is clear) — named CRC polynomials are odd, and an even polynomial cannot detect every single-bit error.- This one is a warning, not a refusal: the checksum still computes. Every published polynomial has its low bit set, so an even value is nearly always a typo or a reversed spelling — 8004 for 8005, say.
FAQ
Which CRC-16 does Modbus RTU use?
CRC-16/MODBUS: 16 bits, polynomial 8005, starting register ffff, input and output both reflected, no final XOR. Its published check value is 4b37, so if this tool and your controller agree on the nine digits 123456789 they will agree on your frames.
Why do two libraries print different CRC-32 values for the same bytes?
Because CRC-32 names a family. CRC-32 and CRC-32/BZIP2 share polynomial 04c11db7, starting register and final XOR, and differ only in reflection — cbf43926 against fc891918 on the nine digits. Drop your value into the identify field and the matching row will tell you which set the other library used.
How do I know I typed a custom parameter set correctly?
Checksum the nine digits 123456789 and compare the result with the check value published for that model in the RevEng catalogue. It is a one-line test that catches a wrong bit order, a reversed polynomial or a stale starting register before you go near real data.
Keyboard shortcuts
- ⌘/Ctrl + Enter
- Recompute the checksum now.
- ⌘/Ctrl + S
- Download the result as a .txt file.
- ⌘/Ctrl + C
- With no selection, copy the hex result.
- ⌘/Ctrl + Shift + C
- Copy the hex result whatever is selected.
- t
- Flip between light and dark.
- ? or ⌘/Ctrl + /
- Show the shortcut overlay.
- Esc
- Close whatever is on top.