About

Base64 encoding represents binary data using 64 printable ASCII characters. Base26 uses only the 26 uppercase Latin letters (A - Z), where each letter maps to a value from 0 to 25. Converting between these systems requires interpreting the Base64 payload as a raw byte sequence, accumulating those bytes into an arbitrary-precision integer, then performing iterative division by 26 to extract letter positions. Precision loss is the core risk: naive implementations using IEEE 754 floats silently corrupt data beyond 2⁵³. This tool uses JavaScript's native BigInt to guarantee lossless conversion at any input length. Note: the conversion treats the decoded byte stream as a single unsigned integer. Padding bytes (=) in Base64 are handled by the standard atob decoder and do not appear in the output.

Formulas

The conversion pipeline follows three stages. First, decode the Base64 string into a sequence of raw bytes B₀, B₁, …, B_n−1 using the standard atob function.

N = n−1∑i=0 B_i ⋅ 256ⁿ⁻¹⁻ⁱ

This accumulates all bytes into one large unsigned integer N using base 256 positional notation. The tool uses native BigInt for this step to avoid floating-point truncation.

N = q ⋅ 26 + r, r ∈ {0, 1, …, 25} → letter = chr(65 + r)

Repeated Euclidean division by 26 extracts remainders. Each remainder maps to a letter: A = 0, B = 1, …, Z = 25. Collect remainders in reverse order to form the Base26 string.

Where: N = accumulated integer from byte stream, B_i = i-th byte value (0 - 255), n = total byte count, q = quotient, r = remainder. Output length is approximately n ⋅ log(256)log(26) ≈ 1.7 ⋅ n characters.

Reference Data

Base26 Letter	Decimal Value	Binary (5-bit)	Base64 Chars (for reference)
A	0	00000	A (idx 0)
B	1	00001	B (idx 1)
C	2	00010	C (idx 2)
D	3	00011	D (idx 3)
E	4	00100	E (idx 4)
F	5	00101	F (idx 5)
G	6	00110	G (idx 6)
H	7	00111	H (idx 7)
I	8	01000	I (idx 8)
J	9	01001	J (idx 9)
K	10	01010	K (idx 10)
L	11	01011	L (idx 11)
M	12	01100	M (idx 12)
N	13	01101	N (idx 13)
O	14	01110	O (idx 14)
P	15	01111	P (idx 15)
Q	16	10000	Q (idx 16)
R	17	10001	R (idx 17)
S	18	10010	S (idx 18)
T	19	10011	T (idx 19)
U	20	10100	U (idx 20)
V	21	10101	V (idx 21)
W	22	10110	W (idx 22)
X	23	10111	X (idx 23)
Y	24	11000	Y (idx 24)
Z	25	11001	Z (idx 25)
Base64 Alphabet (for reference)
Indices 0 - 25		A - Z
Indices 26 - 51		a - z
Indices 52 - 61		0-9
Index 62		+
Index 63		/
Padding		=

Frequently Asked Questions

Base64 uses 64 symbols per position, packing ~6 bits per character. Base26 uses only 26 symbols (~4.7 bits per character). To encode the same amount of information, Base26 requires more characters. Specifically, the output length scales by a factor of approximately log(256) / log(26) ≈ 1.70, meaning each original byte needs ~1.7 Base26 letters.

Yes. The tool preserves leading zero bytes by encoding the original byte length alongside the integer value. When converting back from Base26 to Base64, the byte length metadata ensures the reconstructed byte stream matches the original exactly, including any leading null bytes that would otherwise be lost during BigInt conversion.

Standard Base64 uses + and / as indices 62 and 63. URL-safe Base64 (RFC 4648 §5) replaces these with - and _. This tool expects standard Base64. If you paste URL-safe Base64, replace - with + and _ with / before converting. The tool will reject invalid characters and display a validation error.

An empty string decodes to zero bytes, yielding the integer 0. By convention, 0 in Base26 maps to the single letter A. Converting A back yields an empty Base64 string. This edge case is handled explicitly in the algorithm.

This is a client-side encoding tool. No data leaves your browser. However, Base26 is not encryption - it provides no confidentiality. Anyone who knows the encoding scheme can reverse it trivially. For cryptographic applications, use proper encryption (AES-256, RSA) before encoding. Base26 is useful for environments that accept only alphabetic characters, such as certain legacy systems or manual transcription scenarios.

JavaScript BigInt has no fixed upper limit - it grows with available memory. In practice, inputs up to several kilobytes of Base64 (producing tens of thousands of Base26 letters) convert in under 100 ms on modern hardware. Beyond ~50 KB of Base64, performance may degrade due to BigInt division overhead. The tool will warn you if processing takes longer than expected.