Encode and decode Base85 in seconds
Base85 encodings are a compact way to represent bytes as printable text. Compared to Base64, Base85 typically produces shorter output because it packs data more efficiently (85 symbols instead of 64).
You’ll encounter Base85 in:
- PostScript and PDF workflows (Ascii85 / Adobe)
- debugging and data transport
- message systems and libraries that use Z85 (ZeroMQ)
- places where you want a compact printable representation of bytes
This tool gives you a fast, browser-based way to encode or decode Base85 with two popular variants:
- Ascii85 (Adobe)
- Z85 (ZeroMQ)
It also supports practical “power-user” features like batch processing, trimming, wrapping, and Ascii85 delimiters.
What this Base85 tool can do
- Encode text → Ascii85 (Adobe)
- Decode Ascii85 → text
- Encode text → Z85 (ZeroMQ) (with required input rules)
- Decode Z85 → text
- Batch by newline (encode/decode many items at once)
- Trim lines in batch mode (optional)
- Wrap output at 76 characters (encode mode)
- Use or recognize Ascii85 <~ ~> delimiters
- Copy output with one click
Everything runs locally. No uploads.
How to use it
1. Choose your variant
Pick one:
- Ascii85 (Adobe) → the most flexible option for general use
- Z85 (ZeroMQ) → strict rules on encoding input length, common in ZeroMQ-related contexts
2. Choose Encode or Decode
- Encode: converts your text into Base85
- Decode: converts Base85 back into readable text
3. Use batch mode if you have lists
Turn on Batch by newline to treat each non-empty line as a separate item.
This is perfect when you have:
- many values to encode/decode
- exports from logs
- lists of tokens
- multiple Base85 strings to inspect
4. Use optional formatting (encode mode)
- Wrap @ 76: inserts line breaks every 76 characters
- Use <~ ~> (Ascii85 only): wraps output using Adobe delimiters
5. Copy the result
Click Copy on the output panel to copy everything.
Base85 vs Base64 (why Base85 exists)
Both Base64 and Base85 are reversible encodings, not encryption.
The main difference is efficiency:
- Base64 uses 64 characters → output is commonly ~33% larger than the raw bytes
- Base85 uses 85 characters → output is typically smaller than Base64 for the same input
That extra compactness can matter when you’re embedding data into text-heavy formats or sending data through channels where size matters.
Ascii85 (Adobe) explained
Ascii85 is the variant often seen in PostScript and PDF systems.
Notable behaviors:
- It encodes in 4-byte blocks and produces 5 characters per block.
- It supports optional delimiters:
<~at the start and~>at the end. - It supports a shorthand: a single
zrepresents four zero bytes (0x00000000), which makes sequences of zeros much shorter.
Delimiters: when to use <~ ~>
Some Adobe/PostScript workflows expect the encoded data to be wrapped like:
<~87cURD]i,"Ebo7~>If you’re using Base85 in those ecosystems, enabling Use <~ ~> helps ensure compatibility.
This tool can also decode Ascii85 whether the delimiters are present or not.
Z85 (ZeroMQ) explained
Z85 is a Base85 encoding standardized by the ZeroMQ project.
It uses a specific alphabet designed to be safe in many text contexts.
The important rule: input length must be divisible by 4 bytes
When encoding, Z85 requires the input byte length to be a multiple of 4.
That is why you may see:
- “Z85 encode requires input length divisible by 4 bytes”
If your text contains non-ASCII characters, the UTF‑8 byte length can change in ways that are not obvious by counting characters.
If you need a more flexible Base85 option, use Ascii85.
Wrap @ 76: what it’s for
Wrapping inserts a newline every 76 characters in the encoded output.
Use it when:
- you want long Base85 strings to be easier to read
- you’re pasting into systems that expect wrapped lines
- you want predictable line widths in logs or documentation
For most APIs and modern tooling, leaving wrapping off is typically best.
Practical use cases
PDF / PostScript work
- encoding data streams
- debugging embedded content
- working with Adobe-style Ascii85 blobs
ZeroMQ / Z85 workflows
- inspecting or generating Z85 strings
- decoding Z85 payloads
- converting between raw bytes and text-safe strings
Development and debugging
- quickly inspect an unknown Base85 string
- batch decode logs that contain Base85 chunks
- encode test vectors for documentation
Data transport in text-only systems
- embedding byte-like payloads into text formats
- sending compact encoded data through channels that dislike binary
Tips for reliable results
- Base85 is not encryption. Do not use it to “hide” data.
- Prefer Ascii85 if you want fewer restrictions and broad compatibility.
- Use Z85 when you specifically need Z85 output and can satisfy the 4-byte rule.
- If you hit errors in batch mode, remember each line is processed independently—valid lines will still work.
- If decoding produces “garbage” characters, the decoded bytes may not represent UTF‑8 text.
Troubleshooting
“Invalid Ascii85 character”
- The string contains characters outside the Ascii85 range.
- Remove surrounding quotes, stray punctuation, or accidental copy artifacts.
“Invalid Ascii85 length”
- Ascii85 groups data into blocks. A trailing partial block must still meet minimum requirements.
- Ensure the string is complete and not truncated.
“Z85 input length must be divisible by 5 characters” (decode)
- Z85 output comes in 5-character chunks.
- If the input isn’t a multiple of 5, it’s incomplete or contains extra characters.
“Z85 encode requires input length divisible by 4 bytes”
- Your UTF‑8 text isn’t a multiple of 4 bytes.
- Shorten/adjust the text, or use Ascii85 instead.
Perfect for
- developers working with Base85, Ascii85, or Z85
- PDF/PostScript debugging and inspection
- ZeroMQ payload workflows
- batch decoding lists of values
If you need a fast, private Base85 tool that supports both the Adobe and ZeroMQ variants, this is the simplest way to encode and decode Base85 in your browser.
