Encode and decode data:image/png;base64 Data URIs, RFC 4648 Base64URL JWT tokens, and Base16 byte streams client-side.
Hexadecimal Decoder parses space-delimited or 0x-prefixed Base16 byte streams into UTF-8 ASCII characters, decimal integers, and RFC 4648 Base64URL strings without server exfiltration. RFC 4648 §5 Base64URL replaces index 62 ('+') with '-' (0x2D) and index 63 ('/') with '_' (0x5F) while omitting '=' (0x3D) padding for URI and JWT header safety. If an input payload mixes uppercase and lowercase hex nibbles, then the radix parser resolves each 8-bit octet without NaN truncation.
Real-time byte overhead curve across UTF-8 payload scaling
Positional radix-16 nibble weights, 24-bit Base64URL bit-group partitioning, and byte-boundary padding equations.
Every 3-octet (24-bit) input group subdivides into four 6-bit indices (0..63). Remainder octets require 1 or 2 padding (0x3D) characters to align the 4-character quantum.
Byte length emitted by UTF-8 TextEncoder.encode(str)
4-byte aligned ASCII output length (+33.33% ceiling)
Splits each 8-bit octet into high (b >> 4) and low (b & 0x0F) 4-bit nibbles mapped onto 0–9 and A–F, doubling character length (+100%).
Two hexadecimal nibbles per raw input byte
Binary 11111111 full 8-bit unsigned integer ceiling
Standardizes telegraph pulse durations relative to the fundamental dot quantum T_dit (1200 / WPM milliseconds under PARIS 50-unit calibration).
Base pulse duration and intra-character element gap
Represented by "/" between space-delimited character codes
Processes 512-bit padded blocks across 64 Merkle-Damgård rounds over eight 32-bit state registers (H0..H7) to emit a 256-bit (64-hex-char) digest.
Fractional square roots of the first 8 primes (2..19)
Fractional cube roots of the first 64 primes (2..311)
| Vector Profile | Input Stream | Deterministic Output | Byte Boundary Implication |
|---|---|---|---|
| UTF-8 Greeting Vector | Plaintext: "Hello, Base64!" (14 B) | SGVsbG8sIEJhc2U2NCE (1-pad, 20 B) | 5-quantum ceiling with single 0x3D padding character (n mod 3 is 2). |
| High-Bit Octet Sequence | Bytes: [251, 255, 191] (0xFBFFBF) | Std: +/+/ | URL: -_-_ | RFC 4648 §5 replaces "+" and "/" to prevent URL query corruption. |
| Hexadecimal Byte Stream | Hex: "48 65 78" & "0xFF" | ASCII: "Hex" | Dec: 255 (11111111) | Case-insensitive radix-16 nibble parsing without NaN truncation. |
| ITU-R Distress Signal | Plaintext: "SOS" (3 Chars) | ... --- ... (27 Timing Units) | 3 dits + 3-unit gap + 3 dahs + 3-unit gap + 3 dits. |
| NIST FIPS 180-4 Vector | Input: "abc" (24 Bits) | ba7816bf8f01cfea...f20015ad (64 Hex) | Single 512-bit block compression yielding deterministic 256-bit digest. |
Modern Base64, Base32 & Data URI String Converters must reconcile three distinct byte representations without corrupting multi-byte Unicode sequences: raw 8-bit octets emitted by UTF-8 TextEncoder, 4-bit nibbles processed by a Hexadecimal Decoder, and 6-bit sextets defined in IETF RFC 4648. When inspecting network frames or memory registers formatted in IEEE 754 Hexadecimal, each byte (0x00 to 0xFF) splits into an upper nibble (bits 7–4, multiplied by 16^1) and a lower nibble (bits 3–0, multiplied by 16^0). Feeding space-delimited vector 48 65 78 into the parser resolves 0x48 (72 decimal for H), 0x65 (101 decimal for e), and 0x78 (120 decimal for x) into a contiguous ASCII Byte Stream, while 0xFF evaluates to unsigned decimal 255 (11111111 binary).
Conversely, when serializing binary keys or OAuth 2.0 state parameters for HTTP transport, RFC 4648 Base64URL eliminates the URL-collision hazards of standard Base64. In standard Base64, a 24-Bit Octet Quantum containing high-bit bytes such as [251, 255, 191] (0xFBFFBF) maps onto indices 62 and 63 of the 6-Bit Index Alphabet, producing +/+/. If placed directly into a query string without RFC 3986 Percent-Encoding, web servers decode + as a space (0x20) and / as a path delimiter. Switching to RFC 4648 Base64URL deterministically substitutes - (0x2D) and _ (0x5F) and strips trailing 0x3D padding to emit -_-_. To compare all 30 standards side by side, return to the Base64, Hex & Cryptographic Decoder Master Hub or verify one-way checksums in our Cryptographic Hash Generators Tool & Guide.
Replaces standard Base64 index 62 (+) with hyphen-minus (-, 0x2D) and index 63 (/) with underscore (_, 0x5F) while omitting trailing = (0x3D) padding characters for OAuth 2.0 PKCE and JWT headers.
Splits each 8-bit octet into an upper 4-bit nibble (bits 7–4) and a lower 4-bit nibble (bits 3–0) over the 16-symbol alphabet 0–9 and A–F with zero padding ambiguity.
Partitions 40-bit (5-byte) input groups into eight 5-bit quintets mapped to uppercase A–Z and digits 2–7, omitting 0, 1, 8, and 9 to prevent visual transcription errors.
When front-end performance workflows require embedding small vector icons or binary thumbnails directly inside HTML or CSS stylesheets, developers serialize raw files under the Data URI MIME Scheme (RFC 2397) and validate the resulting byte buffer inside our Base64 Image Decoder. For case-insensitive file systems, DNS labels, and RFC 6238 Time-Based One-Time Password (TOTP) provisioning secrets, engineers instead select the Base32 Alphabet, which maps 40-bit (5-byte) input blocks into eight 5-bit uppercase alphanumeric characters (A–Z and 2–7).
In low-bandwidth embedded telemetry and amateur radio beacon diagnostics, character streams are frequently cross-checked against variable-length pulse timing governed by ITU-R M.1677-1 Morse Code using a bidirectional Morse Code Decoder. Whenever decoded binary buffers require cryptographic provenance before ingestion, passing the reconstructed Uint8Array directly into the browser's Web Crypto SubtleCrypto engine computes a deterministic 256-bit NIST FIPS 180-4 SHA-256 checksum or a keyed HMAC-SHA256 Digest without exposing preimage bytes.
Wireshark hex dumps and C byte arrays (0x48, 0x65, 0x78) mix uppercase (A–F) and lowercase (a–f) digits. Normalizing delimiters via regex before calling parseInt(nibblePair, 16) prevents NaN byte corruption across -byte streams.
RFC 7519 JSON Web Tokens omit trailing 0x3D characters to save 1–2 bytes per segment. Before invoking atob(b64), append (4 - (token.length % 4)) % 4 padding symbols so the character count realigns to a 4-symbol quantum ( aligned characters).
A single Unicode emoji (such as U+1F510) occupies 4 bytes in UTF-8 (F0 9F 94 90) and 2 UTF-16 code units in JavaScript strings. Encoding at the Uint8Array byte layer prevents split surrogate pairs when slicing frames across network buffers.
During legacy database audits, our integrated Hash Identifier automatically distinguishes deprecated 128-bit MD5 Message Digest strings from SHA-256 digests, while the companion token generator mints collision-resistant RFC 4122 UUID v4 identifiers backed by 122 bits of hardware-seeded CSPRNG Entropy.
Side-by-side radix efficiency, character alphabet constraints, padding rules, and URI transport safety across IETF RFC 4648 and RFC 3986 URI syntax.
Filter specification rows by bijective codec reversibility or one-way cryptographic digest class.
| Encoding Scheme | Normative RFC | Input -> Output Quantum | Wire Expansion | Padding & URL Safety |
|---|---|---|---|---|
| Base64 Standard | IETF RFC 4648 §4 | 3 Bytes (24b) -> 4 Sextets | +33.33% (4/3n) | Mandatory = (0x3D); unsafe + and / in URIs |
| Base64URL (Filename Safe) | IETF RFC 4648 §5 | 3 Bytes (24b) -> 4 Sextets | +33.33% (4/3n) | Optional = omitted; uses - (0x2D) and _ (0x5F) |
| Base32 Uppercase | IETF RFC 4648 §6 | 5 Bytes (40b) -> 8 Quintets | +60.00% (8/5n) | Uses A–Z and 2–7; case-insensitive DNS/TOTP safe |
| Base16 Hexadecimal | IETF RFC 4648 §8 | 1 Byte (8b) -> 2 Nibbles | +100.00% (2n) | Zero padding; deterministic 0x00–0xFF nibble pairs |
| Percent-Encoding | IETF RFC 3986 §2.1 | 1 Reserved Byte -> %XX | Variable (1x–3x) | Escapes reserved URI delimiters via % hex triplets |
Manage Base64URL OAuth 2.0 client secrets, PKCE verifiers, and hex encryption keys inside 1Password Developer Vaults.
Execute RFC 4648 Base64URL JWT verification and zero-latency byte parsing at the Cloudflare network edge.
Inspect Base16 hexadecimal packet dumps and RFC 3986 URI percent-encoded payloads directly inside JetBrains IDEs.
Diagnose modulo-4 padding exceptions, URL query corruption, and odd-nibble hexadecimal truncation with one-click vector loading.
Use Standard Base64 when embedding small raster icons (under 4 KB) in CSS/HTML Data URIs or encoding X.509 certificates where strict 4-character quantum padding (0x3D) is required by MIME parsers.
Standard Base64 emits "+" and "/" which collide with URL form-encoding and path delimiters. Base64URL substitutes "-" (0x2D) and "_" (0x5F) and strips trailing 0x3D padding to guarantee lossless HTTP query transport.
Unlike Base64 (which spans 3-byte boundaries), Base16 maps every individual 8-bit octet onto exactly two hexadecimal nibbles (00..FF), enabling direct byte-offset inspection in Wireshark and GDB.
Base64 and Hex are reversible encodings with zero cryptographic secrecy. For tamper-evident payload verification or collision-resistant primary keys, use SHA-256 (128-bit birthday bound) and UUID v4.
Every pair of hexadecimal characters (0–9, A–F) represents one 8-bit octet ranging from 0x00 (0 decimal) to 0xFF (255 decimal, binary 11111111). The radix-16 parser strips optional "0x" prefixes and whitespace, converts each two-nibble token via parseInt(token, 16) into a Uint8Array byte buffer, and decodes the resulting byte stream through UTF-8 TextDecoder(utf8).
Both specifications map 6-bit values 0 through 61 to A–Z, a–z, and 0–9. However, RFC 4648 Section 4 maps index 62 to "+" (0x2B) and index 63 to "/" (0x2F), whereas Section 5 Base64URL maps index 62 to "-" (0x2D, hyphen-minus) and index 63 to "_" (0x5F, low line) and allows omitting trailing 0x3D padding characters so tokens can pass through URLs and filenames unescaped.
In binary, the 24-bit sequence 0xFBFFBF is 11111011 11111111 10111111. Grouping those 24 bits into four 6-bit sextets yields 111110 (62), 111111 (63), 111110 (62), and 111111 (63). Standard Base64 encodes those indices as "+/+/", which breaks URI query parsing, whereas RFC 4648 Section 5 Base64URL deterministically outputs "-_-_" with zero reserved URL characters.
Base32 partitions binary input into 40-bit (5-byte) quanta divided into eight 5-bit quintets using the case-insensitive alphabet A–Z and 2–7 (omitting 0, 1, 8, and 9 to prevent human transcription errors). It incurs a 60.0% wire expansion (8/5 ratio), making it ideal for RFC 6238 TOTP 2FA secret seeds and case-insensitive DNS labels.
JSON Web Tokens (RFC 7519) strip trailing 0x3D padding characters and use "-" and "_". Passing a raw JWT segment directly to window.atob(b64) fails because atob(b64) requires standard "+" and "/" symbols and a string length divisible by 4. Normalizing "-" to "+", "_" to "/", and appending (4 - (len % 4)) % 4 padding characters restores strict RFC 4648 quantum alignment.