Z85 Encoder and Decoder (ZeroMQ)

How to encode and decode Z85

1. Paste the bytes as hex into Input · Hex. Spaces, colons and 0x prefixes are accepted, so a hex dump pastes as is.
2. Read the Z85 in Output · Z85 (ZeroMQ).
3. If the byte count is not a multiple of 4, you get an error that names the count. Tick Allow partial last block (non-standard) only if both sides agree on that extension.
4. To decode, click Z85 (ZeroMQ) → Hex in the direction toggle and paste the Z85 string. Set To to Base64 or Text for other views, or Save bytes for a binary file.

The spec test vectors

ZeroMQ’s Z85 specification (RFC 32 in the ZeroMQ RFC series) gives two test values. This tool reproduces both:

The first shows the block structure: 8 bytes, two blocks, ten characters. The second is a 32-byte key and its 40-character encoding, the size you see in CurveZMQ configuration.

Some edge values: four zero bytes are 00000, and four ff bytes are %nSc0. Z85 has no shortcut for zero blocks, so a run of zeros stays five characters per block.

Why ZeroMQ uses Z85

CurveZMQ keys are 32 random bytes. ZeroMQ needed a way to put them in configuration files, command lines and source code as plain strings. Z85 was designed for that:

• It is 25% larger than the raw bytes, against 33% for Base64, so a 32-byte key is 40 characters instead of 44.
• Its alphabet has no ", ', \ or backtick, so a key can go into a C, Python or shell string literal without escaping. It also avoids , and ;.
• Digits and letters come first (0-9 a-z A-Z), followed by 23 punctuation characters: .-:+=^!/*?&<>()[]{}@%$#.

It still contains <, > and &, so Z85 inside XML or HTML needs escaping. In JSON it needs none.

Z85 in Python

Z85 and Python’s b85encode share the arithmetic and differ only in the alphabet, so a character translation converts one into the other:

import base64

B85 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
Z85 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#"
TO_Z85 = str.maketrans(B85, Z85)
FROM_Z85 = str.maketrans(Z85, B85)

def z85encode(data: bytes) -> str:
    if len(data) % 4:
        raise ValueError("Z85 needs a multiple of 4 bytes")
    return base64.b85encode(data).decode().translate(TO_Z85)

def z85decode(text: str) -> bytes:
    return base64.b85decode(text.translate(FROM_Z85))

z85encode(bytes.fromhex("864FD26FB559F75B"))   # 'HelloWorld'

If you already depend on PyZMQ, zmq.utils.z85.encode and decode do the same. In C, libzmq has zmq_z85_encode and zmq_z85_decode. More Python byte handling is on the Python page.

Common problems

• “Z85 encodes 4-byte blocks and the data has N bytes”. The input is not block-aligned. Check that you copied the whole key; a 32-byte key that shows 31 bytes lost a pair of hex digits.
• “Z85 needs groups of 5 characters; N are left over”. The Z85 string was cut short or has extra characters. A CurveZMQ key must be exactly 40 characters.
• The string decodes but the key does not work. It may be Ascii85 or Git Base85, which share the length rules but not the alphabet, so the same characters decode to different bytes. Try it on the Base85 page with From set to another variant.

FAQ