how-to-guides

QR Code Not Working? 9 Real Reasons and How to Fix Each One

Your QR code isn't scanning? Here are the 9 real reasons QR codes fail in 2026, how to diagnose the cause in under a minute, and the exact fix for each one.

Team U2L • 19 min read

A QR code stops working for one of three reasons: the code itself is broken (too small, low contrast, no quiet zone, or blurry), the destination link is dead or blocked, or the scanning device can't lock onto it. Start by scanning a known-good QR code. If that works and yours doesn't, the code is the problem. If nothing scans, the device is.

Everything looked fine on the screen. You printed 500 flyers, taped one to the door, held up your phone, and nothing happens. The camera stares at your QR code like it's a wall.

This is one of the most frustrating "small" problems in marketing, because there's usually no error message. The camera just refuses to see the code, and you have no way to know why. Is the print too small? Wrong colors? Broken link? Bad camera? All four?

Here's the good news: 9 out of 10 QR code failures come down to one of nine specific causes, and each one has a clean fix. If you know what to look for, you can diagnose the problem in under a minute and often fix it without reprinting a thing. This guide walks through every reason a QR code stops working in 2026, ordered by how common they actually are, plus a diagnostic flow you can run before your next batch of prints so this never happens again.

Table of Contents

Before troubleshooting anything else, run a 30-second test. Pull up a QR code you know works (any Google Pay code, a bank ATM QR, or a random one from Wikipedia's QR code article on your laptop). Try scanning it with the same phone you were using.

  • The known-good code scans, yours doesn't → the problem is in your code or the destination. Continue to reason #1.
  • Nothing scans → the phone or camera is the problem. Skip ahead to reason #9.
  • Yours scans but shows an error page → the code is fine, the link is broken. Jump to reason #6.

This one test saves an hour of wrong-turn debugging. We've watched teams reprint entire runs because they assumed the QR was bad when the destination page had 404'd two weeks earlier.

Symptom Most likely cause Fastest fix
Camera doesn't detect the code at all Size, contrast, or quiet zone Enlarge, add margin, boost contrast
Code detects but no banner appears Malformed data or bad slug Regenerate with a fresh short URL
Banner appears, tap opens error page Broken/expired destination Update the destination in the dashboard
Some phones work, others don't Low error correction or bad print Increase EC level and reprint
Only fails outdoors Glare, reflection, or lighting Matte finish, move to shade

1. The QR Code Is Too Small for the Scan Distance

This is the single most common reason. A QR code that measures 1 cm on a business card is fine at reading distance, but the same size on a poster people walk past is invisible to a phone camera. The physics is simple: cameras need enough pixels on the code's smallest squares (modules) to reconstruct the pattern.

The rule of thumb: the QR code should be at least 1/10th of the scan distance. If you want people to scan from 1 metre away, the code needs to be 10 cm wide. From 3 metres, 30 cm. Absolute minimum for a card or menu at arm's length: 2 x 2 cm. Anything smaller starts failing on older phone cameras.

Fix: measure the intended scan distance and multiply by 0.1. If you can't reprint yet, tell people to walk closer. On packaging or product labels where space is tight, use a dynamic QR pointing to a short slug (u2l.ai/x1) instead of a long URL - dynamic codes have fewer modules for the same URL, so they stay legible at smaller sizes. This is one of the practical wins of dynamic QR codes over static ones.

2. Low Contrast or Inverted Colors

Cameras are trained on one pattern: dark modules on a light background. The moment you flip that (light modules on dark, or two similar mid-tones), scan rates crash. Your brand's "moody navy on charcoal" QR code might look beautiful in the mockup and be functionally unreadable in the wild.

What actually fails:

  • White QR on black background - some cameras handle it, most older ones don't
  • Pastel-on-pastel (mint green modules on peach background - real example we've seen)
  • Gradient fills that dilute the darkest squares to grey
  • Metallic ink on metallic backgrounds under artificial light

Fix: use dark modules (black, deep navy, dark forest green) on a plain light background (white, cream, very pale grey). If you must brand-color the modules, keep the WCAG contrast ratio above 4:1 against the background. And never, ever invert unless you've physically scan-tested the printed code on at least three phones. If a designer insists on the aesthetic, the compromise is to keep the QR itself standard and put brand color in the frame around it.

3. Missing or Cropped Quiet Zone

Every QR code needs a blank border around it - the "quiet zone." Officially, it needs to be at least 4 modules wide (roughly the width of four of the little black squares). Without it, the camera can't figure out where the code ends and the background begins.

The quiet zone is usually broken by designers not knowing it exists. They see white space and think "wasted room," so they crop tight, add a border line right against the modules, or place text so close it touches. The camera then treats the surrounding artwork as part of the code and gets confused.

Fix: enforce a padding of at least 4 modules of blank space on all four sides. If you're placing the QR on a busy background (photo, pattern, dark color), put a solid white box behind it that extends well past the modules. When you export from a decent QR generator, the quiet zone is baked into the file - don't crop it out in your design tool "to save space."

4. Blurry, Pixelated, or Stretched Image

Someone dragged a 200 x 200 pixel PNG into an Illustrator file, resized it to fit a poster, and printed it. Now the black modules have soft grey edges and the camera can't decide where one square ends and the next begins.

Signs you have this problem:

  • The code edges look fuzzy or "smoky"
  • Straight lines in the pattern have a staircase effect
  • The file was tiny (under 300 x 300 px) and got scaled up
  • Someone applied a "smart resize" or upscale filter that guessed at pixels

Fix: always export as SVG for print work. SVG is vector, so it stays sharp at any size - a 1 cm sticker or a 3 metre billboard from the same file. If you must use raster, export at the final print size and at least 300 DPI. Never let a PDF export downsample your QR image. If the code arrived as a small PNG and you can't get a fresh export, regenerate it from the original source rather than upscaling.

5. Damaged, Curved, or Reflective Print Surface

The pattern is fine, the file is fine, but the physical world is doing weird things to it. Real-world failure modes:

  • Glossy lamination reflecting overhead lights back into the camera, wiping out modules
  • Curved surfaces (mugs, water bottles, product cylinders) distorting the grid so squares no longer align
  • Torn, folded, or scratched paper where enough modules are lost that error correction can't recover
  • Faded thermal receipt printing where the black modules have gone grey-brown after a week in sunlight
  • Ink bleed on porous stock (uncoated newsprint, kraft paper) fattening the modules until light gaps disappear

Fix: use matte lamination or a spot matte varnish on the QR area instead of gloss. On cylindrical products, position the QR so it doesn't wrap - keep it inside a face that stays roughly flat when you look at it head-on. For any printed asset in direct sunlight (window decals, patio menus), use UV-stable ink or laminate against fade. And print a test on the actual stock and coating you'll use for the run, not a proof from a different printer.

The camera detects the code perfectly, a banner pops up, you tap - and land on a 404 page or a "site can't be reached" error. A large share of QR code failures in the wild are destination problems, not code problems, and it's the failure mode most likely to hurt your brand, because the customer sees your logo and then sees a broken page.

Why destinations break:

  • The landing page was moved or renamed, redirect wasn't set up
  • The domain expired
  • The static QR was pointing at a marketing URL that the web team killed
  • The destination was flagged by a browser's Safe Browsing list
  • The short link was created on a platform that shut down (goo.gl, Firebase Dynamic Links, and others)

Fix: if the code is static (data encoded in the pattern itself), you have no choice - reprint. This is why we push so hard on dynamic. If it's dynamic, log into your dashboard, edit the destination without reprinting, and every existing print starts working again. On U2L AI, changing the destination is one field and a save - the printed QR keeps working, no version bump, no reprint. Set up a 404 catch too, so if you ever have a lag you're pointing to a branded fallback page instead of a browser error screen.

For dead destinations you inherited from another platform - especially anything you built on Firebase Dynamic Links or goo.gl before they were shut down - you'll need to migrate. Our guide on Firebase Dynamic Links alternatives walks through the migration path.

7. Logo or Overlay Covering Too Much of the Pattern

A little logo in the middle of a QR code is fine. That's what error correction is for - the code can lose 7% to 30% of its modules and still reconstruct. But designers regularly push way past that, dropping full brand marks, illustrations, or text over 40% of the pattern. At that point no error correction level saves you.

The safe limits:

Error correction level Max logo coverage Best for
L (Low) ~5% Clean codes, no logo
M (Medium) ~10% Small logo, high-quality print
Q (Quartile) ~20% Branded codes on marketing materials
H (High) ~25-30% Any code with a centered logo

Fix: if you're placing a logo, bump the error correction level up to H when you generate the code. Keep the logo inside the centre region (never spanning the position markers in the three corners), and never larger than 25-30% of the total area including the quiet zone. Test with three different phones before going to print. When you add a logo to your QR code the right way, the generator should let you set error correction and preview scannability before download - if it doesn't, use a different one.

8. Error Correction Level Is Too Low

Related to the logo problem but broader. Error correction is what lets a QR code work with small imperfections - a coffee splash, a wrinkle, a slightly cropped edge. Per Denso Wave's error-correction spec, Level L (Low) tolerates around 7% damage while Level H (High) tolerates around 30%. If you generated at L and then printed on a surface that scuffs or scratches, the code has almost no margin.

You want level M as a baseline for anything printed. Use Q for outdoor or high-wear surfaces. Use H if there's a logo overlay, and for anything getting handled a lot (stickers, restaurant tables, event lanyards).

Fix: regenerate the code at higher error correction. Yes, higher EC means slightly denser modules for the same URL - which is why keeping the underlying URL short (a redirect through a short URL service instead of a long branded URL) matters. Fewer characters to encode + higher EC = a code that scans reliably even when scuffed.

9. Scanning Device or Camera Problems

Sometimes the problem really is on the reader's side. If your quick diagnostic showed nothing scans, walk through this list:

  • Dirty lens. Half the "my camera won't scan" tickets are fingerprints and pocket lint. Wipe with a microfibre cloth.
  • QR scanning turned off. On iPhone, check Settings → Camera → Scan QR Codes (Apple's walkthrough). On Samsung Galaxy, check Settings → Useful features → Scan QR codes.
  • Autofocus dead. Try pinch-zooming so the code fills more of the frame - forces the camera to refocus.
  • Old OS. iOS 10 and older Android versions don't natively scan. If someone's on ancient hardware, they need Google Lens or a scanner app.
  • Wrong app. People try to scan inside Instagram's or Facebook's built-in camera and it doesn't detect. Switch to the system camera.
  • Bad lighting. Fluorescent flicker, low light, direct backlight from a window behind the code. Move to even light and try again.

If you're the code owner and this is happening at scale (customers reporting scans failing across many devices), it's almost never a device problem - go back to reasons 1-4. But if you're the scanner and everything else has been ruled out, working through the list above catches the last 5%. Our full how to scan a QR code walkthrough covers device-specific quirks for iPhone, Android, and desktop scanners.

How to Test Before You Print

Everything above is easier to prevent than to diagnose in the field. A 5-minute test flow before any print run kills nearly all of these failure modes:

  1. Generate the QR code at its final destination URL. Use error correction level H if there's any logo or brand element.
  2. Export as SVG for the print file (fallback to a high-DPI PNG at final print size only if your printer can't handle vector).
  3. Print a single test copy on the actual stock and finish you'll use for the run. Photocopies or laser proofs on plain paper don't count - gloss and matte behave completely differently.
  4. Scan it on three phones - one recent iPhone, one recent Android, and one older device (something four or five years old). If any of the three fails, adjust and retest.
  5. Test at real distances. For a poster meant to be scanned from across a room, tape the test print up and try scanning from that distance. Don't just test at 20 cm.
  6. Verify the destination page loads correctly and looks right on mobile. Do a final scan-and-tap flow on the actual phone, not just a URL paste in a desktop browser.

If a code passes those steps, you can commit to the full print run with confidence. This is the flow we recommend to every U2L AI customer running larger campaigns, especially anything on packaging or outdoor signage where reprinting is expensive.

How U2L AI Prevents Most of These Failures

U2L AI generates dynamic QR codes linked to short URLs by default, which quietly eliminates several of the failure modes above:

  • The destination is always editable. If a page moves or breaks, you change it in the dashboard and every printed code keeps working - no reprint. This alone kills the single most damaging failure mode (dead destination pages after the print is out in the world).
  • URLs stay short. Because the code encodes a short URL (like u2l.ai/xyz) instead of the full destination, the underlying data is small and the module density stays low. That means the same physical print size scans reliably from farther away.
  • Full customization without breaking scannability. Colors, patterns, corner styles, frames, and centered logo upload - all with a live preview so you can see whether contrast, quiet zone, and error correction are still safe. If you push a design past the safe threshold, you know before you download.
  • Multiple export formats. SVG for print work (scales infinitely), PNG for screens, high-DPI options for large-format runs. No excuse for pixelated codes.
  • Free to try, no login needed. Generate a QR code straight from the QR code generator without an account. Login is only required if you want to keep the dynamic link editable long-term or see scan analytics.
  • Real-time scan analytics. Once a code is out in the world, you can see if scans are failing at unusual rates - your dashboard will tell you if scans are landing on the destination page or dropping between scan and load. This is the fastest early warning that something has broken.
  • Link safety checks. Every U2L AI short link runs through parallel safety checks (Safe Browsing, moderation, blocklists) so the destination isn't going to trip a browser warning that makes your code look sketchy. The full feature list is here.

For teams doing high volumes of printed QR campaigns, this combination is genuinely hard to beat. And for readers who found this article by frantically Googling with a broken print run in front of them: if the failing code is a dynamic one from any provider, check whether the destination is still live before you reprint - it's a two-second check that often saves the whole run.

Frequently Asked Questions

Why does my QR code work on some phones but not others?

Usually error correction level or scan distance. Older phones have less capable cameras that need bigger, higher-contrast, higher-EC codes to reconstruct the pattern. Regenerate at error correction level H, print larger, and add more quiet zone. If it still fails on older Android, ask the tester to open Google Lens directly instead of the native camera.

Can a QR code stop working over time?

The code itself doesn't degrade, but three things around it can. The physical print fades or scratches, the destination URL breaks, and the platform that hosted the redirect can shut down (goo.gl and Firebase Dynamic Links are the biggest recent examples). Dynamic QR codes on an actively maintained service protect against the second and third; UV-safe print protects against the first.

The code is fine - your problem is on the destination side. Common causes: the URL has a typo, the page returned a 404, the domain expired, or a browser Safe Browsing warning is blocking the load. Open the scanned URL manually in a desktop browser and see what happens. If the page loads there but not on the phone, it's usually a mobile network or Safe Browsing issue.

Do QR codes expire?

Free static QR codes never expire because the destination is baked into the pattern. Dynamic QR codes only stop working if the service hosting the redirect shuts down or the destination goes dead - not because of any time limit on the code. Some providers do expire dynamic QR codes on free plans as a business tactic, so check the terms before committing to a big print run.

What's the smallest a QR code can be and still work?

Around 2 x 2 cm (0.8 x 0.8 inches) at close reading distance, assuming good contrast and a full quiet zone. Below that, older phone cameras start failing. For any distance beyond arm's length, use the 10:1 rule: minimum QR width equals 1/10th of the scan distance.

Why does my QR code work on my phone but not on the customer's phone?

Most often it's device diversity - your phone is newer, has a better camera, and you're testing in ideal lighting. Test on three different phones (recent iPhone, recent Android, older device) in the actual environment where customers will scan. If your customers are consistently failing where you succeed, the code is under-designed for real-world conditions.

Can I fix a QR code that's already printed?

If it's dynamic, yes - log into the QR code service, edit the destination URL, save, and every printed code now points to the new page. That's the whole point of dynamic. If it's static, no - the destination is physically encoded in the pattern and only reprinting changes it.

How do I check if my QR code will actually scan before printing 1,000 of them?

Print a single copy on the actual stock and finish you'll use for the full run. Scan it with a recent iPhone, a recent Android, and one older phone. Scan from the maximum realistic distance (across the room for a poster, arm's length for a menu). If any of the three phones fails or the scan needs more than three seconds, adjust size, contrast, quiet zone, or error correction and retest before committing to the run.

Your next QR campaign shouldn't need this article. Generate the code with dynamic redirects, export as SVG, print a single test on your real stock, and scan on three phones before you go to press. If you want the whole workflow (dynamic redirects, logo customization, real-time scan analytics, and safety-checked short URLs) in one place, try U2L AI free - no card needed to start.

Ready to try U2L AI?

Free forever plan. No credit card required.

Get Started Free View Pricing