Base32 Encode and Decode Online
Encode text to Base32 or decode it back with the standard alphabet of A to Z and 2 to 7: «Hello, Base32!» becomes JBSWY3DPFQQEEYLTMUZTEII=. Accents and emoji are handled, and damaged input is refused rather than half decoded. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello, Base32!
- Calculation mode
- Encode
- Output
- JBSWY3DPFQQEEYLTMUZTEII=
This Base32 encoder and decoder converts ordinary Unicode text using the standard RFC 4648 alphabet of uppercase letters A through Z and digits 2 through 7. Select encode to turn UTF-8 text into portable Base32 with standard padding, or select decode to recover the original text. Decode mode validates the alphabet, padding, length, unused trailing bits, and UTF-8 result instead of silently producing damaged content.
How RFC 4648 Base32 represents text
Base32 is a binary-to-text encoding: it does not encrypt, compress, or hide information. In encode mode, the converter first represents the supplied string as UTF-8 bytes. It then reads those bytes as one continuous bit stream and divides the stream into groups of five bits.
Each five-bit value selects one symbol from the RFC 4648 alphabet, which contains the uppercase letters A through Z followed by the digits 2 through 7. Because five input bytes contain forty bits, they map exactly to eight Base32 symbols. When the final block is shorter, zero bits complete the last symbol and equals signs pad the result to an eight-character boundary.
That padding makes complete blocks easy for other implementations to recognize. The converter always emits the standard alphabet and canonical padding, so its output can be compared directly with RFC-compatible libraries in common programming languages. Unicode is handled before the bit conversion, which means accented letters, non-Latin scripts, and emoji have stable byte representations rather than being truncated to legacy character values.
Identical input and mode always produce identical output.
Decode validation and error behavior
Decode mode treats its input as RFC 4648 Base32 rather than as a loosely similar token. Letters may be uppercase or lowercase, but every data symbol must belong to A through Z or 2 through 7. An equals sign is accepted only as final padding, and its count must agree with the number of data symbols in the last block.
Lengths that cannot represent a whole number of bytes are rejected. The converter also checks unused trailing bits: RFC-compliant encoders set them to zero, while accepting nonzero bits could allow multiple spellings of the same byte sequence. After bytes are recovered, a strict UTF-8 decoder verifies that they form text, because this capability promises a string result rather than an arbitrary binary file.
Any invalid character, misplaced padding mark, impossible length, nonzero trailing bits, or malformed UTF-8 sequence returns an invalid-input error instead of partial output. Correct unpadded Base32 is also accepted when its final length is structurally valid.
Using the converter in tools and automated workflows
For a quick conversion, provide the text and choose encode or decode. Encode mode returns a padded Base32 string in the output field; decode mode returns the recovered Unicode string in that same field. Base32 is useful when a value must travel through systems that handle a limited character set, including provisioning records, human-readable setup material, case-insensitive stores, and text-only configuration.
It is commonly encountered around authenticator secrets, though encoding a secret does not protect it and access controls remain necessary. The algorithm uses no network, randomness, clock, account state, or external service, so it is suitable for repeatable builds and tests.
What you can do with it
Prepare interoperable configuration values
Encode Unicode text with the standard alphabet and padding before placing it in a text-only configuration or exchanging it with an RFC-compatible system.
Validate copied Base32 material
Decode a pasted value and receive a clear error when a symbol, padding mark, trailing bit, or resulting UTF-8 sequence is invalid.
FAQ
Which Base32 alphabet does this converter use?
It uses the standard RFC 4648 Base32 alphabet: uppercase A through Z and digits 2 through 7, with equals signs for output padding.
Does decode mode accept lowercase letters?
Yes. Lowercase letters are normalized to uppercase before decoding, while characters outside the RFC 4648 alphabet are rejected.
Is Base32 encryption?
No. Base32 is a reversible representation of bytes, not encryption or hashing. Anyone with the encoded value can decode it.
What happens if the Base32 text contains an invalid character?
You get a clear error instead of partial output. The same applies to padding in the wrong place, a length that cannot form whole bytes, nonzero leftover bits or a result that is not valid text.
Why does the result end with equals signs?
They are padding. Base32 works in blocks of eight symbols, because five bytes fill exactly eight of them; when the last block is shorter, equals signs fill it up, as in the example ending in EII=.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/base32-convert \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, Base32!","mode":"encode"}'const res = await fetch("https://api.kit.forhosting.com/web/base32-convert", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello, Base32!",
"mode": "encode"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/base32-convert",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello, Base32!",
"mode": "encode"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/base32-convert", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello, Base32!","mode":"encode"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello, Base32!","mode":"encode"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/base32-convert", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Hello, Base32!",
"mode": "encode"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.base32_convert",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
timeout_sec | 30 |
max_crawl_pages | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Using the converter in tools and automated workflows
Browser conversion is available for interactive work, while an API request is priced at $0.002 per item when the same deterministic operation is incorporated into an automated workflow.
Integration use cases
Create cross-language test vectors
Generate stable inputs and outputs for regression tests that compare Base32 implementations across browser, server, and command-line environments.
Technical questions
What happens when decode input contains an invalid character?
The request fails with an invalid-input error that identifies the offending character and its position; no partial decoded text is returned.
What does an API conversion cost?
Each successful API item uses the published base price of $0.002. Interactive browser conversion is available without an API request.