Transcode binary octets, UTF-8 payloads, and Data URI streams client-side across RFC 4648 Base64, Base64URL, Hex, Morse, and SHA-256.
Base64 Image Decoder transcodes binary octets, UTF-8 payloads, and Data URI streams client-side in under 15ms. RFC 4648 §4 maps every 3-octet (24-bit) input quantum into 4 6-bit Base64 index characters, increasing payload byte size by 33.33% (4/3 ceiling). If an input string contains multi-byte Unicode or unaligned octets, then the parser normalizes byte boundaries and appends '=' padding deterministically.
Real-time byte trajectory comparing Raw UTF-8 Bytes (n), Base64 4*ceil(n/3) (+33.33%), and Hexadecimal 2n (+100%)
Explore all 30 verified encoding, radix, cipher, and cryptographic protocols with instant client-side search, multi-tag set-intersection filtering, and live payload byte calculation.
| Cmp | Standard & Authority | Category | Bit Quantum / Digest | Byte Expansion | Padding & URI Rules | Primary Engineering Use Case |
|---|---|---|---|---|---|---|
| RFC 4648 Base64 Standard IETF RFC 4648 §4 | Est. 1996 | Binary-to-Text Encoding | 6-Bit Sextet (Radix-64) | 1.333x (+33.3%) | Bijective Reversible URL-Safe: Requires Escaping | MIME email attachments, Data URIs, TLS PEM certificates, and JSON binary payloads | |
| RFC 4648 Base64URL (Filename-Safe) IETF RFC 4648 §5 | Est. 1997 | Binary-to-Text Encoding | 6-Bit Sextet (Radix-64 URL) | 1.333x (+33.3%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | JSON Web Tokens (JWT), OAuth 2.0 PKCE code challenges, and URL query strings | |
| RFC 4648 Base16 / Hexadecimal IETF RFC 4648 §8 / IEEE | Est. 1998 | Radix & Byte Representation | 4-Bit Nibble (Radix-16) | 2.000x (+100.0%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Memory dumps, MAC addresses, packet inspection, color hex codes, and hash digests | |
| ITU-R M.1677-1 International Morse Code ITU-R M.1677-1 | Est. 1999 | Telegraph & Signal Ciphers | Variable Timing (1:3:7 Dit/Dah) | ~3.200x Variable | Bijective Reversible URL-Safe: Requires Escaping | CW radio telemetry, aviation navigational beacons (NDB/VOR), and maritime distress signaling | |
| NIST FIPS 180-4 SHA-256 Digest NIST FIPS 180-4 | Est. 2000 | Cryptographic Hash Functions | 256-Bit Digest (64 Hex Chars) | Fixed 32 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | TLS certificate fingerprints, Git SHA-256 commits, Bitcoin Merkle trees, and package checksums | |
| RFC 4122 / RFC 9562 UUID v4 CSPRNG IETF RFC 4122 / RFC 9562 | Est. 2001 | Cryptographic Identifiers | 128-Bit (122 Random Entropy Bits) | Fixed 36 ASCII Chars | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | Distributed database primary keys, idempotency tokens, and trace correlation IDs | |
| RFC 4648 Base32 Standard IETF RFC 4648 §6 | Est. 2002 | Binary-to-Text Encoding | 5-Bit Quintet (Radix-32) | 1.600x (+60.0%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | TOTP 2FA authenticator secrets (RFC 6238), case-insensitive DNS labels, and Onion v3 addresses | |
| RFC 4648 Base32hex (Extended Hex) IETF RFC 4648 §7 | Est. 2003 | Binary-to-Text Encoding | 5-Bit Quintet (0–9, A–V) | 1.600x (+60.0%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | DNSSEC NSEC3 hashed owner names (RFC 5155) requiring lexicographical sort preservation | |
| NIST FIPS 180-4 SHA-512 Digest NIST FIPS 180-4 | Est. 2004 | Cryptographic Hash Functions | 512-Bit Digest (128 Hex Chars) | Fixed 64 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | High-security archival integrity, Linux shadow password hashing, and Ed25519 key derivation | |
| NIST FIPS 180-4 SHA-384 Digest NIST FIPS 180-4 | Est. 2005 | Cryptographic Hash Functions | 384-Bit Digest (96 Hex Chars) | Fixed 48 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | CNSA Suite TLS cipher suites, W3C Subresource Integrity (sha384-...), and ECDSA P-384 | |
| RFC 3174 SHA-1 Legacy Checksum IETF RFC 3174 / FIPS 180-4 | Est. 2006 | Cryptographic Hash Functions | 160-Bit Digest (40 Hex Chars) | Fixed 20 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | Git object blob addressing, BitTorrent info-hashes, and RFC 4122 UUID v5 namespace hashing | |
| RFC 1321 MD5 128-Bit Checksum IETF RFC 1321 | Est. 2007 | Cryptographic Hash Functions | 128-Bit Digest (32 Hex Chars) | Fixed 16 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | HTTP Content-MD5/ETag headers, S3 multipart upload checksums, and legacy hash identification | |
| NIST FIPS 202 SHA3-256 (Keccak) NIST FIPS 202 | Est. 2008 | Cryptographic Hash Functions | 256-Bit Sponge (64 Hex Chars) | Fixed 32 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | Post-Merkle-Damgård cryptographic hashing, smart contract state verification, and zero-knowledge proofs | |
| RFC 2104 HMAC-SHA256 Authenticator IETF RFC 2104 / FIPS 198-1 | Est. 2009 | Cryptographic Hash Functions | 256-Bit Keyed MAC | Fixed 32 Bytes | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | Webhook signature verification (Stripe/GitHub), AWS SigV4 signing, and JWT HS256 tokens | |
| RFC 9562 UUID v7 Time-Ordered IETF RFC 9562 §5.7 | Est. 2010 | Cryptographic Identifiers | 128-Bit (48-Bit Unix Epoch ms + 74 Random) | Fixed 36 ASCII Chars | One-Way Digest URL-Safe: Yes (RFC 3986 Safe) | B-tree indexed PostgreSQL/MySQL primary keys eliminating random page-split fragmentation | |
| RFC 2397 Data URI Base64 Encoder IETF RFC 2397 | Est. 2011 | Binary-to-Text Encoding | MIME Header + 6-Bit Base64 | 1.333x + MIME Prefix | Bijective Reversible URL-Safe: Requires Escaping | Inlining critical above-the-fold SVG/WebP icons, CSS background assets, and self-contained HTML files | |
| RFC 3986 URI Percent-Encoding IETF RFC 3986 §2.1 | Est. 2012 | Binary-to-Text Encoding | %XX Hex Octet Escape | 1.000x to 3.000x | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Escaping reserved URI delimiters (?, &, padding , /, +) and UTF-8 query parameters in HTTP requests | |
| RFC 3629 UTF-8 Multi-Byte Inspector IETF RFC 3629 / ISO 10646 | Est. 2013 | Radix & Byte Representation | 1 to 4 Octets per Code Point | 1.0x (ASCII) to 4.0x (Supplementary) | Bijective Reversible URL-Safe: Requires Escaping | Resolving DOMException InvalidCharacterError in btoa(str) for CJK, Cyrillic, accented, and emoji strings | |
| ANSI X3.4 7-Bit ASCII & Decimal Table ANSI X3.4 / RFC 20 | Est. 2014 | Radix & Byte Representation | 7-Bit (Code Points 0–127) | 1.000x (1 Byte/Char) | Bijective Reversible URL-Safe: Requires Escaping | Control character inspection (LF 0x0A, CR 0x0D, NUL 0x00), serial protocols, and printable text conversion | |
| Binary 8-Bit Octet Stream (Base-2) ISO/IEC 2382 / IEEE | Est. 2015 | Radix & Byte Representation | 8-Bit Octet (Radix-2) | 8.000x (+700.0% in ASCII) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Bitwise mask verification, subnet prefix calculation, and 24-bit Base64 bit-boundary debugging | |
| Base58 Check & Bitcoin Alphabet Satoshi Base58 / IETF Draft | Est. 2016 | Binary-to-Text Encoding | ~5.858 Bits/Char (Radix-58) | 1.366x (+36.6%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Cryptocurrency wallet addresses, IPFS CIDv0 multihashes, and Flickr short URLs | |
| Base62 Pure Alphanumeric Encoding POSIX Alphanumeric Radix-62 | Est. 2017 | Binary-to-Text Encoding | ~5.954 Bits/Char (0–9, A–Z, a–z) | 1.343x (+34.3%) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | URL shorteners, compact database IDs (Base62 UUID), and double-click selectable tokens | |
| Base85 / Ascii85 (RFC 1924 & Adobe) Adobe PostScript / IETF RFC 1924 | Est. 2018 | Binary-to-Text Encoding | 4 Bytes to 5 ASCII Chars (Radix-85) | 1.250x (+25.0%) | Bijective Reversible URL-Safe: Requires Escaping | PDF stream compression, Git binary diffs, and ZeroMQ Z85 transport framing | |
| RFC 7519 JSON Web Token (JWT) Inspector IETF RFC 7519 | Est. 2019 | Cryptographic Identifiers | 3-Part Base64URL (Header.Payload.Sig) | 1.333x + JSON Schema | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Inspecting OAuth 2.0 / OIDC bearer tokens, exp/iat claims, and alg header parameters | |
| RFC 7468 PEM / ASN.1 DER Base64 Envelope IETF RFC 7468 / ITU-T X.690 | Est. 1996 | Binary-to-Text Encoding | 64-Column Line-Wrapped Base64 | 1.354x (+35.4% with CRLF) | Bijective Reversible URL-Safe: Requires Escaping | X.509 TLS certificates, RSA/ECDSA private keys, and CSR certificate signing requests | |
| RFC 3492 Punycode IDNA Bootstring IETF RFC 3492 / RFC 5891 | Est. 1997 | Binary-to-Text Encoding | Variable-Length Integer (xn-- Prefix) | ~1.150x Variable | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Internationalized Domain Names (IDN) translating Unicode hostnames to ASCII DNS labels | |
| POSIX Octal Base-8 Representation IEEE Std 1003.1 (POSIX) | Est. 1998 | Radix & Byte Representation | 3-Bit Triplet (Radix-8, 0–7) | 3.000x (3 Octal Digits/Byte) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Unix chmod file permissions (0755, 0644), C string escapes, and PDP-11/tar headers | |
| ROT13 / Caesar Alphabetical Shift Cipher Usenet RFC 1036 / Classical Shift | Est. 1999 | Telegraph & Signal Ciphers | Modulo-26 Alphabetical Rotation | 1.000x (0% Overhead) | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Symmetric text obfuscation (ROT13 self-inverse), CTF challenges, and classical cryptanalysis | |
| ITU-T ITA2 / Baudot-Murray 5-Bit Code ITU-T Rec. S.1 (ITA2) | Est. 2000 | Telegraph & Signal Ciphers | 5-Bit Code (LTRS / FIGS Shift) | 0.625x vs 8-Bit ASCII | Bijective Reversible URL-Safe: Requires Escaping | Radioteletype (RTTY), aviation AFTN teleprinter networks, and historical telegraphy | |
| IEEE 754 Floating-Point Hex Inspector IEEE Std 754-2019 | Est. 2001 | Radix & Byte Representation | 32-Bit (FP32) & 64-Bit (FP64) | Fixed 4 or 8 Bytes | Bijective Reversible URL-Safe: Yes (RFC 3986 Safe) | Debugging floating-point sign/exponent/mantissa bit layouts, Modbus registers, and WebGL buffers |
Base64, Hex & Cryptographic Decoder architectures rely on deterministic bit-stream partitioning defined in IETF RFC 4648. When our Base64 Image Decoder ingests an arbitrary binary buffer or multi-byte string via UTF-8 TextEncoder, the input stream of bytes is segmented into contiguous 3-byte blocks known as a 24-Bit Octet Quantum ( active quanta). Each 24-bit register is then sliced into four 6-bit unsigned integers ranging from 0 (000000) to 63 (111111), which index into the canonical 6-Bit Index Alphabet (A–Z, a–z, 0–9, +, /) yielding wire bytes.
When encoding inline raster graphics under the Data URI MIME Scheme (RFC 2397, such as data:image/png;base64,... or data:image/webp;base64,...), preserving exact byte alignment is critical. If the final input block contains only 1 octet (8 bits), the encoder zero-pads 4 trailing bits to form two 6-bit symbols and appends two 0x3D padding characters. If 2 octets (16 bits) remain, the encoder zero-pads 2 trailing bits to emit three 6-bit symbols and appends a single pad ( pad character in the active vector). Explore our Base64 Encoding Tools Tool & Guide, decode Base16 streams in our Hexadecimal & Binary Decoders, verify message integrity with the Cryptographic Hash Generators Tool & Guide, mint CSPRNG tokens in our UUID & GUID Generators, or inspect telegraph timing in the Morse Cipher Translators 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.
Standard Base64 maps index 62 to + and index 63 to /. Inside HTTP query parameters, RFC 3986 Percent-Encoding interprets + as a space and / as a path separator. RFC 4648 Base64URL substitutes - and _ and omits padding for JWT headers.
Calling window.btoa(str) directly on UTF-16 code units above 0xFF triggers a DOMException. Converting text into an ASCII Byte Stream or UTF-8 Uint8Array via UTF-8 TextEncoder guarantees lossless round-trip parity across CJK ideographs and emojis.
While Base64 expands payloads by 33.33%, the Base32 Alphabet (RFC 4648 §6, 5-bit quintets for TOTP seeds) expands payloads by 60.0%, and Hexadecimal Decoder streams using IEEE 754 Hexadecimal / Base16 nibbles expand binary buffers by 100.0% ( hex characters).
Reversible radix encodings provide transport serialization across 7-bit channels, so they must be paired with NIST FIPS 180-4 SHA-256 message digests or keyed HMAC-SHA256 Digest verification tags computed via browser-native Web Crypto SubtleCrypto primitives whenever cryptographic payload integrity and origin authentication are required across API boundaries.
During automated security audits, our Hash Identifier inspects hexadecimal nibble counts to flag deprecated 128-bit MD5 Message Digest checksums, while the companion token engine mints collision-resistant RFC 4122 UUID v4 identifiers seeded by 122 bits of hardware CSPRNG Entropy via crypto.getRandomValues(byteArray).
Formal IETF RFC 4648 quantum ceiling arithmetic, Base16 radix-16 expansion, ITU-R M.1677-1 Morse Code timing ratios, and NIST FIPS 180-4 SHA-256 bitwise compression 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. |
Executing deterministic binary-to-text transcoding across heterogeneous payloads requires strict adherence to three byte-boundary invariants: (1) normalize UTF-16 DOM strings into raw UTF-8 octets via TextEncoder(utf8) before applying 6-bit bitmask shifts; (2) strip MIME data:image/*;base64, headers and whitespace before validating modulo-4 quantum length; and (3) select the exact transport profile below, whether ITU-R M.1677-1 Morse Code via our Morse Code Decoder, URL-safe JWT headers, or 256-bit cryptographic digests.
In production web architecture, the most frequent failure mode during client-side Base64 decoding occurs when parsing multi-part MIME payloads or RFC 2397 Data URIs that include line breaks (CRLF, 0x0D 0x0A every 76 characters per RFC 2045). Our parser normalizes incoming byte streams by stripping non-alphabet whitespace prior to quantum verification, then reconstructs the exact 8-bit Uint8Array buffer so binary PNG headers (89 50 4E 47 0D 0A 1A 0A) and WebP RIFF containers decode without byte drift.
| 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 |
Furthermore, when auditing API payloads across microservice boundaries, engineers must distinguish between reversible radix encodings and one-way cryptographic message digests. Encoding a sensitive bearer token in Base64, Base32, or Base16 Hexadecimal provides transport compatibility across 7-bit ASCII channels but adds zero entropy against eavesdropping. Whenever payload authenticity is required, pair RFC 4648 serialization with a 256-bit NIST FIPS 180-4 SHA-256 digest computed locally in browser memory.
Inject verified Base64TLS certificates, JWT signing keys, and RFC 4122 UUID v4 tokens directly from 1Password Developer Vaults without plaintext .env files.
Deploy zero-cold-start crypto.subtle HMAC-SHA256 webhook verifiers and RFC 4648 Base64URL token routers across Cloudflare edge locations.
Pipe decoded hex packet dumps, Data URI MIME fixtures, and SHA-256 preimage assertions directly into JetBrains IntelliJ IDEA and GoLand test runners.
Compare MIME Data URI, JWT Base64URL, Wireshark Hexadecimal, and FIPS 180-4 SHA-256 operational profiles and load verified test vectors in one click.
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.
IETF RFC 4648 Section 4 divides every 24-bit input group (three 8-bit octets) into four 6-bit index values (4 * ceil(n / 3)). Because each 6-bit index is stored as a full 8-bit ASCII byte on the wire, 3 raw bytes expand into 4 encoded bytes, producing a deterministic 4/3 (1.3333x or +33.33%) size expansion before optional MIME CRLF line wrapping.
The native browser btoa(latin1Str) function only accepts Latin-1 (ISO-8859-1) code points 0x00 through 0xFF and throws an InvalidCharacterError on multi-byte UTF-8 characters. To encode arbitrary Unicode safely, convert the string into a Uint8Array via new TextEncoder(utf8).encode(input) before mapping octets into the 6-bit Base64 index alphabet, and reverse the process with new TextDecoder(utf8).
Standard Base64 includes "+" (index 62), "/" (index 63), and 0x3D padding, which collide with reserved URL query delimiters and filesystem path separators. RFC 4648 Section 5 Base64URL substitutes "-" (0x2D) for "+" and "_" (0x5F) for "/" while omitting trailing padding, making it mandatory for JSON Web Tokens (RFC 7519) and OAuth 2.0 PKCE code challenges.
No. Base64 (RFC 4648) and Hexadecimal (Base16) are public, reversible radix representations that require zero secret keys to decode. For payload integrity and tamper detection, compute a NIST FIPS 180-4 SHA-256 message digest or an RFC 2104 HMAC-SHA256 signature via the Web Crypto SubtleCrypto API.
Embedding raster or vector graphics via data:image/png;base64 or data:image/svg+xml eliminates separate HTTP request roundtrips, which reduces latency for micro-icons under 4,096 bytes. Above 4 KB, the 33.33% Base64 expansion penalty and inability to cache the asset independently across routes outweigh the single-request benefit.