basE91 encoder
basE91 packs text into 91 printable characters, denser than Base64 and with no padding: “Hello, world!” becomes >OwJh>}A"=r@@Y?F with Joachim Henke's original alphabet, and any basE91 string decodes back to UTF-8 text. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello, world!
- Result
- >OwJh>}A"=r@@Y?F
- Calculation mode
- Encode
- Variant
- base91
- Bytes
- 13
Encoding is deterministic UTF-8 then bit-queue basE91 arithmetic; decoding strips whitespace, maps each symbol through the reverse table, and rejects illegal symbols instead of inventing silent replacements.
Encode UTF-8 text to basE91
The engine interprets the string as Unicode text, serializes it to UTF-8 bytes, then feeds those bytes into Joachim Henke’s basE91 bit queue: each input byte contributes eight bits, and whenever more than thirteen bits are buffered the encoder emits a two-character pair drawn from the ninety-one-symbol alphabet. When the thirteen-bit window value is at most eighty-eight, the algorithm instead consumes fourteen bits before emitting the pair, which is the variable-width trick that makes basE91 denser than a fixed Base64 expansion.
A final partial queue is flushed as one or two remaining symbols so the decode side can recover the exact byte length without padding characters like equals signs. Empty strings are valid and encode to an empty result with zero bytes. Multilingual text, emoji, and punctuation all round-trip because the path is full UTF-8, not a Latin-1 shortcut.
Identical inputs always produce identical outputs because the algorithm is pure arithmetic with no network, no random salt, and no wall clock. Use this path whenever you need a denser text-safe representation than Base64 for short configuration fragments, documentation samples, or legacy basE91 channels.
Decode basE91 back to text and handle invalid characters
Set mode to decode and put a basE91 string in text. Leading, trailing, and internal whitespace—including spaces, tabs, and newlines—is stripped so multi-line pastes still work. The alphabet is strict: only the ninety-one symbols defined by Joachim Henke (uppercase and lowercase letters, digits, and a fixed set of printable punctuation that excludes space, hyphen, single quote, and backslash) are accepted.
The decoder rebuilds the bit queue by pairing symbols: the first of each pair is the low digit modulo ninety-one and the second scales by ninety-one; thirteen or fourteen bits are released per pair depending on the same eighty-eight threshold used on encode, then whole bytes are emitted until fewer than eight bits remain. A final unpaired symbol is treated as a short flush of the remaining queue. Successful decode returns result as the recovered string, mode decode, variant base91, and bytes as the decoded UTF-8 length.
Prefer this capability when your search intent is literally base91 encoder, basE91 decoder, or base91 convert for human-readable content; Base64, Base58, and Ascii85 remain separate tools with their own landings.
FAQ
How do I encode text to basE91?
The response result field holds the basE91 string and bytes is the UTF-8 length.
How do I decode basE91 back to text?
Set mode to decode and put the basE91 string in text. Whitespace is stripped. The result field is the recovered UTF-8 text.
What happens on an invalid basE91 character?
Characters outside the ninety-one-symbol basE91 alphabet are rejected; validation failures are not charged.
Is the basE91 encoder free?
The browser tool runs free on your device.
How is basE91 different from Base64?
basE91 uses a 91-symbol alphabet and a 13/14-bit variable-width queue, typically about 23% overhead versus roughly 33% for Base64. This tool implements Joachim Henke basE91, not RFC 4648 Base64.
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/enc/base91 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, world!"}'const res = await fetch("https://api.kit.forhosting.com/enc/base91", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello, world!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base91",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello, world!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base91", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello, world!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello, world!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base91", 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, world!"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base91",
"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.
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
basE91 is a compact binary-to-text scheme that packs data into ninety-one printable ASCII characters, typically denser than Base64 and useful whenever you need a shorter text-safe payload without leaving the classic printable range. People search for a base91 encoder or basE91 decoder when they store short binary tokens in JSON, tickets, or chat, compare encoding overhead against Base64, or restore a basE91 string that another tool produced with Joachim Henke’s original alphabet. This capability focuses on that everyday job: choose mode encode or decode, send a text field, and receive the transformed string plus byte length, or a clear invalid_input error when a decode payload contains a character outside the basE91 alphabet.
Encode UTF-8 text to basE91
Send a JSON body with the required string field text set to the plain message you want to represent in basE91, and leave mode at its default encode or set mode to encode explicitly. Optional aliases input, value, and s are accepted for the same field when you generate clients from older form names. The response always includes result with the basE91 string, mode equal to encode, variant equal to base91, and bytes equal to the UTF-8 length before encoding so you can assert payload size in tests.
Decode basE91 back to text and handle invalid characters
Any other character—including Base64 padding equals signs, URL-safe hyphen or underscore used alone as foreign alphabets, or binary noise—causes an immediate invalid_input failure with a message that names the invalid basE91 character condition, so clients can fix the paste instead of receiving corrupted Unicode. After alphabet validation, the recovered bytes are decoded as UTF-8 with a fatal decoder: if the payload is not valid Unicode text, you get invalid_input instead of replacement characters that would corrupt downstream displays. Validation failures are not charged on the prepaid API, so probing a suspicious token is cheap for operators and safe for end users.
API usage, pricing, workflows, and practical limits
Call the free in-browser basE91 encoder for classroom demos, support playbooks, token checks, and one-off conversions without installing native packages or scripting a custom bit-queue yourself. A typical workflow encodes a short configuration value for storage in a text-only ticket, ships it through email or chat, then decodes it on the receiving service with mode decode and asserts that bytes match the original length. Authors shipping SDKs can map the result field straight into a copy button, while mode and variant labels make OpenAPI examples self-explanatory for readers who only know the ninety-one-symbol alphabet and the thirteen-or-fourteen-bit variable queue. Use the prepaid KIT API when a backend, serverless function, or SDK needs the same encode or decode step under balance at $0.002 per successful item; failed validation never consumes balance after the engine rejects the request. Pair this endpoint with a Base64 tool when a partner system only speaks Base64, but keep the steps on separate landings so each page matches a single search intent—basE91 density versus Base64 ubiquity.
Integration use cases
Denser text-safe config tokens
Pack short UTF-8 configuration fragments more tightly than Base64 for tickets, chat, and JSON, then decode on the receiving service with the same mode field.
Legacy basE91 interoperability
Encode or decode Joachim Henke basE91 payloads when integrating with tools, archives, or libraries that already expect the classic ninety-one-symbol alphabet.
Docs and CI golden checks
Pin encode and decode fixtures so documentation samples and continuous-integration tests fail fast if the basE91 alphabet or bit-queue rules ever drift.