The short answer
A QR code that looks crisp on screen can still fail on paper, because print adds three things a screen never does: fixed size, ink spread, and real-world lighting. Printing a QR code that scans reliably comes down to a handful of print-specific choices that a screen-only generator never forces you to make. Get these right and the printed code scans on the first try; skip them and you can print a thousand copies of a code no phone will read.
The recipe: export a vector file (SVG or EPS) so the code scales to any print size without pixelation, or a raster PNG at 300 dpi at the final printed size if vector is not an option. Size the code for the distance people will scan it from using the 1/10 scan-distance rule. Set error correction to level H so the code survives wear, folding, and a centered logo. Keep a quiet zone of at least 4 modules (about 4 mm on a typical small print) of empty margin on every side. Print dark modules on a light background on matte — not glossy — stock. Then print one proof at the final size and scan it from the real distance before you commit to the run. This page walks through each step; for the broader design rules, see our qr best practices guide and our qr code design guide.
Always use vector, or a 300+dpi raster
A QR code is a grid of squares, and grids are exactly what vector formats are built for. Export the code as SVG or EPS and it scales to a business card or a billboard with no quality loss — the printer rasterizes it at its own resolution at print time, so every module edge stays razor-sharp. This is the single biggest print-quality lever, and it costs nothing. Our how to make a QR code guide covers the export step in the generation flow.
If you must use a raster image (a PNG dropped into a non-vector workflow, or a screenshot), the rule is resolution at the final printed size, not on screen. A PNG that looks sharp at 800 px on a monitor becomes a soft, blurry grid when it lands at 5 cm on a business card, and blurry module edges are the fastest way to kill a scan. Generate the PNG at the pixel dimensions the printer needs at 300 dpi: for a 5 cm (~2 inch) code that is about 600 px, for a 10 cm (~4 inch) code about 1200 px. Round up, never down.
Resolution for print: the 300 dpi rule
DPI (dots per inch) only means something relative to the physical print size. The number that matters is the final pixel count: printed width in inches times 300, rounded up. A code printed at 3 inches across wants roughly 900 px; the same code printed at 6 inches wants roughly 1800 px. Below 300 dpi the module edges start to soften and small or dense codes fail to scan; above 300 dpi there is no meaningful gain, so do not waste file size on 600 dpi exports.
One trap: scaling a low-resolution raster up in your layout software does not add detail — it just stretches the same blurry pixels. If the source PNG is too small, regenerate it at the right size from the QR tool rather than enlarging it in the design file. Vector export sidesteps the entire problem, which is why vector is the default recommendation for print.
Size the code for the scan distance
The size of a printed QR code is not a design choice — it is set by the distance people will scan it from. The rule of thumb is the 1/10 scan-distance rule: the printed code width should be about one tenth of the distance it will be scanned from. A code on a table tent scanned from 50 cm wants at least about 5 cm across; a code on a poster scanned from 2 m wants at least about 20 cm. Round up for difficult lighting, glossy stock, or older phone cameras. Our qr code size guide has recommended minimum sizes for every common placement.
Density compounds with size: a long URL forces a higher QR version with a denser grid, and a dense grid needs to print larger to keep each module big enough for a camera to read. Keep the payload short (use a short link) so the version stays low, then size for the scan distance. A small, dense code is the worst print case; a larger, sparser code is always safer.
Error correction: level H for print
Printed codes take abuse that screen codes never do — they get scuffed, folded, splashed, half-torn off a wall, and printed over seams or curved surfaces. Error-correction level H adds about 30% redundant data so the code still scans when part of it is damaged, which is exactly the resilience print demands. Level H is also mandatory the moment you add a centered logo, because the logo covers part of the data area and the redundancy has to absorb it.
The trade-off is density: level H makes the grid denser for the same payload, which can push the version up and require a larger print. Keep the payload short and the print sized for the scan distance and the cost of level H disappears; the resilience is free. Level M (about 15% recovery) is fine for clean, protected surfaces with no logo, but for anything that will be handled or weathered, default to H. Our qr error correction guide covers the L/M/Q/H trade-off in depth.
Quiet zone: keep at least 4 modules empty
The quiet zone is the empty margin around the code, and on print it has to be measured in real units, not just modules. Keep at least 4 modules of clear space on every side — on a typical small print that is about 4 mm, and larger for bigger codes. Scanners need that blank border to locate the three finder patterns in the corners; without it the camera cannot frame the code and will not decode, no matter how clean the pattern inside is.
On print the quiet zone is eaten most often by design: a border running right up to the modules, a caption tucked into the margin, a background photo bleeding under the edge, or the code butted against the edge of a card or label. Keep the quiet zone genuinely empty — nothing printed in it, not even a thin keyline — and let any frame sit outside the quiet zone, not on top of it. Our qr best practices guide covers the quiet zone rule in the broader scannability context.
Color and contrast for print
Print color is where screen designs most often break, because ink on paper behaves differently from pixels on a monitor. The safe default is unchanged: dark modules on a light background, with strong contrast. Near-black on near-white is bulletproof; a deep navy or dark teal on off-white also scans well. Inverted codes (light modules on a dark square) look striking but most phone cameras in most lighting reject them, and low-contrast pastel-on-white fails on print just as it fails on screen — only more so, because print contrast is usually lower than monitor contrast.
Two CMYK pitfalls catch print buyers. First, a “rich black” built from all four ink channels can shift slightly on misregistration, softening module edges on a tight grid; for the crispest small codes, a single-channel black (100% K) for the dark modules keeps edges clean. Second, light tints of a brand color can render lighter on uncoated stock than on the proof, dropping contrast below the scan threshold. Generate the code, proof it on the actual stock, and scan it in the real lighting before you commit. Avoid gloss: a glossy laminate or coating throws a glare band that the phone flash reads as a destroyed stripe — see the material section next.
Material matters: matte, flat, and durable
The surface you print on affects scannability as much as the artwork. Matte stock is safer than glossy: a glossy laminate or coating reflects the camera flash as a bright stripe across the code, which the scanner reads as a destroyed band of modules. If a gloss finish is required by the brand, angle-proof it under the lighting it will actually be scanned in, and consider a matte spot-varnish over just the QR area.
Flat surfaces scan better than curved or folded ones. A code wrapped around a bottle or printed across a fold is partially distorted from the camera’s point of view; place the code on the flattest, most face-on part of the item, and never let a fold line run through the pattern. For codes that will live outdoors or be handled a lot, choose a durable stock or overlaminate and pair it with level H so scuffs do not brick the code. Lamination itself is fine as long as it is matte.
Test the print proof before the run
The last step is the one most skipped: print one proof at the final size, on the final stock, place it where it will live, and scan it from the real distance with more than one phone. A code that scans on a bright monitor can fail on matte paper under restaurant lights, or shrunk to its final size, or once the gloss laminate adds a glare band. A one-proof test takes a minute and catches all of it before you print a thousand.
Run the full validation pass: decode the image back to text and confirm the payload round-trips exactly, scan on at least one iPhone and one Android (ideally one older device), check the contrast and quiet zone by eye in the real lighting, and for a batch from CSV decode a sample of the output images. Our qr code validation guide is the full test pass, and our common QR code mistakes guide is the troubleshooting table if a proof will not scan.
Print checklist at a glance
Here is the whole print recipe in one table, with what to do and why each step matters. Work top to bottom; if the proof fails a scan, walk back through the list and change one variable at a time.
| Print step | What to do | Why it matters |
|---|---|---|
| File format | Export vector SVG or EPS; if raster, PNG at 300 dpi at the final printed size | Vector scales to any size with sharp module edges; low-res raster blurs the grid and kills the scan |
| Resolution | Raster at printed width in inches × 300 dpi, rounded up | Below 300 dpi module edges soften; above it there is no useful gain |
| Size | Print width ≈ scan distance ÷ 10, rounded up for hard conditions | A code too small for its scan distance is the most common print failure |
| Error correction | Level H, especially with a logo or for worn/outdoor codes | About 30% redundancy absorbs wear, folding, and the area a logo covers |
| Quiet zone | At least 4 modules (≈4 mm on small prints) of empty margin on every side | The scanner needs blank border to frame the finder patterns; borders or captions in it break the decode |
| Color & contrast | Dark modules on light background, strong contrast, single-channel black for crisp edges | Inverted or low-contrast codes fail on print; rich-black misregistration softens edges |
| Material | Matte not glossy, flat not curved, durable stock for handled/outdoor codes | Gloss glare destroys a stripe of modules; folds and curves distort the pattern |
| Proof test | Print one at final size on final stock, scan from the real distance on 2+ phones, decode the payload | Catches size, contrast, glare, and payload errors before the full run |
Frequently asked questions
How do I print a QR code?
Export the code as a vector SVG or EPS (or a PNG at 300 dpi at the final printed size), size it to about one tenth of the scan distance, set error correction to level H, keep at least a 4-module quiet zone of empty margin, print dark-on-light on matte stock, then print one proof at the final size and scan it from the real distance on more than one phone before committing to the run.
What format is best for printing a QR code?
Vector — SVG or EPS. A vector file scales to any print size with perfectly sharp module edges, because the printer rasterizes it at its own resolution. If you must use a raster image, generate the PNG at 300 dpi at the final printed size (printed width in inches × 300, rounded up); never scale a small PNG up in your layout software.
Can I add a logo to a QR code I am printing?
Yes. Keep the logo to about 20–22% of the code width, center it, never let it overlap the three finder eyes in the corners, and generate the code at error-correction level H so the roughly 30% redundancy absorbs the covered data area. Keep the payload short, because level H makes the grid denser, and proof-test the print before the run.
Why does my QR code scan on screen but not on the printed version?
Usually one of: the print is too small for the scan distance, the raster export is below 300 dpi so module edges blurred, the quiet zone is eaten by a border or caption, the contrast dropped on the actual stock, a glossy finish is throwing a glare band, or a fold runs through the pattern. Print one proof, walk the print checklist, change one variable at a time, and re-scan.