About

Base36 encodes data using 36 symbols (0 - 9, A - Z) and is common in URL shorteners, tracking codes, and compact identifiers. Base64 encodes arbitrary binary data into 64 printable ASCII characters per RFC 4648 and is the standard for embedding data in JSON, emails (MIME), and data URIs. Converting between them requires an intermediate arbitrary-precision integer representation because both are positional encodings over different radices. A manual conversion error - dropping a character, mishandling padding - silently corrupts data with no checksum to catch it. This tool converts through a BigInt intermediary: Base36 string → BigInt → byte array → Base64 (and the reverse path). It handles arbitrary input lengths, validates charset before processing, and applies correct = padding per the RFC. Note: this tool treats the input as a single large integer in the source radix. It does not interpret Base36 as raw UTF-8 text.

Formulas

The conversion pipeline relies on positional numeral expansion and base-change arithmetic through an arbitrary-precision integer intermediary.

Base36 string → BigInt (decoding):

N = n−1∑i=0 d_i ⋅ 36ⁱ

where d_i is the digit value at position i from the right (0 - 9 → 0 - 9, A - Z → 10 - 35).

BigInt → byte array:

Extract 8-bit chunks by repeated bitwise AND with 0xFF and right-shift by 8. Reverse the resulting array to get big-endian byte order.

Byte array → Base64 (encoding per RFC 4648):

Group bytes into 3-byte (24-bit) blocks. Split each block into four 6-bit indices. Map each index to the Base64 alphabet: A - Z (0 - 25), a - z (26 - 51), 0 - 9 (52 - 61), + (62), / (63). Pad with = if the last block has fewer than 3 bytes.

Reverse path (Base64 → Base36):

Decode Base64 to bytes (reverse lookup, strip padding), bytes to BigInt (big-endian accumulation), BigInt to Base36 by repeated divmod(36):

N = q ⋅ 36 + r, where r maps to the Base36 digit. Repeat until q = 0. Reverse collected digits.

where N = arbitrary-precision integer, n = number of input characters, d_i = digit value at position i, q = quotient, r = remainder.

Reference Data

Property	Base36	Base64 (RFC 4648)
Radix	36	64
Alphabet	0 - 9, A - Z	A - Z, a - z, 0 - 9, +, /
Padding	None	= (1 or 2 chars)
Case Sensitive	No (case-insensitive)	Yes
Bits per Character	≈ 5.17 bits (log₂36)	6 bits exactly
Efficiency vs Binary	64.6%	75%
Common Uses	URL shorteners, Reddit post IDs, NanoID	MIME email, Data URIs, JWT, PEM certs
Standard	No formal RFC	RFC 4648, RFC 2045
Whitespace Handling	Not allowed	Ignored per RFC 2045 (MIME)
URL-Safe Variant	Inherently URL-safe	Base64url: - and _ replace + and /
Max Value in 6 chars	2,176,782,335 (36⁶ − 1)	Encodes 4.5 raw bytes
Encoding Direction	Integer → string	Bytes → string
Null / Zero	0	AA== (single zero byte)
Leading Zeros	Significant (changes value)	Significant (maps to 0x00 bytes)
Example: decimal 255	73	/w==
Example: decimal 1000000	LFLS	D0JA

Frequently Asked Questions

Base36 is a positional numeral system, not a character encoding. The string "HELLO" in Base36 represents the integer 29,234,652 (H×36⁴ + E×36³ + L×36² + L×36¹ + O×36⁰). Converting it to Base64 means encoding that integer's binary representation as Base64 bytes. Character-by-character mapping would be arbitrary and non-standard.

In Base36, leading zeros change the implied magnitude (e.g., "0A" and "A" represent the same integer 10, but "0A" as a string includes a positional zero that this converter preserves as a leading null byte). In Base64, the padding character "=" is structural (not a leading zero) and indicates the final block had fewer than 3 bytes. The converter preserves leading zeros by tracking them and prepending corresponding 0x00 bytes before Base64 encoding.

The converter accepts inputs up to 100 KB of text. JavaScript's native BigInt handles arbitrary-precision integers, so mathematical overflow is not a concern. The practical limit is browser memory and processing time. Inputs beyond approximately 50,000 characters may take a few seconds to convert due to the O(n²) nature of BigInt string parsing in some engines.

No. The converter outputs standard Base64 per RFC 4648 Section 4, which uses "+" and "/" characters. These are not URL-safe. If you need Base64url (RFC 4648 Section 5), manually replace "+" with "-" and "/" with "_", and optionally strip "=" padding from the output.

Yes, the conversion is lossless and fully reversible. Converting Base36 → Base64 → Base36 will return the original string (uppercased, since Base36 is case-insensitive). The intermediate BigInt representation preserves the exact numeric value. One caveat: leading zeros in the original Base36 input are preserved through null-byte tracking, so "00AB" will round-trip correctly.

Base64 padding ensures the output length is always a multiple of 4 characters. A short Base36 string like "1" equals the integer 1, which is a single byte (0x01). One byte encoded in Base64 produces 2 data characters plus 2 padding "=" characters: "AQ==". This is correct per the RFC specification.