Every printed QR code carries the same quiet fear: will this square still work next year? The straight answer: QR codes themselves never expire — the pattern is just data, readable forever. What *does* expire is everything around the code: the destination link, the hosting behind it, the free-tier service that generated it, and the dynamic subscription that kept it alive. Understanding which layer broke is the difference between a code that works forever and one that fails silently in month three. Here's the full anatomy of QR longevity.
Why the Code Itself Is Immortal
A QR code is a spatial encoding of data — a pattern that means "this string of characters." The scanning standard is open, documented, and implemented in every phone camera; nothing in the format decays, times out, or phones home. A QR code printed in 2011 scans today with the same phone that scans one printed this morning.
Two properties follow:
- Static codes are permanent — a code encoding your URL directly will work as long as that URL resolves. The code never breaks; the link behind it can.
- Dynamic codes are leased — a dynamic code encodes a short redirect held by the generating service, and the redirect lives as long as the service (and your subscription) does. The code pattern is equally immortal; the redirect's *destination* is the rented part.
This is the single most important distinction in QR ownership: static codes are immutable and free and dumb; dynamic codes are editable, trackable, countable — and dependent on whoever operates them.
The Five Ways Codes "Die" (None of Them the Code's Fault)
When a printed square stops working, one of these is the cause:
1. The destination link went dead. The page moved, the business closed, the promotion ended, the domain lapsed. The most common death by far — the code faithfully delivers visitors to a 404. Prevention: point codes at links you control (your own domain, a redirect layer), and update destinations rather than reprinting.
2. The free generator's redirect expired. Many free QR services generate "dynamic" codes whose redirects survive only days or weeks on free tiers — or until the account lapses. The code looks identical to a permanent one; it just isn't. Prevention: read the generator's terms before printing anything permanent, and prefer static codes or owned redirects for long-lived materials.
3. The dynamic subscription lapsed. Paid dynamic codes stop redirecting when the subscription ends — the analytics and editability were rented with the service. The printed menus and business cards depending on them fail together. Prevention: know which of your codes are dynamic, keep those subscriptions current, or migrate the destinations before canceling.
4. The physical code degraded. Sun-bleached ink, scratched laminate, peeling stickers, worn paint — the pattern becomes unscannable while remaining "there." Prevention: UV-stable printing for outdoor use, lamination for handled surfaces, and the seasonal walk-through that reprints faded labels while the plant or the poster still exists.
5. The design broke the pattern. Over-stylized codes (low contrast, cropped quiet zones, decorations over the modules) that scanned at design time and fail at print scale. Prevention: contrast and quiet-zone rules, and testing the actual printed output.
The pattern across all five: the failure lives in the layers around the code. The square itself did everything right.
The Layered Fix: Redirects Make Everything Repairable
The professional architecture that prevents most of the five deaths:
- Print codes that point to your own short domain (`go.yourbrand.com/menu`) — a redirect you own
- The redirect forwards to the *current* destination — your site, your platform, whatever hosts the content today
- When content moves, the redirect updates; the printed code never notices
This architecture makes even static codes effectively editable (edit the redirect, not the code) and removes the free-generator dependency entirely. The institutions that survived their QR systems — libraries, museums, restaurants — all learned the same lesson: own the middle layer. The code is forever; the redirect is the part you must own.
Diagnosing a Dead Code (The Five-Minute Autopsy)
When a printed code fails, work the layers in order:
1. Scan it now — does it fail to read (physical degradation or design), or read and lead nowhere (destination death)?
2. If it reads: where does it point? Decode it with any free QR decoder app — the embedded URL tells you whose system owns the failure
3. If the URL is yours: check where the link breaks — expired page, moved content, lapsed hosting
4. If the URL is a generator's redirect: log into that service — expired free tier or lapsed subscription is the likely verdict, and the fix is migrating to an owned redirect
5. If it doesn't read at all: physical reprint from the same (or an owned) link — and add lamination or size this time
The autopsy usually ends with the same prescription: reprint through your own redirect so the failure never repeats. If the original code came from a service that has since shut its doors, regenerating it as a static code with a free QR code generator and pointing it at your new link takes about a minute.
The Longevity Checklist (For Codes That Must Survive Years)
For menus, business cards, signage, packaging, and anything printed to last:
- Static code or owned redirect — never a free generator's dynamic link for permanent materials
- Your domain in the redirect — `go.yourdomain.com/x` rather than any third party's shortener
- Test after printing, then annually — the physical check catches fade and damage before the audience does
- The destination survives you — hosting that outlives platforms and trends; your own storage for the content that matters
- Print the URL as a fallback — one small line of text under the code rescues every failed scan, forever
Conclusion
QR codes don't expire — links, subscriptions, hosting, ink, and design decisions do. The static code is immortal and unchangeable; the dynamic code is flexible and rented; and the professional answer to longevity is an owned redirect layer that makes printed codes repairable without reprinting. Diagnose failures by layer — physical, pattern, redirect, destination — and build permanent materials with your own domain in the middle. The square will outlive everything; make sure everything behind it keeps up.
FAQ
Do QR codes expire?
No — the code pattern is permanent data readable by any phone camera indefinitely. What expires is the destination: the link behind a static code, or the redirect subscription behind a dynamic one. A "dead" QR code is always a failure in the layers around the pattern, never the pattern itself.
Why did my QR code stop working?
The usual causes, in order: the destination page moved or lapsed, the free generator's redirect expired, a dynamic-code subscription lapsed, the print physically faded or was damaged, or the design broke scanability. Decode the code with a free scanner app — the embedded URL reveals which layer failed.
How long does a free QR code last?
A free *static* code (encoding your URL directly) lasts forever. Free *dynamic* codes frequently carry time limits, scan limits, or account-lifespan limits — the redirect dies when the free tier does. For anything printed to last, use static codes or an owned redirect, and read the generator's terms first.
Can I make a QR code that never expires?
Yes: a static code pointing at a URL you control (a free QR code generator makes one without an account) — ideally through a redirect on your own domain — never expires, because the pattern is permanent and the destination is yours to maintain. Add the URL in small text beneath the code as the physical-world fallback, and the system survives both link changes and scan failures.
