Skip to main content

Free Base32 Encoder & Decoder Online

Base32 Encoder / Decoder encodes and decodes Base32 strings online for free. Supports RFC 4648 with the A-Z2-7 alphabet, plus base32hex and Crockford variants, with instant conversion in your browser.

Written & reviewed by Helperzy Editorial Team · Updated July 2026

The classic Base32 alphabet used by most systems.

Plain Text

Base32 Output

RFC 4648 Self-Check

ALL PASS
"" → "" PASS
"f" → "MY======" PASS
"fo" → "MZXQ====" PASS
"foo" → "MZXW6===" PASS
"foob" → "MZXW6YQ=" PASS
"fooba" → "MZXW6YTB" PASS
"foobar" → "MZXW6YTBOI======" PASS

100% Private

All encoding and decoding runs locally in your browser. Nothing is uploaded.

How to Use Base32 Encoder / Decoder

1

Enter Your Text or String

Paste the text you want to encode into the input area, or paste an existing Base32 string that you want to decode back into its original readable bytes.

2

Choose Encode or Decode and Variant

Select whether to encode or decode and pick the alphabet you need, such as standard RFC 4648, base32hex, or Crockford, so the result matches the system you are exchanging data with.

3

Copy the Result

Read the converted output complete with any required padding, then copy the finished string to your clipboard with one click to paste it directly into your own project or configuration.

What Is Base32 Encoding and How It Works

Base32 is a way of writing binary data using a small, unambiguous set of printable characters. The standard defined in RFC 4648 uses the twenty-six uppercase letters A through Z followed by the digits two through seven, giving exactly thirty-two symbols, with the equals sign used as padding at the end. This encoder and decoder moves text between raw bytes and that alphabet in both directions. Base32 is less compact than Base64, so why use it at all? Its alphabet avoids characters that are easy to confuse or that cause trouble in case-insensitive systems, which makes it the format of choice for things like time-based one-time password secrets, some DNS and filename schemes, and any context where a human might have to read or type the value aloud without errors. The mechanics come down to regrouping bits into fives. Base64 slices data into six-bit chunks because sixty-four is two to the sixth; Base32 slices into five-bit chunks because thirty-two is two to the fifth. Each five-bit group is a number from zero to thirty-one that indexes the alphabet and becomes one output character. The neat consequence is that five input bytes, which is forty bits, divide evenly into exactly eight output characters, so a full block is five bytes in and eight characters out. When the input does not fill a complete five-byte block, the remaining bits are zero-padded up to the next five-bit boundary and then equals signs are appended so the total length becomes a multiple of eight. That padding tells a decoder how many real bytes to reconstruct, and it is why encoded strings so often end in a run of equals characters. A concrete example makes the padding rules stop feeling mysterious. Encode the six-byte word foobar. Six bytes is forty-eight bits, which is one full five-byte block plus one extra byte. The full block yields eight characters, and the leftover byte is padded out and produces a partial block, so the finished output is MZXW6YTBOI followed by six equals signs, written as MZXW6YTBOI======. Now encode just the three-byte word foo. Three bytes is twenty-four bits, which fills five characters worth of five-bit groups with some bits left over, so the result is MZXW6 followed by three equals signs, written as MZXW6===. Paste either string into the decoder and you recover the original bytes exactly. Deleting the trailing equals signs will make a strict decoder reject the string, because the length no longer lands on an eight-character boundary. Several situations bring Base32 into everyday work. A developer building or debugging two-factor authentication pastes a shared secret to confirm it decodes to the expected bytes before feeding it to an authenticator, since these secrets are conventionally exchanged in Base32. An engineer inspecting a system that stores identifiers in a case-insensitive filesystem uses Base32 so the same value cannot collide just because of letter case. A support technician handed a value over the phone can read Base32 aloud with far fewer mistakes than Base64, because it avoids the plus and slash symbols and mixed case entirely. A tester constructing fixtures encodes a small binary blob into a stable, portable string that survives copy and paste through chat and ticket systems without mangling. A few notes keep results correct. The standard RFC 4648 alphabet is not the only one: base32hex uses the digits zero through nine then the letters A through V, chosen so the encoding preserves sort order, while Crockford Base32 drops easily confused characters and adds a checksum option, so make sure you pick the variant that matches the system you are talking to or the decode will produce garbage. Treat Base32 as a transport encoding and never as a security measure, because anyone can decode it without a key, exactly as with Base64. Expect the output to be larger than the input, roughly sixty percent bigger, since eight characters carry five bytes. Everything here runs in your browser, nothing is uploaded, so even a real one-time password secret stays on your own device.

Base32 Encoder / Decoder Formula & Method

group bits into 5-bit chunks (2^5 = 32); each chunk indexes A-Z2-7; 5 bytes (40 bits) -> 8 chars; zero-pad and append '=' to reach a multiple of 8

Examples: Base32 Encoder / Decoder

Input

Encode the plain text: foobar

Result

MZXW6YTBOI======

Six bytes form one full five-byte block plus a leftover byte, producing eight characters then padding to a multiple of eight.

Input

Encode the plain text: foo

Result

MZXW6===

Three bytes are twenty-four bits, giving five characters plus three equals-sign padding marks to reach eight.

Frequently Asked Questions – Base32 Encoder / Decoder

Paste your text into the encoder and click Encode to get a Base32 string using the RFC 4648 alphabet of A to Z and the digits two to seven. The result appears instantly and includes any equals-sign padding needed to reach a full block. Everything runs in your browser with no signup, so you can encode as much as you like.