Base94 encoder & decoder
“Hello, world!” becomes /P|?l:+>Nq\sr<+r in Base94, which uses every printable ASCII character from ! to ~ except the space, so each character carries more than in Base64 and the text stays inside plain ASCII. 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
- /P|?l:+>Nq\sr<+r
- Calculation mode
- Encode
- Variant
- base94
- Bytes
- 13
Base94 encoding maps binary data onto every printable non-space ASCII character from exclamation mark through tilde—ninety-four symbols—so each character carries more information than Base64’s sixty-four-symbol alphabet and still stays inside the classic printable range used by terminals, chat, and plain-text config files. People search for a Base94 encoder or Base94 decoder when they want maximum text density without leaving ASCII, when they need a paste-safe form that is denser than Base64 for short tokens, or when a protocol already assumes the full printable set excluding space. Encoding is deterministic UTF-8 then big-integer base-256 to base-94 conversion; decoding rejects spaces, control characters, and any symbol outside the alphabet instead of inventing silent replacements.
Encode UTF-8 text to Base94 for maximum printable density
The engine interprets the string as Unicode text, serializes it to UTF-8 bytes, then converts those bytes from base two hundred fifty-six to base ninety-four using big-integer arithmetic. Each remainder indexes into the fixed alphabet that runs from exclamation mark through tilde—exactly ninety-four printable ASCII characters with no space and no control codes—so the result is always a dense, paste-safe string for channels that accept any printable non-space character. Multilingual text, emoji, and punctuation all encode correctly because the path is full UTF-8, not a Latin-1 shortcut.
The response always includes result with the Base94 string, mode equal to encode, variant equal to base94, bytes equal to the UTF-8 length before encoding, and alphabet set to the full ninety-four-character string so you can assert the alphabet in tests. 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 denser text-safe packing than Base64 for short tokens, configuration fragments, documentation samples, or any pipeline that already tolerates the full printable ASCII set excluding space.
Decode Base94 back to text and handle invalid characters
Set mode to decode and put a Base94 string in text. The alphabet is strict: only the ninety-four characters from exclamation mark through tilde are accepted. Leading exclamation marks decode as leading zero bytes, matching the encode path so length-preserving round-trips stay stable.
Successful decode returns result as the recovered string, mode decode, variant base94, bytes as the decoded UTF-8 length, and alphabet for symmetry with encode responses. Prefer this capability when your search intent is literally base94 encoder, base94 decoder, or printable ascii base encoding for human-readable content; standard Base64, URL-safe Base64, Base58, and Ascii85 remain separate tools with their own landings and alphabets.
FAQ
How do I encode text to Base94?
The response result field holds the Base94 string and bytes is the UTF-8 length.
How do I decode Base94 back to text?
Set mode to decode and put the Base94 string in text. Only the 94 printable ASCII symbols from ! through ~ are accepted. The result field is the recovered UTF-8 text.
What happens on an invalid Base94 character?
Characters outside the alphabet (including space and control codes) are rejected with a message that names the character and index; validation failures are not charged.
Is the Base94 encoder free?
The browser tool runs free on your device.
How is Base94 different from Base64?
Base94 uses all 94 printable non-space ASCII characters (!–~) for denser packing than Base64’s 64-symbol alphabet. This tool is not Base64, Base58, or Ascii85—those have separate landings and alphabets.
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/base94 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, world!"}'const res = await fetch("https://api.kit.forhosting.com/enc/base94", {
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/base94",
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/base94", 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/base94", 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.base94",
"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
This capability does that job cleanly: choose mode encode or decode, paste a text field, and receive the transformed string plus byte length and the fixed alphabet, or a clear invalid_input error when a decode payload contains a character outside the ninety-four-symbol set.
Encode UTF-8 text to Base94 for maximum printable density
Send a JSON body with the required string field text set to the plain message you want to represent in Base94, and leave mode at its default encode or set mode to encode explicitly. Leading zero bytes in the UTF-8 payload map to leading exclamation marks (alphabet index zero), mirroring the leading-one convention familiar from Base58 so round-trips preserve length and empty payloads stay empty. Optional aliases input, value, and s are accepted for the same field when you generate clients from older form names.
Decode Base94 back to text and handle invalid characters
Any other character—including space, tab, newline, control codes, or bytes outside the printable range—causes an immediate invalid_input failure with a message that names the invalid Base94 character and its index, 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 Base94 encoder for classroom demos, support playbooks, density comparisons against Base64, and one-off conversions without installing custom libraries. A typical workflow encodes a short configuration value for storage in a text-only ticket that allows any printable non-space ASCII, 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, variant, and alphabet labels make OpenAPI examples self-explanatory for readers who need the full ninety-four-character printable set. 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 or Base85 tool when a partner system only speaks those alphabets, but keep the steps on separate landings so each page matches a single search intent—Base94 maximum printable density versus Base64 ubiquity or Ascii85 Adobe streams.
Integration use cases
Maximum-density text-safe tokens
Pack short UTF-8 secrets or config fragments denser than Base64 for tickets, chat, and JSON that accept any printable non-space ASCII, then decode on the receiving service with the same mode field.
Density benchmarks versus Base64 and Base85
Compare encoded length of the same payload across Base94, Base64, and Ascii85 when choosing a text-safe representation for documentation samples or protocol design notes.
Docs and CI golden checks
Pin encode and decode fixtures so documentation samples and continuous-integration tests fail fast if the Base94 alphabet or leading-zero rules ever drift.