Return to blog index Harry Otten 22 November 2021

QR Code Series: Encoding the data (Part 2)

In the previous blog of this series, we covered the basics of QR codes and their limits. In this second instalment, we will dive into the nitty gritty of fitting the most data possible into a QR code. We will look at the relation between the QR input method and URL encoding, the limits on the amount of data, and using some tricks to squeeze every bit out of a QR code.

Data gymnastics

Encoding an URL

In the first instalment, we established that binary data seems the most efficient way of inputting data for QR codes. The logical next step would be to encode it into an URL. Putting the data inside an URL is no problem, but keeping the URL valid presents a challenge. We can safely use A-Z, a-z, 0-9, and some special symbols. All-in-all, 71 characters are available inside a valid URL.

Calculating the fit


In summary, binary input gives us 256 unique values to work with and an URL can consist of at least 71 (10 + 26 + 26 + 3 unreserved and 6 reserved characters) unique characters. We then select base64 encoding to encode the data within the URL due to its fit within the 71 available characters within the URL. The constraint of 71 characters results in the following loss of bytes:

  • $\log_{256}256 \times 2953 = 2953$
  • $\log_{256}64 \times 2953 \approx 2214 $
  • $\log_{256}71 \times 2953 \approx 2270$

This results in a whopping 23 % loss due to the 71 character constraint and 56 unused bytes due to base64. Let's compare this to alphanumeric and see if we can do any better. The complete charset for alphanumeric QR input is:

Code Decoded Code Decoded Code Decoded Code Decoded
00 0 12 C 24 O 36 Space
01 1 13 D 25 P 37 $
02 2 14 E 26 Q 38 %
03 3 15 F 27 R 39 *
04 4 16 G 28 S 40 +
05 5 17 H 29 T 41 -
06 6 18 I 30 U 42 .
07 7 19 J 31 V 43 /
08 8 20 K 32 W 44 :
09 9 21 L 33 X
10 A 22 M 34 Y
11 B 23 N 35 Z

Luckily we have base45, which uses (you guessed it) 45 characters with 3 alphachars per 2 bytes. This gives $\log_{256}45 \times 4000 \approx 2745$ bytes. Compared to byte/bit input's 2270 bytes, alphanumeric has the clear advantage when encoding URLs.


While testing we quickly discovered that % and spaces break the URL quite easily on Android phones and should therefore not be used. To solve these problems in our project, we removed % and space from the characters. Leaving us with $\log_{256}43 \times 4000 \approx 2713$. The maths behind base45 can easily be altered to work with 4 characters less. Because $2^{16} = 65535$ and $41^3 = 68921$, so the encoding will fit anyway. However, you again lose some bytes in the process, and that is not what we want!

The 0-waste solution

We can imagine our QR code as one big number with a base of 43. We can generate this number from the bit stream of the data we want to encode into the QR code. As an example:

Binary data Base45 Integer (base10) ZEM Base43
The quick brown fox jumps over the lazy dog. 8UADZCKFEOEDJOD2KC54EM-DX.CH8FSKDQ
44 bytes 66 alphanumeric 106 numbers 65 alphanumeric

Every column contains the same data, but represented in a different way. Our base43 encoding outperforms default base45 by 1 character in this example.


In summary, the results of encoding data into an URL are the following for each of the bases:

QR Input Encoding Formula URL Length Real Data
Binary Base64 $2953 \div 4 \times 3$ 2953 2214
Alphanumerical Base45 $4000 \div 3 \times 2$ 4000** 2666*
Alphanumerical ZEM Base45 $\log_{45}\times 4000$ 4000** 2745*
Alphanumerical ZEM Base43 $\log_{43}\times 4000$ 4000** 2713

*Contains characters that break URLs
**Maximum characters scannable by iOS devices

This shows that ZEM Base43 maintains a clear advantage within the practical constraints of this exercise, gaining 47 bytes over base45 encoding. With these rules we can fit an absolute maximum of 2713 byes into a QR code while maintaining error correction and readability on all mobile devices. This might seem like a small improvement, but we must remember that off-the-shelve base45 is actually unsuited for URL composition due to the illegal characters. When comparing base64 (2214 bytes in a QR) to ZEM base43 (2713 bytes in a QR), our base43 implementation provides a clear and worthwhile implementation. If you would like to know more or want to get in touch with us, don't hesitate to mail us at