How this instrument works
A parity bit is one extra bit added to a block of data, chosen so that the total count of 1-bits — data plus that extra bit together — follows a fixed rule: under the even convention the total must always come out even, and under the odd convention it must always come out odd. Computing it is simple arithmetic regardless of how many data bits there are — count how many bits equal 1, then apply the chosen rule: the even-parity value is that count modulo 2, and the odd-parity value is 1 minus that same figure.
This instrument accepts a data-bit sequence of any length, unlike this site's other fixed-width tools, which work with a fixed 8-bit byte — the general Parity instrument computes both conventions together for exactly 8 bits, and the dedicated Even Parity and Odd Parity calculators each handle one convention, also fixed at 8 bits. This one lets you enter any number of bits and choose the convention yourself, useful for block sizes other than a standard byte, such as a 4-bit nibble, a 7-bit ASCII character (a common real-world use case for this kind of check), or a longer custom data block.
Parity checking has been used since the earliest days of digital communication and storage — old RS-232 serial links and many early RAM modules used exactly this kind of bit, appended cheaply for the cost of just one extra bit per data word, to catch single-bit corruption. It's worth being clear about its limits, though: a parity bit only ever detects an odd number of flipped bits and cannot correct anything — it just flags that something's wrong. This site's Hamming Code instrument covers a scheme that can actually correct, not just detect, a single-bit error, using multiple overlapping parity bits instead of just one.
Real-world protocols almost always fix the parity convention to one specific data-word length, most often 7-bit or 8-bit characters — this instrument's arbitrary-length flexibility is meant for learning and experimenting across different block sizes, rather than mimicking any one specific wire protocol's fixed framing.
- Enter Data bits (0s and 1s, any length) — type your bit sequence, for example 1,0,1,1,0,1,0,1.
- Select Parity type — Even or Odd.
- Read Number of 1-bits in the data for the raw count of set bits.
- Read Parity bit to append — the single bit that completes the chosen parity convention for that data.
- Switch Parity type without changing the data to see how the same bits produce the opposite parity bit under the other convention.
Worked example — an 8-bit byte, even parity
Enter the data bits 1, 0, 1, 1, 0, 1, 0, 1 with Parity type set to Even. Number of 1-bits in the data reads 5 — this byte, 10110101, has five bits set to 1, an odd count. Parity bit to append reads 1, since 5 mod 2 = 1, and adding that 1 to the total brings the combined 1-count (data plus the new bit) to 6, an even number, satisfying the even-parity rule.
This exact example, a byte with an odd count of 1-bits under the even convention, mirrors the standard textbook illustration of the parity-bit formula: whenever the raw data's 1-count is odd, the even-parity bit is always 1; whenever it's already even, the even-parity bit is always 0 — the same 'sum mod 2' logic applies identically regardless of whether the data block is this 8-bit example or a completely different length.
Questions
How do you calculate a parity bit for a bit string?
Count how many of the data bits equal 1, then apply the chosen convention: for even parity, take that count modulo 2 (0 if the count is already even, 1 if it's odd); for odd parity, take 1 minus that same value. Appending the resulting bit to the data always brings the total 1-count, data plus parity together, in line with whichever convention was chosen — even or odd.
What's the difference between this and the site's fixed 8-bit parity calculators?
This instrument accepts a data-bit sequence of any length you type in, along with a choice of even or odd parity. The site's other fixed-width tools — the combined Parity calculator and the dedicated Even Parity and Odd Parity calculators — all work with a fixed 8-bit byte using individual bit toggles instead. Use this one when your data block isn't exactly 8 bits, or when you want to type a sequence directly rather than toggle individual switches.
Can a parity bit correct an error, or only detect one?
Only detect — a single parity bit can tell a receiver that an error probably happened, but it can't say which bit is wrong or fix it. For a scheme that can actually correct a single-bit error, not just flag it, see this site's Hamming Code instrument, which uses three overlapping parity bits instead of one, letting a receiver pinpoint and reverse the exact bit that flipped.
Does parity work the same way for data lengths other than 8 bits?
Yes — the underlying math, counting 1-bits and taking that count modulo 2, doesn't depend on the data length at all. It works identically whether the data block is 4 bits, 7 bits, 8 bits, or considerably longer; the only thing that changes with length is how many bits there are to count, not the formula used to compute the parity bit itself.
What happens if two bits flip instead of one?
Parity misses it entirely. A single parity bit reliably catches any odd number of flipped bits, since an odd number of flips always changes whether the total 1-count is even or odd. An even number of flips (two, four, and so on) cancels out, leaving the total's evenness or oddness exactly as it was before the corruption — so the check passes even though the data itself is no longer correct, which is the fundamental limitation of any single-parity-bit scheme.