How Big Should a QR Code Be for Print? A Size Guide by Material

The one rule that sizes any QR code

QR codes have been an open standard since Denso Wave's engineer Masahiro Hara published them in 1994, and the physics of scanning one has not changed since. A phone camera has to resolve the little black and white squares (called modules) clearly enough to tell them apart. Print the code too small and the camera gives up.

One rule does most of the work here. The 10:1 rule: a QR code scans reliably from about 10 times its own width away. Flip that around and you get the only sizing formula you need.

Minimum size = scan distance / 10.

If someone scans from 10 inches away, the code needs to be about 1 inch wide. If they scan from 10 feet, it needs to be about a foot. Decide how far your reader will realistically stand, divide by 10, and you have your floor. That is it. Everything else in this guide is just applying that one line to real surfaces.

The small end has a floor, though. Below roughly 0.8 x 0.8 inches (2 x 2 cm), codes start failing even at close range, so treat that as a hard minimum for anything held in the hand. Codes printed under an inch fail more than codes at 2 inches or bigger, so if you have the room, give the code room.

Recommended QR code size by material

Here is the table I wish existed when I started printing these. Every row is the 10:1 rule applied to a realistic scan distance for that surface, then rounded up for safety. The sizes are for the printed code itself, not counting the blank margin around it (more on that below). Treat them as minimums. Bigger is always safer.

A quick sanity check on the extremes: a 2 x 2 inch code scans from roughly 2 feet, and an 8 x 8 inch storefront code scans from 6 to 7 feet. Both land right on the 10:1 line. If your scan distance is not in this table, do not guess. Divide it by 10.

The pixel math before you export

DPI (dots per inch) is how many ink dots fit in an inch of print. For a QR code read up close, aim for 300 DPI. That is the standard sharpness for business cards, flyers, menus, and packaging.

The math is simple, and worth doing before you export anything:

Pixels needed = printed inches x DPI.

A 1 inch code at 300 DPI needs a 300 x 300 pixel image. A 2 inch code needs 600 x 600. A 4 inch poster code needs 1200 x 1200. Export smaller than that and the printer stretches your pixels, the module edges blur, and scans get flaky.

Two ways to skip the pixel math. First, for big-format work seen from several feet (posters, banners, billboards), 150 DPI is fine, and 72 DPI is acceptable at true billboard distance, because nobody inspects a billboard from six inches. Second, and this is what I would do, export a vector SVG instead of a raster PNG. A vector file has no fixed pixel count. It stays sharp at any size, so the same file works on a business card and a bus wrap. The tool I built exports PNG up to 4000px and true vector SVG for exactly this reason (generate one here). One more rule: never save a QR code as a JPEG. JPEG compression smears the sharp edges that scanners depend on. PNG or SVG only. If you want to weigh the formats first, the rest of the guides go deeper on PNG versus SVG.

Why a longer link forces a bigger print

Not every QR code is equally dense, and density changes the size you need. The more data you cram in, the more modules the code needs, and the smaller each module gets at a fixed print size. A code can range from Version 1 (a 21 x 21 grid) up to Version 40 (177 x 177), gaining 4 modules per side at each step. A short link might sit at Version 3. A long URL stuffed with tracking parameters can push it much higher, which means far more tiny squares packed into the same square inch, and a code you have to print bigger to keep scannable.

Two moves keep your code sparse and forgiving:

• Keep the destination short. Point at a clean URL. Every character you drop is fewer modules and a code that scans smaller.
• Static keeps it honest. Because this tool encodes the destination straight into the pattern with no redirect, nothing pads the link out behind your back. What you type is what gets encoded.

A center logo works with this, not against it. Every QR code carries built-in error correction, with four levels that let a scanner recover from roughly 7% up to 30% of the code being obscured, so a modest logo over the middle still reads. Push the logo too big, though, and you spend the margin you needed for real-world scuffs and glare. I put the safe limits in the logo size guide.

The quiet zone people delete

The most common reason a technically valid code will not scan is a missing margin. The QR standard (ISO/IEC 18004) requires a quiet zone: a blank border at least 4 modules wide on every side. Scanners use that clear space to find where the code starts and stops. Crowd text, a logo, or a photo right up against the edge, and a perfect pattern can still fail.

Four modules is not a fixed number of millimeters. It scales with the code. If each module prints at 1 mm, your margin is at least 4 mm. Any decent generator adds this for you, but designers routinely crop it off to make a layout fit. Do not let them. That white space is doing a job.

Test-scan before the full run

Every size in this guide is a starting point, not a promise. Paper stock, ink bleed, lamination glare, curved surfaces, and cheap phone cameras each shave a little reliability off the top. So before you commit to a full run, do the one thing that costs almost nothing.

Print a single proof at the real final size, tape it where it will actually live, and scan it. Use a couple of different phones. Try it in the lighting your reader will have, from the distance they will stand. If it reads clean in under two seconds, you are done. If it hesitates, bump the size up about 20% and test again. Catching this at the proof stage costs you one sheet of paper. Catching it after 5,000 flyers are boxed costs you the whole run.

FAQ