OpenPGP Radix-64 encoder
“Hello, OpenPGP!” becomes the Radix-64 body SGVsbG8sIE9wZW5QR1Ah plus the checksum line =FPfi: the OpenPGP armor format, whose CRC-24 lets the receiver spot corruption before trusting the 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, OpenPGP!
- Result
- SGVsbG8sIE9wZW5QR1Ah =FPfi
- Calculation mode
- Encode
- Body
- SGVsbG8sIE9wZW5QR1Ah
- Crc24
- FPfi
People searching for an OpenPGP Radix-64 encoder need that exact wire form: folded Base64 lines plus a final equals-prefixed four-character checksum, not a plain Base64 blob without integrity. This capability encodes UTF-8 text into that armored body, or decodes an armored body after verifying the CRC-24 against the reconstructed octets.
Encode text to OpenPGP Radix-64 with a CRC-24 trailer
The engine serializes the string to UTF-8 bytes, maps those bytes through the OpenPGP Radix-64 alphabet (identical to MIME Base64: A through Z, a through z, zero through nine, plus, and slash, with equals padding when the length is not a multiple of three), then computes the twenty-four bit cyclic redundancy check defined in RFC 4880 section six: generator polynomial zero-x-eight-six-four-C-F-B and initialization zero-x-B-seven-zero-four-C-E, accumulated over the raw octets before encoding.
That CRC is itself encoded as exactly four Radix-64 characters and written on its own final line after a leading equals sign. By default wrap is true, so the Base64 body is folded at sixty-four characters per line to match classic OpenPGP armor readability; set wrap to false if you need a single continuous body line for compact storage. Empty strings are valid and still produce a CRC line over zero bytes.
Multilingual text and emoji round-trip because the path is full UTF-8. Identical inputs always yield identical armor because the algorithm is pure arithmetic with no salt, clock, or network.
How Radix-64 armor differs from plain Base64
Call the free in-browser OpenPGP Radix-64 encoder for classroom demos, support playbooks, and one-off armor checks without installing GnuPG. Another workflow re-verifies documentation samples that publish armored blobs so readers can trust the CRC line still matches the body. Compared with plain Base64, this landing page targets a different search intent: people who need the OpenPGP checksum trailer and line folding, not merely a padded alphabet.
Compared with full OpenPGP message tools, this capability deliberately stops at the Radix-64 body and CRC—it does not assemble packets, signatures, or encryption—so the contract stays tiny and deterministic.
What you can do with it
Armor short secrets for text-only channels
Encode UTF-8 fragments into OpenPGP Radix-64 with a CRC-24 trailer so email, chat, and tickets can carry them safely; decode and verify on the receiving side.
FAQ
What is OpenPGP Radix-64?
It is the Base64-style alphabet OpenPGP uses for ASCII armor, plus a trailing CRC-24 checksum line (=XXXX) computed over the raw bytes before encoding (RFC 4880 §6).
Is this the same as plain Base64?
The alphabet matches standard Base64, but OpenPGP armor adds a mandatory CRC-24 trailer and usually folds lines at 64 characters. Plain Base64 tools omit that checksum.
What happens if the CRC-24 checksum does not match?
Decoding recalculates the CRC-24 over the recovered bytes and compares it with the four-character line at the end. A mismatch, a missing checksum line, a character outside the alphabet or bytes that are not valid UTF-8 text all stop with a clear message.
Can I keep the armored text on a single line?
Yes. By default the Base64 is folded every 64 characters, as in classic OpenPGP armor. Turn line folding off when encoding and you get one continuous line plus the checksum line, which is handy for compact storage.
Can I paste a whole PGP block with its BEGIN and END lines?
Yes. Banner lines such as BEGIN and END and simple header lines are stripped before decoding, so a larger armor block still works. The tool only handles the Radix-64 text and its checksum; it does not build packets, signatures or encryption.
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/base64-radix64 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, OpenPGP!"}'const res = await fetch("https://api.kit.forhosting.com/enc/base64-radix64", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello, OpenPGP!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base64-radix64",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello, OpenPGP!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base64-radix64", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello, OpenPGP!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello, OpenPGP!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base64-radix64", 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, OpenPGP!"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base64_radix64",
"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
OpenPGP ASCII armor carries binary payloads through email and text channels by encoding them as Radix-64—the same sixty-four character alphabet as standard Base64—then appending a CRC-24 checksum line so receivers can detect corruption before they parse packets. Mismatched checksums, missing CRC lines, illegal alphabet characters, and non-UTF-8 payloads fail with a clear invalid_input error instead of silent garbage.
Encode text to OpenPGP Radix-64 with a CRC-24 trailer
Send a JSON body with the required string field text set to the plain message you want to armor, and leave mode at its default encode or set mode to encode explicitly. The response includes result (body plus CRC line), body (continuous Base64 without the checksum), crc24 (the four-character token), crc24_hex (six lowercase hex digits), crc_ok true, bytes (UTF-8 length), mode encode, and wrap. Optional aliases input, value, and s are accepted for the text field; direction, op, and action alias mode; line_wrap and fold alias wrap.
Decode armored Radix-64 and verify the CRC-24 checksum
Optional full PGP framing lines such as BEGIN or END banners and simple header key-value pairs are stripped so pasting a larger armor block still works when you only need the Radix-64 body. The engine concatenates the body lines, decodes the standard alphabet, recomputes CRC-24 over the recovered octets, and compares it to the four-character trailer. Prefer this capability when your search intent is OpenPGP Radix-64, ASCII armor CRC-24, or verifying armored checksums; plain text-to-Base64 without a trailer belongs to standard Base64 tools, and URL-safe cookies belong to base64url encoders. Set mode to decode and put an OpenPGP-style armored body in text: one or more Base64 lines followed by a trailing checksum line of the form equals plus four alphabet characters. When the checksum does not match, the task fails immediately with invalid_input and a message that reports both the claimed and the computed CRC in hex—so operators can tell truncation from bit flips without guessing. Missing CRC lines, empty bodies, illegal alphabet characters, padding errors, and non-UTF-8 payloads also raise invalid_input with a specific reason. Validation failures are not charged on the prepaid API.
API usage, pricing, workflows, and how this differs from plain Base64
Use the prepaid KIT API when a backend, edge worker, 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 fragment for transport through a ticket system that only allows printable ASCII, then decodes on the receiving service with mode decode and asserts that crc_ok is true and bytes match the original length. Authors shipping SDKs can map result into a copy button while exposing crc24_hex for human-readable integrity labels in dashboards and OpenAPI examples.
Integration use cases
CI and documentation checksum pins
Golden-test armored samples: encode then decode must round-trip, and a tampered CRC line must raise invalid_input before release.
Support and training without full GnuPG
Agents and students generate or verify Radix-64 bodies in the free browser widget when they only need the armor format and CRC-24, not packet crypto.
Technical questions
How do I encode text to Radix-64 with a CRC?
Send JSON with text set to your plain string and mode encode (or omit mode). result contains the Base64 body (optionally wrapped at 64 columns) and a final =CRC line.
What happens if the CRC-24 checksum does not match?
Decode fails with invalid_input and reports the claimed and computed CRC values. The request is not charged.
What does the OpenPGP Radix-64 encoder cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful item; invalid input is not billed.