Universal Text Codec – Base16 to Base91, URL, HTML Entity, Unicode Escape, ROT13 Online

Encode or decode text in 20+ formats simultaneously: Base16, Base32, Base36, Base45 (RFC 9285), Base58 (Bitcoin/IPFS), Base62, Base64, Base64url, Base85 (Ascii85 & z85), Base91, URL percent-encoding, HTML entities, Unicode escapes (JS/Python), ROT13, Punycode, and more. Auto-detects encoding. All processing runs locally in your browser.

What is the Universal Text Codec?

The Universal Text Codec encodes or decodes any text or binary data across 37 formats simultaneously. Paste a string and instantly see results in every supported encoding — all computed locally in your browser with no data sent to any server.

Whether you are debugging a JWT token, encoding a Bitcoin wallet address, preparing a QR code payload, escaping C firmware strings, inspecting UTF-16 byte order, reading Morse code, or normalizing Unicode — this tool eliminates the need to open multiple single-purpose converters.

Base64 and Base64url — JWT, Email, Data URIs

Base64 (RFC 4648 §4) encodes every 3 bytes as 4 characters from A–Z, a–z, 0–9, +, / with = padding — 33% overhead. Base64url replaces + with - and / with _ for safe use in URLs and HTTP headers.

Example — 'Hello' in Base64:

  • Input bytes: 48 65 6C 6C 6F
  • Base64: SGVsbG8=
  • Base64url: SGVsbG8= (same when no + or / appear)
  • JWT tokens use Base64url for header and payload sections

Base58, Base62 and Crockford Base32

These three human-readable encodings remove visually ambiguous characters for safe manual transcription.

Base58 (Bitcoin) alphabet — 58 characters, no 0 O I l + /:

123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz

Crockford Base32 alphabet — 0-9 A-Z without I L O U:

0123456789ABCDEFGHJKMNPQRSTVWXYZ

Crockford Base32 is used in ULID (Universally Unique Lexicographically Sortable Identifier) and produces output that sorts correctly as a string.

All three use BigInteger arithmetic (O(n²)) and are limited to 4 KB input. For large binary data, use Base64 or Base85.

Binary String and C Escape Sequences

Embedded firmware developers frequently need to represent binary data as C source literals or binary digit patterns.

'Hello' in binary and C escape forms:

  • Binary String: 01001000 01100101 01101100 01101100 01101111
  • C Hex Escape: \x48\x65\x6C\x6C\x6F — paste into C/C++ string literals
  • C Octal Escape: \110\145\154\154\157 — POSIX / ANSI terminal sequences

Use Hex Bytes input mode to feed raw binary data (e.g. DE AD BE EF) and see it in all formats at once.

UTF-16 and UUencode

UTF-16 Big Endian and Little Endian

'Hello' in UTF-16:

  • UTF-16 BE: 00 48 00 65 00 6C 00 6C 00 6F — macOS, Java, network byte order
  • UTF-16 LE: FF FE 48 00 65 00 6C 00 6C 00 6F 00 — Windows (BOM included), .NET, NTFS

Supplementary plane characters (U+10000+) are encoded as surrogate pairs (4 bytes each).

UUencode — Legacy Unix Email Encoding

UUencode encodes 3 bytes as 4 characters in ASCII range 32–95 and wraps output in begin 644 data / end headers. Historically used to share binary files on Usenet before MIME Base64 became standard.

Text Transforms — JSON, QP, ROT47, Atbash, Morse, Unicode

JSON String Escape

  • " → \" · \ → \\ · \n → \n
  • Control chars below U+0020 → \uXXXX numeric escape
  • Use case: embedding multi-line strings or user content in JSON payloads

Quoted-Printable (RFC 2045)

Encodes non-ASCII bytes as =XX while leaving printable ASCII unchanged. Used for MIME email bodies where text is mostly readable. Lines are soft-wrapped at 76 characters with =\r\n continuation.

ROT47 vs ROT13

'Hello, World! 123' through both ciphers:

  • ROT13: Uryyb, Jbeyq! 123 (only letters rotate)
  • ROT47: w6==@[ (@C=5P "bD (all printable ASCII 33–126 rotates)

Both are self-inverse: applying the same cipher twice returns the original.

Atbash Cipher

Mirror substitution: A↔Z, B↔Y, C↔X … a↔z, b↔y. Non-alphabetic characters pass through unchanged. Originally a Hebrew cipher, it is self-inverse like ROT13.

Morse Code (ITU-R M.1677)

'SOS' in Morse: ... --- ...

Letters within a word are space-separated; words are separated by / . Supports A-Z, 0-9, and common punctuation.

Unicode NFD and NFC Normalization

  • NFD: é (U+00E9) → e (U+0065) + combining acute accent (U+0301)
  • NFC: e + combining acute → é (precomposed form, W3C recommended)
  • Uses the browser's native String.prototype.normalize() — handles full Unicode

Emoji Encoding

Each byte value (0–255) maps to a unique emoji from Unicode Miscellaneous Symbols and Pictographs (U+1F300–U+1F3FF). Fully reversible and a distinctive way to represent binary data visually.

Frequently Asked Questions

Which encoding should I use for a JWT?

JWTs use Base64url (RFC 4648 §5), not standard Base64. The - and _ characters replace + and / making the token safe in URL paths and Authorization headers without further escaping.

How do I use Hex Bytes input mode?

Switch Input Mode to Hex Bytes and paste space-separated or continuous hex: DE AD BE EF or DEADBEEF. All 37 encodings recalculate from the raw binary payload — useful for firmware register dumps and network captures.

Why are some encodings limited to 4 KB?

Base36, Base58, and Base62 use BigInteger arithmetic that scales as O(n²). These encodings are designed for small payloads (Bitcoin addresses are 25 bytes, IPFS CIDs are 34 bytes). For large binary data, use Base64 or Base85 which are block-based O(n) algorithms.

Input Settings

Show / Hide Groups

Input
Text → Encoded
Encoding Results
37 encodings
1 byte → 2 chars · 100% overhead · debug dumps, color codes
5 bytes → 8 chars · 60% overhead · TOTP secrets, DNS labels, email-safe tokens
5 bytes → 8 chars · 60% overhead · sort-preserving, DNS names
5 bytes → 8 chars · alphabet 0-9A-Z (no I L O U) · ULID, sort-preserving IDs
BigInteger · case-insensitive · URL shorteners (max 4 KB input)
2 bytes → 3 chars · 22% overhead · QR alphanumeric mode, EU COVID certs
BigInteger · no 0OIl+/ · Bitcoin addresses, IPFS CIDs (max 4 KB)
BigInteger · alphanumeric only · compact IDs, URL tokens (max 4 KB)
3 bytes → 4 chars · 33% overhead · JWT, email MIME, data URIs
3 bytes → 4 chars · 33% overhead · JWT, URL-safe tokens (RFC 4648 §5)
4 bytes → 5 chars · 25% overhead · PDF, PostScript, Git binary patches
4 bytes → 5 chars · 25% overhead · ZeroMQ frames (4-byte aligned input only)
13-bit blocks · ~23% overhead · compact binary transfer
1 byte → 8 binary digits · firmware bit patterns, datasheet register values
\x48\x65... · C/C++ hex string literal · paste directly into firmware source
\110\145... · C/C++ octal string literal · POSIX / ANSI terminal sequences
Each UTF-16 code unit → 2 bytes BE · macOS / Java / network byte order
Each UTF-16 code unit → 2 bytes LE + FF FE BOM · Windows / .NET / NTFS
3 bytes → 4 chars (ASCII 32-95) · legacy Unix mail · begin/end wrapped
1 byte → 1 emoji (U+1F300+) · novelty encoding · fully reversible, 256 symbols
1 byte → 2 hex chars, space-separated · firmware dumps, network captures
Reserved chars → %XX · RFC 3986 · query strings, API request parameters
Special chars → & < > · HTML template rendering, XSS prevention
All chars → &#decimal; · numeric decimal entity encoding
All chars → &#xHex; · numeric hexadecimal entity encoding
Non-ASCII → \uXXXX or \u{XXXXX} · JavaScript string literals
Non-ASCII → \uXXXX or \UXXXXXXXX · Python string literals
Each char → U+XXXX · Unicode consortium standard code point notation
" \ and control chars → \ sequences · embedding in JSON string values
Non-ASCII → =XX · MIME email body encoding · 76-char soft-wrap lines
A-Z shifted 13 · self-inverse · spoiler text, simple obfuscation
All printable ASCII (33–126) shifted 47 · self-inverse · extends ROT13
A↔Z B↔Y mirror substitution · self-inverse · Hebrew cipher, obfuscation
. - / word separator · ITU-R M.1677 · letters, digits, punctuation
Precomposed → base + combining marks · é→e+◌́ · Unicode NFD (JS native)
Combining marks → precomposed · e+◌́→é · Unicode NFC (web standard form)
IDN domains → xn--... · RFC 3492 · internationalized domain names
All 37 encoding/decoding operations run entirely in your browser (Rust/WebAssembly). No data is ever transmitted to any server. Base36 / Base58 / Base62 limited to 4 KB (BigInteger arithmetic).