What's the difference between packed and unpacked BCD?

Unpacked BCD stores one decimal digit per byte (high nibble = 0). Packed BCD stores two digits per byte (one in each nibble), halving storage. Most RTC chips and financial calculators use packed BCD.

Why use BCD instead of plain binary?

BCD avoids the binary-to-decimal rounding errors of floating point and makes display drivers (7-segment, LCD) trivial since each nibble is one digit. It's still common in embedded systems, RTCs, and POS terminals.

Is the conversion local?

Yes. Everything runs in your browser.

BCD Â· to packed Â· live

Convert decimal to Binary-Coded Decimal

Pack each decimal digit into a 4-bit nibble â€” the format real-time clocks, calculators, and POS terminals use for exact, drift-free decimal math.

BCD Converter

Input

8 B

1 lines

Output

35 B

1 lines

Status

ready

live

Ratio

4.38×

out/in

input · decimal digits

output · bcd binary

00100000 00100110 00000101 00100001

Quick Start

How to convert BCD

Every decimal digit (0-9) maps to a 4-bit pattern. Packed BCD fits two digits in a byte; unpacked uses one nibble per digit.

01
Pick conversion
Packed for compact storage, unpacked for nibble-aligned hardware.
Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.
modeUTF-8TextEncoderlosslesslive
mode · raw bytesto-packed · UTF-8
```
packed Â· unpacked Â· reverse
```
loaded · UTF-8MIME · ready
02
Type digits
Decimal digits only â€” letters or signs throw a clear error.
Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.
digitsWeb Cryptosubtledeterministiclive
input · optionsdec · live
```
20260521
```
options applied · livelive
03
Read nibbles
Spaces between bytes make scanning easier â€” drop them for raw memory layout.
Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.
binarymemoisedoptionsinstantreactive
out · encodedbin · ready
```
0010 0000 0010 0110
```
encoded · livelossless
04
Copy or download
Paste into firmware tables, RTC init code, or test fixtures.
Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.
exportclipboardblobMIME-correctclient-side
âœ“ · copiedready · done
```
âœ“ Copied
```
shipped · ready to shipsuccess

Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When to use BCD

Embedded clocks, point-of-sale, exact decimal arithmetic.

Real-time clocks

DS1307, PCF8563 etc. store seconds/minutes as packed BCD. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Calculators

Hardware decimal math avoids float rounding. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Point-of-sale

Currency totals stay exact across additions. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Z80 / 6502 retro code

DAA instruction operates on packed BCD nibbles. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Smart card files

ISO 7816 dates and PINs encode in BCD. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Mainframe COBOL

PIC 9(n) COMP-3 fields are packed-decimal BCD. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready

FAQ

Frequently asked questions

Packed vs unpacked?

Packed stores two digits per byte (e.g. 0x42 = decimal 42). Unpacked uses one byte per digit, wasting the high nibble for easier code.

Can BCD store negatives?

Not in this tool. Real systems use sign nibbles (0xC, 0xD, 0xF) on the trailing position â€” apply that after conversion.

Why use BCD instead of int?

Decimal fractions (0.1 + 0.2) round exactly in BCD. Binary floats can't represent them â€” a problem for money and timekeeping.

What about hexadecimal digits A-F?

BCD only allows 0-9 in each nibble. Decoder rejects 1010-1111 patterns to catch corruption.

Is anything sent to a server?

No â€” the BCD conversion runs locally in your browser.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!