CRC Calculator Online — CRC-8, CRC-16, CRC-32 & Modbus

How the CRC Calculator works

The CRC calculator generates cyclic redundancy check values for text or hexadecimal data using ten standard CRC algorithms — CRC-8, CRC-8/MAXIM, CRC-16/IBM, CRC-16/CCITT, CRC-16/MODBUS, CRC-16/X-25, CRC-16/DNP, CRC-32, CRC-32C, and CRC-32/BZIP2. Results are shown simultaneously in hexadecimal, decimal, and binary. The “All Algorithms” mode calculates every variant in one click — useful when you have an unknown CRC and need to identify which algorithm produced it.

How CRC polynomial division works

CRC treats the input data as a large binary polynomial and divides it by a generator polynomial using modulo-2 arithmetic (XOR with no carries). The remainder from this division is the CRC value. A CRC-16 remainder is 16 bits wide; CRC-32 produces a 32-bit remainder. At the receiver, the same division is performed — a zero remainder (or a fixed “residue” for some algorithms) confirms the data arrived without errors.

Algorithm comparison — all supported variants

CRC in Modbus RTU

Modbus RTU uses a 16-bit CRC appended to every frame. The Modbus CRC-16 starts with an initial value of 0xFFFF, uses polynomial 0x8005 in reflected (LSB-first) form, and XORs with 0x0000 at the end. The two CRC bytes are written low byte first, then high byte. The calculator's CRC-16/MODBUS preset produces the correct bytes in the right order for direct frame insertion.

Error detection capability

CRC-32 detects all single and double-bit errors, all odd-number bit errors, all burst errors up to 32 bits, and the vast majority of longer burst errors. The probability of an undetected random error is 1 − 2⁻³² ≈ 99.9999998%. CRC is appropriate for communication error detection but is not a cryptographic hash — it should not be used for security purposes. For integrity verification against intentional tampering, use SHA-256 or HMAC.

Code examples — CRC-32 and Modbus CRC-16

Python

def crc32(data: bytes) -> int:
    """CRC-32 — used in Ethernet, ZIP, PNG (poly 0x04C11DB7 reflected)"""
    crc = 0xFFFFFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1))
    return crc ^ 0xFFFFFFFF

def modbus_crc16(data: bytes) -> int:
    """Modbus CRC-16 — poly 0x8005 reflected, init 0xFFFF"""
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ (0xA001 & -(crc & 1))
    return crc

# Usage
data = b"Hello, World!"
print(f"CRC-32:        0x{crc32(data):08X}")
print(f"Modbus CRC-16: 0x{modbus_crc16(data):04X}")
# Append to Modbus frame: low byte first, then high byte
crc = modbus_crc16(data)
frame = data + bytes([crc & 0xFF, (crc >> 8) & 0xFF])

C

#include <stdint.h>
#include <stddef.h>

/* CRC-32 (Ethernet, ZIP, PNG) */
uint32_t crc32(const uint8_t *data, size_t len) {
    uint32_t crc = 0xFFFFFFFF;
    while (len--) {
        crc ^= *data++;
        for (int i = 0; i < 8; i++)
            crc = (crc >> 1) ^ (0xEDB88320 & -(crc & 1));
    }
    return crc ^ 0xFFFFFFFF;
}

/* Modbus CRC-16 — append as {lo, hi} to every RTU frame */
uint16_t modbus_crc16(const uint8_t *data, size_t len) {
    uint16_t crc = 0xFFFF;
    while (len--) {
        crc ^= *data++;
        for (int i = 0; i < 8; i++)
            crc = (crc >> 1) ^ (0xA001 & -(crc & 1));
    }
    return crc;
}