xxencode encoder
Packs “Hello, world!” into a classic xxencode block, begin 644 hello.txt and all, using only plus, minus, digits and letters so no EBCDIC gateway can mangle it, and decodes such blocks back to 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!
- Calculation mode
- Encode
- Filename
- hello.txt
- Result
- begin 644 hello.txt BG4JgP4wg65RjQalY6E++ + end
- Encoding
- xxencode
- Bytes
- 13
xxencode is a classic binary-to-text encoding related to uuencode, but it swaps the space-heavy uu alphabet for a sixty-four character set built only from plus, minus, digits, and letters. People search for an xxencode encoder or xxencode decoder when they restore vintage mail archives, interoperate with old Unix transfer tools, teach encoding history beside Base64, or need a deterministic text-safe packing of short UTF-8 messages. Encoding is pure UTF-8 then six-bit packing; decoding accepts optional begin and end wrappers, strips blank lines, and rejects illegal symbols instead of silently repairing them.
Encode UTF-8 text to classic xxencode
The engine interprets the string as Unicode text, serializes it to UTF-8 bytes, then wraps those bytes in the classic begin and end form used by historical xxencode tools. Each body line starts with a length character taken from the same sixty-four symbol alphabet, followed by four-character groups that pack three data bytes into twenty-four bits of six-bit indices. Lines carry at most forty-five data bytes, matching the familiar uuencode line budget so long messages stay readable in mail clients and log viewers.
The alphabet itself is only plus, minus, digits zero through nine, uppercase A through Z, and lowercase a through z—no spaces and no punctuation that EBCDIC gateways used to rewrite. Empty strings are valid and still produce a well-formed block with a zero-length terminator line. 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.
Decode xxencode back to text and handle invalid input
Set mode to decode and put a classic xxencode block or a body-only line sequence in text. Leading and trailing blank lines are ignored so multi-line pastes still work. The alphabet is strict: only plus, minus, digits, and letters are accepted.
Lines that declare more than forty-five data bytes, truncated four-character groups shorter than the declared length, or data after the zero-length terminator are rejected the same way. Successful decode returns result as the recovered string, mode decode, encoding xxencode, bytes as the decoded UTF-8 length, and filename from the begin line or data when the header was omitted. Prefer this capability when your search intent is literally xxencode encoder, xxencode decoder, or EBCDIC-safe uuencode alternative for human-readable content; Base64, Ascii85, and classic uuencode remain separate tools with their own landings.
What you can do with it
Legacy Unix xxencode interoperability
Produce or consume classic begin and end blocks that match historical xxencode tools for restoration labs, training materials, and mixed-platform handoffs.
FAQ
How do I encode text with xxencode?
Optional filename sets the begin-line name. The response result field holds the classic xxencode block and bytes is the UTF-8 length.
How do I decode xxencode back to text?
Optional begin and end wrappers are accepted. The result field is the recovered UTF-8 text and filename reflects the begin line when present.
What happens on an invalid xxencode character?
Characters outside the EBCDIC-safe alphabet (+ - 0-9 A-Z a-z), overlong lines, and truncated groups are rejected; validation failures are not charged.
Is the xxencode encoder free?
The browser tool runs free on your device.
How is xxencode different from uuencode?
Both pack three bytes into four six-bit characters with a length prefix, but xxencode uses an alphanumeric alphabet (+-0-9A-Za-z) designed for safer transfer through EBCDIC systems, while classic uuencode uses a space-based alphabet that mail gateways often corrupt.
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/xxencode \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, world!"}'const res = await fetch("https://api.kit.forhosting.com/enc/xxencode", {
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/xxencode",
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/xxencode", 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/xxencode", 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.xxencode",
"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
That alphanumeric design was created so mail gateways and EBCDIC systems would not mangle payloads the way they often mangled uuencode streams. This capability does that everyday job: choose mode encode or decode, send a text field, optionally name the begin-line file, and receive a classic begin-and-end block or recovered plaintext—or a clear invalid_input error when a decode payload contains a character outside the xx alphabet.
Encode UTF-8 text to classic xxencode
Send a JSON body with the required string field text set to the plain message you want to represent in xxencode, and leave mode at its default encode or set mode to encode explicitly. An optional filename field (aliases name and file) writes a simple begin-line name such as message.txt; when omitted the name defaults to data. Optional aliases input, value, and s are accepted for the text field when you generate clients from older form names. The response always includes result with the complete xxencode block, mode equal to encode, encoding equal to xxencode, bytes equal to the UTF-8 length before encoding, and filename echoing the begin-line name so you can assert both payload size and header metadata in tests.
Decode xxencode back to text and handle invalid input
Optional begin lines of the form begin mode filename are parsed for the reported filename, and a trailing end line is accepted when present; payloads without wrappers are equally valid as long as each body line starts with a length character from the alphabet. Any other character—including spaces from a uuencode paste, URL punctuation, or binary noise—causes an immediate invalid_input failure with a message that names the invalid xxencode character condition, so clients can fix the paste instead of receiving corrupted Unicode. After alphabet and structure 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 archive fragment is cheap for operators and safe for end users.
API usage, pricing, workflows, and practical limits
Call the free in-browser xxencode encoder for classroom demos, support playbooks, archive recovery checks, and one-off conversions without installing historical Unix packages or language-specific ports. Authors shipping SDKs can map the result field straight into a copy button, while mode and encoding labels make OpenAPI examples self-explanatory for readers who only know the classic begin and end wrapper and the alphanumeric alphabet. 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. A typical workflow encodes a short configuration value or sample payload for storage in a text-only ticket, ships it through email or chat that may cross EBCDIC-aware hops, then decodes it on the receiving service with mode decode and asserts that bytes match the original length and that filename matches the begin line. Pair this endpoint with a Base64 tool when a modern partner system only speaks Base64, but keep the steps on separate landings so each page matches a single search intent—xxencode heritage and EBCDIC safety versus Base64 ubiquity.
Integration use cases
EBCDIC-safe mail and archive transfer
Encode short UTF-8 payloads with the alphanumeric xx alphabet when gateways or EBCDIC systems would mangle classic uuencode spaces, then decode on arrival with the same mode field.
Docs and CI golden checks
Pin encode and decode fixtures so documentation samples and continuous-integration tests fail fast if the xx alphabet or line-length rules ever drift.