Why Is My QR Code Not Scanning? Troubleshooting Guide

Most QR codes fail to scan because of three issues: insufficient quiet zone (white border), low contrast between modules and background, or an expired dynamic link — check these in order before assuming your code is broken.

Those three causes account for the large majority of real-world scan failures, but they're rarely presented as an actual diagnostic sequence — most guides on this topic list a dozen-plus possible causes as a flat, unordered checklist, leaving you to guess which one actually applies to your situation. This guide is built the other way around: start with a 60-second sanity check that tells you whether the problem is your code or your phone, then work through a symptom-based decision tree, then get the exact numbers — quiet zone in millimeters, a measurable contrast threshold, and the real reasons dynamic codes stop working — for the causes that turn out to be the actual culprit.

Whether you're troubleshooting a single code right now or setting up a process to catch failures before a large print run goes out, the sequence below is designed to be worked through top to bottom, in order, rather than treated as a menu to skim for the one item that sounds familiar.

Quick Diagnosis: Is It Your Code or Your Device?

Before troubleshooting the code itself, rule out the simplest explanation: something wrong with the phone or scanning app, not the code. This is a two-minute check most people skip, and skipping it is why "fixes" sometimes don't fix anything — because the code was never the problem.

1. Scan a QR code you already know works — a code on a product package, a previously-successful scan, or any QR code generator's own homepage example — on the same phone, in the same way you're trying to scan yours. If that known-good code also fails, the problem is your device or scanning app, not your code. Jump straight to the Device & Scanning Technique Issues section below.
2. If the known-good code scans fine but yours doesn't, check the quiet zone first — it's the fastest thing to verify and the single most common cause of a code that fails on every device at once. See the mm table below.
3. Then check contrast — hold the printed code at a slight angle and in different lighting; if it scans under bright even light but not under mixed or dim lighting, contrast is marginal.
4. Then check size relative to scanning distance — a code that only scans from very close, but not from the distance people naturally hold their phone at, is undersized for that use. See this site's minimum size guide for the exact distance-to-size numbers.
5. Then verify the destination manually — copy the URL the code encodes (most scanner apps show it before opening) and paste it directly into a browser. If it doesn't load there either, the code isn't the problem; the destination is.
6. Then check whether it's a dynamic code with a lapsed subscription or deleted destination — this is the cause most often missed, because the code scans successfully (it's a valid, undamaged pattern) but redirects nowhere useful.
7. Finally, check for a logo or heavy customization without adequate error correction — a code that scanned fine before a logo was added, and fails after, has an error-correction mismatch, not a printing defect.

This order matters because it moves from cheapest-to-check to most-involved-to-fix, and because roughly the first three steps resolve the overwhelming majority of real-world cases. This priority ordering reflects common troubleshooting logic and scanning mechanics rather than a published failure-rate statistic — no public dataset breaks down QR scan failures by root cause with this level of granularity, so treat the order as practical guidance, not an official ranking. It's built to match how these failures actually cluster in practice: structural problems (quiet zone, size, distortion) tend to break a code on every device at once, while marginal problems (contrast, error correction, glare) tend to break it only under specific conditions — checking in that order gets you to the right fix faster than working through causes in no particular sequence.

The Complete QR Code Troubleshooting Decision Tree

Match your actual symptom to the row below — this is the fastest path to a fix if the quick diagnosis above didn't already point you somewhere specific.

Reading this table as a flowchart in words: if the code fails on every device from every angle, the problem is almost always structural — quiet zone, distortion, or raw size. If it fails on some devices or some angles but not others, the problem is almost always marginal — contrast, error correction, or glare, something that's borderline rather than broken outright. If the code scans successfully (your phone vibrates, opens something) but leads somewhere wrong or nowhere at all, the problem has moved past the code itself into the destination — most commonly a dynamic code issue, covered in its own section below.

Why This List Is Shorter Than Most Competing Guides

Several widely-read troubleshooting pages for this topic list twelve, fourteen, even close to twenty distinct "possible causes" as a flat, unordered list — technically accurate, but not especially useful when you're staring at a code that won't scan and don't know where to start. Many of those long lists are really the same handful of root causes described multiple times under different names: "low contrast" and "reversed colors" and "faded print" are all, mechanically, the same underlying problem (the scanner can't distinguish light modules from dark ones), just triggered by different circumstances. The decision tree above deliberately groups by symptom rather than by every possible surface-level cause, because symptom is what you actually observe first — "it fails on every phone" versus "it fails on some phones" versus "it scans but goes nowhere useful" are three fundamentally different diagnostic paths, and collapsing a long cause-list into those three branches gets you to the right section of this guide in seconds rather than requiring you to read every possible cause before finding the one that applies.

A Worked Example: Diagnosing a Menu QR Code That Stopped Scanning

To make the decision tree concrete, walk through an actual case. A restaurant's table-tent QR code, linking to its digital menu, worked fine for two months and then started failing — a server notices several customers giving up mid-scan over the course of a dinner shift.

1. Quick diagnosis step 1: the server scans a known-working code (a delivery app's QR code on their own phone) — it scans fine. So the problem is the restaurant's code, not the customers' phones in general.
2. Quick diagnosis step 2: they check the quiet zone. The table tent design was recently updated to add a small "Follow us" text line directly below the code, encroaching into what used to be clear margin. That's the first candidate.
3. Cross-checking against the decision tree: the symptom is "scans on some phones, not others" rather than "nothing happens on any phone" — several customers do get through. That points toward a marginal issue (contrast or quiet zone) rather than a hard structural failure, which is consistent with what they just found.
4. Fix and retest: they reprint the table tent with the added text moved below a proper 8mm margin (per the quiet-zone table above, for a ~2mm module width typical of a table tent print) and reprint a small batch.
5. Verification: the same server tests the reprinted version on three phones, including an older Android model they know has given trouble before, from the actual seated-diner distance and angle. All three succeed consistently.

The full diagnosis, from noticing the problem to confirming the fix, took under fifteen minutes — because the decision tree pointed directly at "encroaching quiet zone" as the most likely cause given the specific symptom pattern (intermittent, not universal failure), rather than requiring a guess-and-check pass through every possible cause in the earlier flat lists this kind of article usually provides.

Design & Print Issues

Quiet Zone — The 4-Module Rule

ISO/IEC 18004 requires a minimum quiet zone — a clear margin free of any other content — of four module widths on all four sides of a QR code. This isn't a stylistic recommendation; it's how the scanner's software isolates the code's position markers from surrounding text, borders, or graphics in the first place. A technically perfect QR code pattern crammed right up against a logo, a border line, or body text can fail to scan entirely, not because the code is damaged, but because the scanner never successfully locates its boundaries to begin decoding.

The 4-module rule is easy to state and hard to apply without knowing your actual module size, which varies by print size and QR version. The table below translates that rule into real millimeters for common print scenarios — a conversion no major competing guide on this topic currently publishes

These figures are a practical conversion of the ISO/IEC 18004 four-module quiet zone rule, calculated from typical module widths at each print size — they are not a table published directly in the standard itself, which specifies the rule as a module-count ratio rather than fixed physical dimensions, since actual module width depends on your specific print size and QR version. If you don't know your exact module width, the safe approach is to measure one module directly on your printed proof with a ruler and multiply by four, rather than assuming one of the typical values above applies exactly to your file.

Contrast — Beyond "Make It Darker"

Vague advice to use "strong contrast" or make foreground colors "at least 40% darker" than the background shows up across most QR troubleshooting content, but it's worth being honest about a gap in that advice: ISO/IEC 18004 does not define a single official contrast threshold. The standard requires that a scanner be able to distinguish light and dark modules by their reflectance difference, but it doesn't mandate one universal percentage or ratio — because the actual threshold that works depends on the scanning device, lighting conditions, and print method, none of which the standard controls. The "40% darker" figure repeated across the web appears to be an industry rule of thumb passed between sources rather than something traceable to a single defined measurement method — different sources describing it don't agree on whether it means RGB brightness, perceived luminance, or something else, and none define the measurement.

Rather than repeat that same ambiguous figure, here's a simpler, genuinely measurable test you can run in any image editor's color picker: sum the absolute difference between the foreground and background colors across all three RGB channels (max possible combined difference is 765, for pure black on pure white). As a practical safety threshold, keep that combined difference at or above roughly 400 — comfortably above a mid-gray-on-white combination (which comes out closer to 380) and well below what pure black-on-white achieves (765). This isn't an official standard either, and it's labeled here as OwnQR's own practical suggested threshold, not an ISO figure — but it has the advantage of being a concrete, checkable number rather than an unexplained percentage.

If you'd prefer a formally defined alternative, the W3C's relative luminance contrast ratio — the same formula used for web accessibility (WCAG) compliance — is a reasonable adjacent method, even though it wasn't designed for QR codes specifically. WCAG's own minimum for body text is a 4.5:1 contrast ratio; because QR modules are smaller and less forgiving than typography, aiming meaningfully higher — 7:1 or above — is a safer target if you're using that formula. In practice, for the vast majority of QR codes, the simplest reliable answer is also the least exciting one: use black modules on a white background. Every deviation from that — custom colors, gradients, colored backgrounds — trades some contrast margin for aesthetics, and it's worth doing that trade deliberately rather than by accident.

Other Design Mistakes That Break Scans

Beyond quiet zone and contrast specifically, a handful of other design and export mistakes show up repeatedly in real print failures, each worth checking directly

• Inverted colors (white modules on a black background). Some scanners handle this correctly, but it's meaningfully less universally supported than standard dark-on-light, and it's a common source of "scans on my phone but not my customer's" reports. Reserve inverted colors for situations where you've specifically tested the target audience's likely devices.
• Non-square cropping or stretching. QR codes must remain perfectly square — modules have to be uniform, equally-sized squares for the position markers to be read correctly. A code stretched slightly during a page layout resize (common when dragging a corner handle without holding a proportion-lock key) distorts every module just enough to cause intermittent failures that are hard to spot by eye.
• Low-resolution export upscaled for print. A PNG generated at web/screen resolution, then scaled up for a large-format print, produces visibly blurred module edges under close inspection, even though it can look fine from a normal viewing distance on screen. See this site's minimum size guide for the DPI-to-pixel math that avoids this.
• Background patterns or busy imagery directly behind or around the code. Even with a technically adequate quiet zone, a highly textured or patterned background immediately outside that margin can confuse some scanners' edge-detection, particularly older camera software. A plain, solid-color quiet zone is the safest choice regardless of how decorative the surrounding design is.
• Placing the code across a fold, seam, or perforation. Common on brochures, tri-fold flyers, and perforated tickets — a crease running through even a portion of the code can distort enough modules to push a marginal code past its error-correction threshold, especially after the material has been folded and unfolded multiple times.

Dynamic QR Code Failures

A QR code that scans successfully — the phone recognizes it instantly, no contrast or quiet-zone problem — but leads to a dead page, an error, or nothing at all is almost never a printing problem. It's a destination problem, and for dynamic QR codes specifically, that has a few distinct, common causes worth naming directly rather than lumping into a generic "broken link" bucket

• Subscription lapse. Most dynamic QR code providers operate on a subscription model — if a user's plan expires or a payment fails, the redirect service can stop resolving, which means every printed copy of that code, no matter how many, stops working simultaneously and without warning to anyone who printed it. According to Uniqode's publicly reported QR Code Scan Index (based on more than 188 million tracked scans), subscription-related expiration is a leading cause of dynamic QR code failures — more common than physical damage to the printed code itself. That statistic comes from Uniqode's own published report rather than independently verified first-hand data, and is cited here as their reported finding, not as an OwnQR measurement.
• Deleted or repointed destination. Someone with access to the dynamic code's dashboard changes or removes the destination without realizing a large batch of printed material still relies on the old target — this is a process failure, not a technical one, but it produces identical symptoms to a technical failure from the scanner's side.
• Scan limit reached. Some providers cap total scans per code on lower-tier plans; once the cap is hit, the code stops resolving until the plan is upgraded, which can look identical to a code that "just stopped working" for no visible reason.
• Temporary server or redirect-service outage. Less common, but worth ruling out by testing again a few minutes later before assuming a permanent failure — dynamic codes depend on the provider's servers being reachable at scan time, which is a dependency a static code simply doesn't have.

This is the structural trade-off dynamic codes carry that static codes don't: the ability to change a destination after printing comes with an ongoing dependency on the provider staying operational and the account staying current. OwnQR's dynamic codes are a one-time $15 purchase rather than a recurring subscription, specifically so that a code doesn't stop resolving because a subscription payment lapsed — but that removes only one of the four causes above, not all of them; a deleted destination, a hit scan limit (on plans that have one), or a genuine service outage can still happen regardless of billing model, so testing dynamic codes periodically after printing remains worthwhile no matter which provider issued them.

It's worth being precise about the difference between "expired" and "failed," since the two get conflated often enough to cause confusion during troubleshooting. A static code never expires in any technical sense — there's no server, no account, and no subscription behind it; the pattern printed on paper either physically survives or it doesn't, independent of anyone paying for anything. A dynamic code's underlying printed pattern also never expires physically, but the redirect service behind it can stop functioning for any of the reasons above, which produces the same practical symptom (a scan that goes nowhere) through an entirely different mechanism. For a broader look at how "expiration" works — or doesn't — across both code types, see this site's dedicated guide to whether QR codes expire.

Device & Scanning Technique Issues

Not every scan failure originates with the code. Camera hardware, default apps, and OS-level settings vary enough between iPhone and Android that the same physical QR code can behave differently across devices — worth checking directly rather than assuming the code is at fault once you've ruled out the design and print issues above.

Beyond the device itself, scanning technique causes a meaningful share of reported failures that have nothing to do with the code

• Holding the phone too close. Most phone cameras have a minimum macro focus distance of roughly 3-5cm — closer than that, the camera physically can't focus, regardless of how correctly sized or printed the code is. Back away slightly and let the camera refocus.
• Scanning at too sharp an angle. A QR code viewed from a steep angle appears as a skewed parallelogram rather than a square to the camera, which some decoders handle poorly, especially combined with any other marginal factor like low contrast.
• Motion blur from an unsteady hand. Holding the phone still for even half a second longer than feels natural resolves a surprising share of "it just won't scan" reports, particularly in lower light where the camera's shutter speed slows down to compensate.
• Scanning through a third-party camera app not designed for QR codes. Some social media or filter apps intercept the camera view and don't run QR detection at all; switching to the phone's native Camera app rules this out immediately.

Third-party dedicated QR scanner apps deserve a specific note, since they're a common recommendation elsewhere: for most users, on most modern phones, they're unnecessary and occasionally counterproductive. Native camera-based QR detection on both iOS and current Android versions is generally as fast and reliable as a dedicated app, without the extra step of opening a separate app first — the main legitimate reason to install one today is an older or lower-end Android device whose manufacturer camera genuinely lacks built-in QR support, which the device table above helps you identify.

Pre-Print Checklist: Catch Failures Before They're Printed

Every cause covered in this guide is cheaper to catch before a print run than after. Run through this checklist on the final artwork — not an earlier draft — before sending anything to a printer at real volume

1. Measure the quiet zone directly on the proof, not just in the design file — confirm at least 4 module-widths of clear space on all four sides, using the mm table above as a reference for your print size.
2. Check contrast in the actual color picker — confirm black-on-white, or if using custom colors, verify the combined RGB difference is comfortably above roughly 400.
3. Confirm the code hasn't been stretched, rotated, or cropped during page layout — it should measure identically wide and tall.
4. Verify the file resolution meets at least 300 DPI at the final print size, or confirm the file is a vector (SVG/EPS) rather than a raster export.
5. If there's a logo, confirm error correction is set to Q or H, and that the logo doesn't touch any of the three corner position markers.
6. If it's a dynamic code, confirm the account and subscription (if applicable) are current, and that the destination it currently points to is the one you intend to go live with.
7. Print one physical test copy on the actual material, not a different paper stock or a desktop printer proxy for a professional print run.
8. Scan the physical test copy on at least two phones — one iOS, one Android — from the real expected distance and under the real expected lighting, not from six inches away on a well-lit desk.

Steps 7 and 8 are the ones most often skipped under time pressure, and they're also the ones that catch problems the first six steps can't — glare from lamination, ink saturation differences between screen and paper, and device-specific decoder quirks all only show up in a genuine physical test, not a digital proof.

When to Reprint vs. When to Just Fix the Destination

Not every QR code failure requires reprinting. Knowing which category a failure falls into saves real time and material cost

• Fix the destination, don't reprint, when the code itself scans successfully (confirmed by copying the decoded URL and testing it directly) but the destination is broken, outdated, or deleted. For a dynamic code, this is a dashboard change with zero reprinting involved — the entire advantage dynamic codes exist for. For a static code pointing at a page you still control, fixing the page at that same URL (rather than moving content to a new URL) also avoids a reprint.
• Reprint, don't just fix the destination, when the code itself fails the physical diagnosis — inadequate quiet zone, distortion, insufficient size for its placement, or genuine physical damage (tears, heavy fading, ink smearing). No destination fix resolves a structurally broken printed pattern; the pattern itself has to be replaced.
• Reprint and switch to dynamic, specifically, when you're facing a second reprint for the same root cause — a destination that changed once already and is likely to change again (a rotating menu, a seasonal promotion, a product page that gets replaced). The first reprint is often unavoidable regardless of code type; it's the second and third reprints for the same reason that a dynamic code exists to eliminate.

The Bottom Line

Most QR code scan failures trace back to one of three causes, in order of how often they're actually the culprit: an inadequate quiet zone (fixable by measuring your printed proof and applying the 4-module rule in real millimeters), marginal contrast (fixable by defaulting to black-on-white, or checking a measurable RGB or luminance threshold if you need custom colors), or a dynamic code whose destination has gone stale — through a lapsed subscription, a deleted target, or a hit scan limit, not through the printed pattern itself failing. Before assuming any code is fundamentally broken, run the 60-second sanity check at the top of this guide: scan something you know works on the same device first, because a surprising share of "my QR code is broken" reports turn out to be a device or scanning-app issue that has nothing to do with the printed code at all.

The decision tree and pre-print checklist in this guide exist to replace guesswork with a specific, ordered sequence — check structural issues (quiet zone, distortion, size) before marginal issues (contrast, error correction), and check the destination directly (by testing the decoded URL in a browser) before assuming the code's pattern itself is at fault. That ordering, applied consistently, resolves the overwhelming majority of real-world QR code failures faster than working through an unordered list of a dozen possible causes one at a time. And for anything going to print at real volume — not just a single test — the physical test-print-and-scan step at the end of the checklist above catches the failures that no formula, table, or checklist can fully predict on paper alone: how a specific material, ink, lamination, and lighting condition actually behave together, which is ultimately what determines whether a real customer's scan succeeds.

Frequently Asked Questions

Why does my QR code work sometimes but not other times?
Intermittent scanning almost always points to a marginal factor rather than a broken code — contrast that's just barely adequate, a quiet zone that's slightly too narrow, or a logo sized close to the error-correction limit. The code decodes successfully under good lighting and a straight-on angle but fails as soon as conditions get slightly worse. Fix the underlying margin (contrast, quiet zone, or error correction) rather than treating each failure as random.

What is the minimum quiet zone size for a QR code?
Four module widths of clear space on every side of the code, per ISO/IEC 18004. Since module width depends on your print size, measure one module on your printed proof and multiply by four — for a typical business-card-sized code with roughly 1mm modules, that works out to a 4mm minimum border.

What contrast ratio do I need for a QR code to scan reliably?
There's no single official ISO-mandated number. Black modules on a white background is the safest default. If you want a measurable rule of thumb, keep the combined RGB difference between foreground and background above roughly 400 out of a possible 765, or use a formal contrast-ratio formula (like WCAG's) and aim well above its 4.5:1 text minimum.

Can a QR code expire?
A static QR code never expires on its own — it's a fixed, unchanging pattern with no dependency on a server. A dynamic QR code can effectively stop working if its subscription lapses, its destination is deleted, or (on some plans) it hits a scan limit, even though the printed pattern itself never physically changes.

Why does my QR code scan but the link doesn't load?
The code is working correctly — it's successfully decoding to a URL — but the destination itself is the problem: a deleted page, a broken link, an expired dynamic redirect, or no internet connection on the scanning device. Copy the decoded URL and test it directly in a browser to confirm.

Why does my QR code scan on one phone but not another?
Camera decoders differ in how much low contrast, small size, or physical damage they tolerate before failing. Older or budget Android devices are typically less forgiving than recent iPhones. Testing on at least two different phones before a full print run catches this kind of device-specific failure before it reaches customers.