Why a QR code that scans fine on screen fails once it's printed

A QR code that opens fine on your screen can fail once you print a QR code business card, and the cause is almost never the phone. It's usually the quiet zone (the blank border around the code), low contrast between the ink and the card stock, or a module size too small for the print resolution: three things a screen preview can't show you.

We build the QR codes behind Nameplate's digital business cards, and we went looking at our own output while writing this because a printed test card wasn't scanning as reliably as the on-screen version. It scanned instantly on a laptop at arm's length. Printed on a standard 3.5" × 2" card and handed across a table, it needed two or three tries. Nothing about the underlying link had changed.

What's actually inside the code

A QR code is a grid of black and white squares called modules, arranged around three big corner squares (finder patterns) that tell a scanner where the code starts and which way is up. How many modules you get depends on two things: how much data you're encoding, and how much error correction you've asked for.

Denso Wave, the company that invented the QR code and maintains the spec, documents four error correction levels (L, M, Q, and H), each trading code density for damage tolerance. Level M, the one most tools default to, restores about 15% of the data if part of the code is dirty, torn, or obscured. A URL like https://www.nameplate.cc/v/anna fits into a fairly sparse grid at that level. Cram an entire vCard's worth of fields into the same code instead of a short URL, and the grid gets denser and less forgiving, which is one reason we point our cards at a page URL and let the .vcf download live behind a button, rather than encoding the vCard directly. We wrote about that decision in more detail in our post on cards that stop saving to contacts.

Two mistakes we found in our own QR codes

This is the part a style guide can't fake, so we went and checked our own code instead of guessing. Nameplate generates QR codes in two places, and they don't use the same settings:

• The free QR code generator tool sets margin: 2 (2 modules of quiet zone) and errorCorrectionLevel: "M", rendered at 512px.
• The QR codes attached to a saved card in the dashboard set margin: 1 and a background color of #f2eadc, a warm cream, not pure white, rendered at 320px.

Both are narrower than the library's own default. The qrcode npm package we use falls back to a 4-module quiet zone when you don't set one, and the spec agrees: ISO/IEC 18004 requires a clear margin of at least four modules on every side of the symbol. The quiet zone isn't decorative, it's how a scanner's software tells the difference between "this is a QR code" and "this is part of a busier design," and shrinking it is exactly the kind of thing that looks fine at 100% zoom on a monitor and gets worse the smaller you print.

The cream background is a smaller issue on its own, but it stacks with a narrow quiet zone: less contrast between the code and its border makes the finder patterns marginally harder to lock onto, especially under uneven print lighting or a slightly worn card. Neither setting was a deliberate scannability decision. One was picked for a tighter layout on the dashboard, the other for a cleaner look on a light background, and neither had been tested printed until we did it for this post. If you're printing a card's QR code for a run of any size, don't trust the default margin from any tool, ours included: check the printed result at the size you're actually using, not the on-screen preview.

If you just need a code for a link, our QR code generator tool is free and doesn't require an account: paste a URL, download a 512px PNG at a fixed 2-module quiet zone and error correction level M, no sign-up. It doesn't expose margin or color controls, so if you need a different quiet zone or a non-default color, generate the code with a tool that lets you set those and test the print yourself rather than trusting any default, ours included.

Why smaller print sizes make this worse

A QR code doesn't have a fixed physical size. It has a module count, and printing shrinks or grows the physical size of each module. A standard US business card is 3.5" × 2" (Vistaprint's own size guide uses the same dimensions, and it's the de facto US default). If a code with, say, a 25×25 module grid gets printed at 0.6 inches square to leave room for a logo and contact text, each module is roughly 0.024 inches, close to the resolution limit of a typical office inkjet or a cheap print run, where ink can bleed and merge adjacent modules together. The same grid printed at 1 inch square gives each module noticeably more room, with margin to spare for minor print drift.

This is also where "qr code with logo" (a real search query, and a common request) gets risky. A logo placed over the center of the code covers data modules, which is why it only works at all because of error correction. At Level M you have roughly 15% of the code to spare, and a large or off-center logo can eat past that budget. If you want a logo, keep it small, centered, and test the printed result before ordering a full batch. Don't assume the on-screen preview generalizes to ink on card stock.

A two-minute print test before you order 500 cards

1. Print one card at actual size on the same paper stock (or as close as you can get) you'll use for the real run.
2. Scan it from about arm's length, in normal indoor light, not backlit by a screen and not six inches from a desk lamp.
3. Scan it again from a slight angle, the way someone glances at a card handed to them rather than holding it flat.
4. If it hesitates or fails, increase the printed size first, then check contrast (dark code on a genuinely light background, not a tinted one), then check quiet zone before you touch error correction level.
5. Only raise the error correction level if you need to add a logo or expect the card to get scuffed. Higher levels make the grid denser for the same data, which can offset the benefit if it forces a smaller module size on a fixed card size.

What this doesn't fix

None of this rescues a QR code encoding too much data for its printed size. If you need dense data (a full vCard, a long survey URL with tracking parameters) on a small physical code, the honest fix is a shorter URL and a page that expands from there, not a higher error correction level. And no quiet zone or contrast setting compensates for a scanner app that's genuinely bad at low light; if a card fails to scan for one person and works for everyone else, it's sometimes their phone's camera, not your print.

Common questions

What is the standard business card size?

In the US, 3.5" × 2" (89mm × 51mm) is the near-universal default, used by major print shops including Vistaprint. Most other countries use a slightly different standard size, so if you're printing internationally, check the local convention before you lay out a QR code that assumes US dimensions. A code sized for a US card can end up too close to the edge on a narrower international card.

Does putting a logo in a QR code stop it from scanning?

Not by itself, but it uses up part of the error correction budget your QR code has for damage and dirt. At the default Level M (about 15% recoverable), a small centered logo usually leaves enough margin to still scan reliably. A large logo, one placed off-center, or one added on top of a code already using a higher error correction level for other reasons, is more likely to push a scan into "sometimes works" territory. Test the actual printed logo placement rather than trusting a generator's live preview.

How do I read a QR code without an app?

Most modern phones don't need a separate app: iOS and recent Android versions can scan a QR code directly from the built-in camera app, and will show a notification or banner with the link rather than opening a scanner interface first. If your phone doesn't do this natively, most photo or messaging apps have an in-app scanner, and it's rarely necessary to install a dedicated third-party scanner just to open a link.

What does a QR code's error correction level actually mean?

It's how much of the code's data can be damaged, dirty, or obscured and still be read correctly. Denso Wave's own documentation lists four levels — L, M, Q, and H — with M (about 15% recoverable) as the one most generators default to and the one that fits most everyday uses. Raising the level makes the code more resistant to damage but also makes the grid denser for the same underlying data, which can force a smaller module size if you're printing at a fixed physical size.

Why does a QR code that works on my phone fail on someone else's?

Usually distance, light, or a slower autofocus on an older camera. Your own phone has probably scanned that exact code a dozen times from a comfortable distance with the screen at full brightness. A stranger scanning a printed card at a networking event is dealing with worse light, a less steady hand, and a camera that's never seen that specific code before. Test the printed version the way a stranger would use it, not the way you use it while designing it.