Base32 Encode/Decode (Binary)

100% client-side processing (no server upload). Encode binary files (bytes) to Base32 text with selectable alphabets (RFC 4648/Base32hex/Crockford), padding control, optional line wrapping, and predictable output formatting.

Loading…

About Base32 Binary Encoder

This page focuses on encoding: upload one or more binary files and convert them into Base32 text. Choose the alphabet (RFC 4648, Base32hex, or Crockford), control padding, set letter case, and optionally wrap output lines. Need the opposite direction? Use the other page.

Features

Encodes binary files (File/Blob/Uint8Array/ArrayBuffer) into Base32 text
Choose Base32 dialect: RFC 4648 (Base32), RFC 4648 (Base32hex), or Crockford Base32
Control padding (=): Auto, Always include, or Omit
Letter case output: UPPERCASE or lowercase (encode mode)
Optional line wrapping: wrap lines at 0–120 columns (0 disables wrapping)
Output formatting helpers: line separator (LF or CRLF) and optional final newline
Multi-file dropzone workflow for batch encoding (client-side)
100% client-side processing (no server upload).

How to use for base32-binary-encoder

Paste or drop a file

Drop one or more files into the upload area (binary input). This encoder expects bytes (File/Blob/Uint8Array/ArrayBuffer), not a plain text string.

Click "Encode"

Keep Action set to "Encode file → Base32", pick the format (RFC 4648 / Base32hex / Crockford), and adjust padding, letter case, wrapping, and newline options as needed.

Copy/Download

Copy the Base32 output from the editor, or download/export the encoded results for your files (your tool UI may generate filenames like *.b32.txt).

Technical specifications

Execution Model

Runtime disclosure, constraints, and what the encoder accepts for this page variant (encode).

Aspect	Detail
Runtime	100% client-side processing (no server upload).
Variant scope	Encode only (File/bytes → Base32 text)
Input types	File/Blob/Uint8Array/ArrayBuffer/TypedArray (binary). Text strings are rejected for encode.
Output type	Text (Base32)
Formats	RFC 4648 (Base32), RFC 4648 (Base32hex), Crockford Base32
Formatting controls	Padding (auto/include/omit), letter case (upper/lower), wrapLineLength (0–120), line separator (LF/CRLF), insert final newline
Limits	~1–2MB chars; ~25000 ms timeout
Retention	All processing happens locally in your browser (no upload)

If you are handling secrets or regulated data, prefer offline/local tooling even though this page runs locally in the browser.

Mini Example

A minimal illustration of what the encoder produces. (Exact output depends on selected format, padding, case, and wrapping.)

Item	Value
Input	Binary file (bytes)
Action	Encode file → Base32
Output	Base32 text (RFC 4648 / Base32hex / Crockford)

For the same input bytes and the same options, the Base32 output is deterministic.

Errors & Edge Cases

What to expect when inputs or settings do not match the encode workflow.

Symptom	Likely cause	What to check
This tool encodes binary data… not a text string	You pasted text into a binary-only encode surface	Upload a file / provide bytes instead of typing text
Unsupported binary input type	Input is not File/Blob/Uint8Array/ArrayBuffer/TypedArray	Ensure the browser is providing a File/Blob or your code passes a byte buffer
Input too large (max 2MB)	The file/bytes exceed the in-tool processing guardrails	Try a smaller sample or split the file into chunks before encoding
Adapter call timed out	The encoding operation exceeded the ~25000 ms timeout	Reduce input size and disable expensive formatting like frequent wrapping if applicable
Unexpected output formatting	Wrapping/padding/case/newline options changed the textual presentation	Verify padding mode, wrapLineLength, separator (LF/CRLF), and final newline setting

Command line alternatives

For automation, reproducibility, or sensitive data workflows, prefer local execution in a terminal or CI environment.

macOS / Linux

Encode a file to Base32 (requires a base32 utility if available on your system)

base32 < input.bin > output.b32.txt

Uses a local Base32 encoder if your platform provides the base32 command (commonly from GNU coreutils). Behavior (padding/wrapping) depends on the implementation.

Windows (PowerShell)

Use a local language/runtime library (recommended) for Base32 encoding

python -c "import base64,sys; data=open('input.bin','rb').read(); print(base64.b32encode(data).decode('ascii'))"

Python’s standard library supports Base32 encoding. Adjust formatting (wrapping/newlines/case) in your script to match your desired output.

Use cases

Share binary data as plain text

Encode small binary blobs so they can be pasted into tickets, chats, or text-based systems
Generate a Base32 representation for systems that restrict input to A–Z/2–7 (RFC 4648)

Interoperability testing across Base32 dialects

Compare RFC 4648 vs Base32hex vs Crockford outputs for the same file
Standardize padding and case rules so teammates get identical results

CI-friendly fixtures and golden outputs

Produce deterministic Base32 fixtures for unit tests
Pin wrapping and newline behavior to avoid diffs across platforms

Performance and size sanity checks

Quickly estimate Base32 expansion for a small file sample
Validate that line wrapping and separators match downstream parser expectations

❓ Frequently Asked Questions

Is there a public API for this encoder?

No. This page is designed for interactive use in the browser and does not expose a public API endpoint.

Is processing local or remote?

100% client-side processing (no server upload). All encoding happens locally in your browser.

Can I encode secrets safely here?

This tool runs locally in your browser, but you should still avoid pasting or uploading highly sensitive secrets into any online page if your environment is not trusted. For sensitive workflows, use a local CLI or offline script.

Why do I get an error saying the tool expects binary data?

This encoder page is for files/bytes. If you paste a text string, it will reject it. Upload a file (or provide bytes) instead of typing text.

Why does my output look different (case, padding, line breaks) than another tool?

Base32 text presentation depends on options and dialect. Check the selected format (RFC 4648/Base32hex/Crockford), padding mode, letter case, wrap length, separator (LF vs CRLF), and whether a final newline is appended.

Pro Tips

CI Tip

If you need stable diffs in PRs or CI, pin formatting: choose a single dialect, fix padding mode, set wrapLineLength explicitly, and decide whether to append a final newline.

Best Practice

For maximum compatibility with strict consumers, prefer RFC 4648 with padding "Auto" or "Always include =" and keep output UPPERCASE.