How to Make a QR Code That Never Expires

A surprisingly common worry among people printing QR codes for the first time is whether the code will simply stop working after some period of time, the way a coupon or a subscription might expire. The concern is understandable given how many software services attach time limits or feature restrictions to free plans, but it reflects a misunderstanding of how QR codes are actually built. This guide explains exactly what does and doesn't expire when it comes to QR codes, the crucial difference between static and dynamic codes, and the concrete steps to make sure a code you generate today still works perfectly five or ten years from now.

A static QR code is just data, and data doesn't expire

At its core, a QR code is a fixed visual pattern that encodes a specific piece of data, whether that's a URL, a phone number, plain text, or Wi-Fi credentials. Once that pattern is generated, it is a complete, self-contained image; there's no server, subscription, or ongoing service required to make it readable. Any phone with a camera and QR-scanning capability can decode that pattern years later exactly the same way it could the day it was created.

This is fundamentally different from something like a streaming subscription or a cloud-hosted file, where access depends on an ongoing relationship with a provider. A static QR code has no such dependency. Once the image exists, whether saved on your device or printed on paper, it will decode to the exact same content forever, regardless of what happens to the generator that created it.

This is why the notion of a QR code "expiring" on its own is technically inaccurate for static codes: there's nothing to expire, because there's no ongoing service being provided after the code is generated. What can happen instead falls into a few specific, avoidable categories covered below.

The real reason some QR codes stop working

When people report that a QR code has "expired," what's usually happened is one of two things, and neither is actually about the code itself. The first is that the destination the code points to has changed or gone offline; if your static code encodes a URL and that page gets deleted, moved, or the domain lapses, the code will still scan successfully and still display the exact same URL it always did, but that URL will now lead to a broken page or error message.

The second, and increasingly common, cause is confusion with dynamic QR codes offered by some services, which intentionally route through a redirect link that the provider controls. If that provider's free plan includes a time limit, or if the underlying account lapses or is deleted, the redirect can stop working even though the printed code hasn't changed at all. This is a business model decision by certain QR services, not an inherent property of QR code technology.

Understanding this distinction is the key to avoiding the problem altogether: a plain static code with a stable destination has no expiry mechanism built in, while a dynamic, redirect-based code's reliability depends entirely on the ongoing status of the service providing that redirect.

Static vs dynamic QR codes: what's the actual difference

A static QR code encodes its final destination directly into the code's pattern at the moment of creation, and that destination is permanent; if it's a URL, that exact URL is baked into the code and can never be changed without generating an entirely new code. This is the type of QR code produced by the free tier of most generators, including qrcodeharbor.com, and it has no dependency on any ongoing service.

A dynamic QR code instead encodes a short redirect link controlled by the QR service, which then forwards the scanner to whatever destination you've currently configured in that service's dashboard. This is genuinely useful because it lets you change where the code points after it's already printed, correcting a typo, updating a menu link, or redirecting a promotion, without needing to reprint anything.

The trade-off is that a dynamic code's reliability is tied to the provider continuing to operate the redirect service indefinitely. For anyone specifically prioritizing a code that will never depend on any external service, a static code is the more resilient choice, while dynamic codes trade a small amount of that independence for the real convenience of being editable after printing.

Step 1: Choose a destination you control long-term

The single biggest factor in whether your static QR code remains useful for years is the stability of what it points to, not the code itself. If you're encoding a URL, use a domain you own and intend to maintain, rather than a third-party page, a temporary campaign microsite, or a free hosting subdomain that might get taken down.

If the exact page content might change over time, such as a menu or a set of business hours, point the code at a stable, permanent URL on your own site (for example, yoursite.com/menu) and update the content on that page as needed, rather than regenerating the code every time the underlying details change. This way the code itself never needs to be reprinted, only the page it links to needs occasional updates.

For content that truly never needs to change, such as a vCard with fixed contact details, plain text, or a Wi-Fi network that won't be renamed, encoding the content directly rather than a URL removes even the dependency on a live web page, since the phone can display or use that information straight from the decoded code.

Step 2: Generate with a tool that doesn't attach artificial limits

Some QR generators, particularly ones built around a freemium dynamic-code business model, apply scan limits, time-boxed trials, or watermarks to codes generated on a free plan, which can create exactly the kind of unexpected expiry problem this guide is addressing. Reading the fine print before committing to a generator for anything you plan to print or rely on long-term is worth the two minutes it takes.

A generator built around static codes with no scan limits, no watermark, and no expiry date sidesteps this problem entirely. The free plan on qrcodeharbor.com, for example, produces unlimited static QR codes with no sign-up requirement, no watermark, and no built-in expiration, and permits commercial use, making it a safe choice for anything you intend to keep using indefinitely.

It's worth explicitly checking, before you print anything at scale, whether the specific code type you're generating (static versus dynamic) matches your expectations, since the permanence guarantee only applies to static codes regardless of which generator produced them.

Step 3: Save the original file, not just the printed copy

Even though a static code's content never expires, the physical printed copy can degrade, get lost, or become damaged over time. Keeping the original downloaded image file, whether JPG or another format, in a properly backed-up location means you can always reprint an identical, undamaged copy without regenerating anything or risking a different destination if you had to recreate the code from scratch.

This is a simple but often skipped habit: after generating a code for something permanent, like a product label or business signage, save the file with a clear, descriptive name in a folder you'll be able to find years later, rather than relying solely on the printed material or a design file that might get misplaced.

If you ever do need to recreate a code because the original file was lost, make sure to encode the exact same original content again; a code created from a slightly different version of the destination URL or text will decode differently, even if it looks visually similar to the original.

Step 4: Periodically verify the destination is still live

Since a static code's permanence only guarantees the code decodes to the same content forever, not that the content it points to remains valid, it's worth a periodic check, perhaps annually for anything long-lived like signage or packaging, that the destination URL still resolves correctly and shows the intended content.

This is especially important after domain renewals, website redesigns, or hosting migrations, all of which can silently break a previously working link without anyone noticing until a customer complains that a code doesn't lead anywhere useful. A quick scan test as part of your regular website maintenance routine catches this before it becomes a customer-facing problem.

For codes tied to genuinely permanent physical objects, like equipment labels or engraved signage that will be in use for a decade or more, this periodic check becomes even more important, since the printed code itself is essentially permanent while websites and business details are far more likely to change over that time span.

When a dynamic, editable code is actually the better choice

None of this is to say static codes are always the right answer. If you genuinely expect the destination to change, such as a seasonal promotion, a menu that updates frequently, or a link you want to A/B test over time, a dynamic code that can be edited after printing solves a real problem that a static code cannot: you'd otherwise need to reprint and redistribute the physical code every single time the destination changes.

Dynamic codes on the Pro tier also typically come with real-time scan analytics, letting you see how many times a code has been scanned and from where, which is valuable for measuring the effectiveness of a physical marketing placement in a way a static code simply can't provide on its own.

The right choice comes down to your actual need: if permanence and complete independence from any external service matters most, a static code is the more resilient option; if editability and analytics matter more than that independence, a dynamic code is worth the trade-off, as long as you choose a provider you trust to maintain the redirect service for as long as you need it.

Frequently asked questions

Related guides