Technology calculators

CRC Calculator

Updated Sep 1, 2026 By Infinity Calculator
Rate Formulas
Data Input
Input Format
ASCII mode: every character (including spaces) is treated as its byte value. The default 123456789 is the universal CRC check vector.
Processed Bytes
Bytes processed: 0
Algorithm Configuration
CRC Width
Polynomial
Calculate
CRC Result — CRC-32
Hexadecimal
Decimal
Octal
Binary
Canonical check value (CRC of 123456789):
Algorithm Results
Output base (Result, Check, Poly, Init, XorOut)
Step-by-Step Solution
Processed Byte Values

Introduction

A CRC, or cyclic redundancy check, is a short code added to data so you can tell if it changed during transfer. Think of it like a seal on a letter. If the seal is broken, you know something went wrong. Computers use CRCs every day when they send files, load web pages, or save data to a disk.

This free CRC calculator lets you compute CRC values for any data you enter. It supports many standard algorithms, including CRC-8, CRC-16, CRC-32, and CRC-64. You can type in ASCII text, hex bytes, decimal bytes, or a binary string. The tool then shows your result in hex, decimal, octal, and binary all at once.

Beyond a simple result, the calculator gives you a full step-by-step breakdown of how the CRC is computed. It also builds a 256-entry lookup table and generates ready-to-use source code in nine programming languages, such as C, Python, Java, JavaScript, and Rust. You can compare results across all built-in algorithms with one click using the "Run All Algorithms" button.

This CRC calculator gives you the answers you need fast and with full detail.

How to Use Our CRC Calculator

Enter your data and pick a CRC algorithm. The calculator will give you the CRC checksum in hex, decimal, octal, and binary. It also shows a step-by-step solution, a lookup table, and ready-to-use code.

Input Format: Choose how your data is typed in. Pick ASCII / String for plain text, HEX Bytes for hex values like FF A0 3C, Decimal Bytes for numbers from 0 to 255, or Binary String for strings of 0s and 1s.

Data to Compute CRC Over: Type or paste the data you want to check. The default value 123456789 is the standard test string used to verify CRC results.

CRC Width: Select the bit size of the CRC you need. Common choices are CRC-8, CRC-16, CRC-32, and CRC-64. Pick Custom to set your own bit width.

Search Algorithm: Type part of an algorithm name to filter the preset list. This helps you find a specific standard fast, such as MODBUS or CCITT.

Algorithm / Preset: Pick a known CRC standard from the dropdown. This fills in the polynomial, initial value, and all other settings for you automatically.

CRC Bits: Shows the bit width of the selected algorithm. You can edit this field only when Custom mode is active.

Data Bit Width: Set this to 8-bit for normal byte data. Use 7-bit only for special protocols that send 7-bit characters.

Poly Notation: Choose how the polynomial value is displayed. Normal is the most common. Reversed and Koopman are alternate forms used in some references.

Polynomial (hex): The generator polynomial in hex. This is set by the preset. In Custom mode, you can type your own value.

Initial Value (hex): The starting value of the CRC register. Many algorithms use 00000000 or FFFFFFFF. Check the Preset Init to all ones box to fill it with all 1s quickly.

Final XOR (hex): A value XORed with the result at the end. Check Post-invert to set it to all 1s.

Input Reflected (RefIn): Check this if the algorithm reverses the bits of each input byte before processing.

Output Reflected (RefOut): Check this if the algorithm reverses all bits of the final CRC register before the XOR step.

Quick Buttons: Click CRC-8, CRC-16, CRC-32, or CRC-64 to load a popular preset and calculate the result in one step.

Calculate CRC: Press this button to compute the CRC for your data using the selected algorithm.

Run All Algorithms: Press this to compute every CRC algorithm at once and compare results side by side in the table below.

Reset: Press this to clear all settings and return the calculator to its default state.

What Is a CRC (Cyclic Redundancy Check)?

A CRC, or Cyclic Redundancy Check, is a short code added to data to help detect errors. When data moves from one place to another, like downloading a file, sending a message, or saving to a disk, bits can get flipped or lost along the way. A CRC catches those mistakes.

Here is how it works. The sender takes a block of data and runs it through a math formula called a polynomial division. The leftover value from that division is the CRC. This small value is then sent along with the data. When the receiver gets the data, it runs the same math on it. If the CRC it calculates matches the one that was sent, the data is most likely correct. If the values do not match, the data was changed or corrupted during transfer.

Common CRC Types

CRCs come in different sizes. CRC-8 produces an 8-bit check value and is used in small devices and sensors. CRC-16 is common in serial communication protocols like Modbus and USB. CRC-32 is one of the most widely used types and protects files in ZIP archives, Ethernet frames, and PNG images. CRC-64 is used when even stronger error detection is needed, such as in large data storage systems like RAID arrays.

Key CRC Parameters

Each CRC algorithm is defined by a set of parameters. The polynomial is the core math value used in the division. The initial value (init) is what the register starts at before processing begins. RefIn and RefOut control whether the input bytes and the final result are bit-reversed. The final XOR value is applied to the result at the very end. Changing any of these parameters gives a different CRC output, even with the same input data.

Why CRC Matters

CRC is not encryption. It does not hide data or protect against intentional tampering. Its job is to catch accidental errors: a flipped bit during a network transfer, a scratch on a disk, or noise on a wire. It is fast, simple, and reliable, which is why nearly every data transfer protocol uses some form of CRC. From Wi-Fi and Bluetooth to hard drives and barcode scanners, CRC quietly keeps our data accurate every day.


Formulas used

CRC register update per input bit
\text{reg} \leftarrow \begin{cases} (\text{reg} \ll 1) \oplus P & \text{if } \text{msb}(\text{reg}) \oplus m_i = 1 \\ \text{reg} \ll 1 & \text{otherwise} \end{cases}
Final CRC result
\text{CRC} = \bigl(\text{reg}_{\text{final}} \oplus \text{XorOut}\bigr) \;\mathbin{\&}\; (2^{W} - 1)
Bit reflection (reversal of W bits)
\text{reflect}(v,\,W) = \sum_{i=0}^{W-1} \left(\left\lfloor \frac{v}{2^{i}} \right\rfloor \bmod 2\right) \cdot 2^{\,W-1-i}
Table-driven CRC step (reflected / LSB-first)
\text{crc} \leftarrow (\text{crc} \gg 8) \oplus T\!\left[(\text{crc} \oplus b_k) \;\mathbin{\&}\; \mathtt{0xFF}\right]
Table-driven CRC step (normal / MSB-first)
\text{crc} \leftarrow (\text{crc} \ll 8) \oplus T\!\left[\left((\text{crc} \gg (W-8)) \oplus b_k\right) \;\mathbin{\&}\; \mathtt{0xFF}\right]

Frequently asked questions

What is the default test string 123456789 and why is it used?

The string 123456789 is the universal CRC check vector. Every CRC standard publishes a known result for this exact input. When you run the calculator with this string, you can compare your output to the published check value shown below the result. If they match, the algorithm is set up correctly. It is a quick way to verify that settings like the polynomial, initial value, and reflections are all right.

What is the difference between RefIn and RefOut?

RefIn reverses the bits of each input byte before it enters the CRC register. RefOut reverses all the bits of the final CRC register before the final XOR is applied. Some algorithms use both, some use neither. These settings must match the standard you are following, or your result will be wrong. When you pick a preset algorithm, the calculator sets both values for you.

What is the difference between Normal, Reversed, and Koopman polynomial notation?

Normal is the most common form. It drops the leading 1 bit and shows the rest. For example, CRC-32 uses 0x04C11DB7. Reversed flips the bit order, which matches how LSB-first shift registers work. The same CRC-32 polynomial becomes 0xEDB88320. Koopman keeps the leading 1 but drops the trailing 1. All three describe the same polynomial. They just write it differently. The calculator converts between them when you switch the dropdown.

Can I create a custom CRC algorithm?

Yes. Click the Custom button under CRC Width, or choose Custom (manual entry) from the algorithm dropdown. This unlocks all fields so you can type your own bit width, polynomial, initial value, final XOR, and reflection settings. You can set any width from 1 to 64 bits.

What does the Final XOR value do?

After the CRC register finishes processing all input bytes and any output reflection is applied, the final XOR value is XORed with the result. For example, CRC-32 uses a final XOR of 0xFFFFFFFF, which flips every bit of the output. Some algorithms use 0x00000000, which leaves the result unchanged. This step is the last thing that happens before you get your CRC value.

What programming languages does the code generator support?

The calculator generates ready-to-use CRC code in nine languages: C, C++, Arduino, Python, Rust, Java, JavaScript / TypeScript, C#, and PHP. The code includes the lookup table and a compute function. You can copy it with one click and paste it into your project.

Why does my CRC result not match what I expected?

CRC results depend on every parameter being exactly right. Check these things: the polynomial must match your standard, the initial value must be correct, RefIn and RefOut must be set properly, and the final XOR must be accurate. Also make sure your input format is correct. A hex input read as ASCII will give a different result. Use the check value for 123456789 to verify your settings against the published standard.

What is the difference between CRC-16 and CRC-32?

The number refers to the bit width of the output. CRC-16 produces a 16-bit value (up to 4 hex digits), and CRC-32 produces a 32-bit value (up to 8 hex digits). A wider CRC can detect more types of errors and is better for larger blocks of data. CRC-32 is the most common choice for files and network frames. CRC-16 is often used in simpler serial protocols where speed and small size matter more.

Is CRC the same as a hash like MD5 or SHA?

No. CRC and cryptographic hashes both turn data into a short value, but they serve different purposes. CRC is designed to catch accidental errors quickly. It is fast but not secure. Hashes like MD5 and SHA are designed to make it very hard to find two inputs with the same output. CRC should never be used for security, passwords, or detecting intentional tampering.