About

Base64 encoding inflates binary data by roughly 33%, producing strings of ASCII characters from the set A - Z, a - z, 0 - 9, +, /, and padding =. Embedding such strings directly into QR codes requires byte-mode encoding, which consumes 8 bits per character. A Version 40 QR symbol at error correction level L holds a maximum of 2953 bytes. Exceeding this silently truncates data or produces unreadable symbols in naive tools. This generator validates the Base64 input, computes Reed-Solomon parity using Galois Field GF(2⁸) arithmetic, evaluates all 8 mask patterns against the ISO/IEC 18004 penalty rules, and renders the optimal matrix to a downloadable PNG.

The decoded byte length is shown so you can verify payload integrity before scanning. Note: QR scanners on older devices may struggle with versions above 25. For large payloads, increase the error correction level to M or Q at the cost of reduced capacity. This tool approximates display only; actual scanner compatibility depends on camera optics and decoder firmware.

Formulas

QR codes use Reed-Solomon error correction over GF(2⁸) with the irreducible polynomial p(x) = x⁸ + x⁴ + x³ + x² + 1 (value 0x11D). The generator polynomial for t error correction codewords is:

g(x) = t−1∏i=0 (x − αⁱ)

where α = 2 is the primitive element. Each data codeword is 8 bits. For byte-mode encoding, the character count indicator length depends on the QR version:

{

8 bits if V ≤ 916 bits if 10 ≤ V ≤ 40

The mask penalty score S is evaluated as S = N₁ + N₂ + N₃ + N₄, where N₁ penalizes runs of 5+ same-color modules, N₂ penalizes 2×2 blocks, N₃ penalizes finder-like patterns, and N₄ penalizes color imbalance. The mask with the lowest S is selected.

Where V = QR version (1 - 40), t = number of EC codewords per block, α = primitive element in GF(2⁸), N_1..4 = penalty rule scores per ISO/IEC 18004.

Reference Data

QR Version	Modules	EC Level L bytes	EC Level M bytes	EC Level Q bytes	EC Level H bytes
1	21×21	17	14	11	7
2	25×25	32	26	20	14
3	29×29	53	42	32	24
4	33×33	78	62	46	34
5	37×37	106	84	60	44
6	41×41	134	106	74	58
7	45×45	154	122	86	64
10	57×57	271	213	151	119
15	77×77	520	412	292	220
20	97×97	858	666	482	364
25	117×117	1276	998	718	538
30	137×137	1732	1370	982	742
35	157×157	2306	1812	1306	986
40	177×177	2953	2331	1663	1273

Frequently Asked Questions

A Version 40 QR code at error correction level L holds a maximum of 2953 bytes. Base64 encoding inflates data by ~33%, so a 2953-byte Base64 string represents roughly 2215 raw bytes. If your input exceeds the capacity for the selected EC level, the tool will report the exact overflow in bytes and refuse to generate a corrupt symbol. Reduce the string length or switch to EC level L for maximum capacity.

Level L recovers ~7% damaged codewords, M recovers ~15%, Q recovers ~25%, and H recovers ~30%. Higher correction means more redundancy codewords, which reduces data capacity. For Base64 strings displayed on clean screens, level L is sufficient. If the QR will be printed on materials subject to wear (stickers, packaging), use Q or H. Each step up roughly halves the remaining data headroom at high versions.

Yes. The input is checked against the RFC 4648 Base64 alphabet (A-Z, a-z, 0-9, +, /) with optional = padding. The tool also attempts atob() decoding. If the string contains illegal characters or has incorrect padding length (not a multiple of 4 after trimming whitespace), a specific error is shown. Whitespace and newlines are stripped before validation, matching standard PEM/MIME behavior.

ISO/IEC 18004 specifies 8 mask patterns. Different generators may select different masks or use different optimization strategies. This tool evaluates all 8 masks and selects the one with the lowest penalty score as required by the standard. The encoded data is identical; only the visual XOR pattern differs. Any compliant scanner will decode all valid masks identically.

This tool encodes the literal Base64 ASCII string into the QR code using byte mode. The scanner will return the Base64 text, which the receiving application must then decode. If you need to encode raw binary, you would first Base64-encode it (which is what this tool expects as input), producing a scannable text representation that any system can decode back to binary.

Each module (the smallest square unit) should be at least 0.33mm in print for reliable scanning at normal distances. On screen, 4-8 pixels per module works well. For high-version QR codes (Version 20+), use a larger module size to ensure the overall image is large enough. The quiet zone (4-module white border) is automatically included in the generated image.