Do QR codes expire?
No. A QR code is a printed pattern, not an account. There is no expiry field in the specification, no clock running against it, and nothing that needs renewing. A code you generate today will still scan in twenty years, in exactly the same way a barcode printed on a tin of soup in 1998 still scans.
So why do so many people search for this? Because a great many QR codes do stop working — and the reason has nothing to do with the code and everything to do with who is standing behind it.
The short version. Static codes never expire. Dynamic codes expire the moment somebody stops paying for them. If your code died, it was dynamic.
What actually broke
A static QR code encodes your destination directly. The URL is physically present in the black and white pattern. Nothing sits in the middle, so there is nothing that can be switched off. Scanning it is a purely local act between the phone's camera and the ink.
A dynamic QR code does not encode your destination at
all. It encodes a short link on the generator's own domain — something
like qr-example.co/aX9k2 — which redirects to wherever you
pointed it. That indirection is what allows the destination to be edited
after printing, and it is also the single point of failure. The redirect
stops resolving when:
- the free trial ends;
- the subscription lapses or a card is declined;
- the plan's monthly scan limit is reached;
- the code count exceeds what the tier allows;
- the company is acquired, pivots, or shuts down.
The last one is the one that catches people out, because it takes everything at once. Every sticker, menu, poster and business card you printed through that service stops working on the same day, and there is no way to fix them without reprinting.
How to tell which kind you have
Point a phone at the code and look at the URL before you open it. Most camera apps show the destination as a preview banner rather than navigating immediately.
-
You see your own address —
yourcompany.com/menu. The code is static. It is permanent and owes nothing to anyone. - You see a domain you do not recognise — a short, unfamiliar host followed by a random string. The code is dynamic, and it will keep working exactly as long as that company keeps the redirect running.
This is worth checking before a print run, not after. The cost of the distinction is not the subscription — it is the reprint.
What you give up by staying static
Static codes are not free of trade-offs, and it would be dishonest to pretend otherwise. You lose two things:
- Editable destinations. Once printed, a static code points where it points, forever.
- Scan analytics. Nothing is counting, because nothing is in the middle to count.
For a great many uses — a table number, an asset tag, a Wi-Fi network, a link to a page you control — neither of those matters at all.
How to get both: permanence and editability
There is a third option that most pricing pages skip, and it is usually the right one for anything printed at scale: encode a URL on a domain you own, and redirect from your own server.
Print a static code pointing at
yourcompany.com/go/menu. That is a permanent, static code —
nobody can turn it off. But because you control what
/go/menu does, you can change where it lands whenever you
like, and your own server logs give you the scan counts. You get the
editability and the analytics without handing anyone a switch to your
printed materials.
A redirect rule is a handful of lines in nearly any web server or CMS, and it does not expire, because you are the one paying for the domain either way. See static vs dynamic QR codes for how to set that up.
Codes from this tool never expire
Every code this generator produces is static. Your destination is encoded straight into the pattern, the image is drawn by JavaScript on your own machine, and the file is yours. There is no account, no redirect on our domain, no scan cap and no plan tier — which means there is nothing we could switch off even if we wanted to, and nothing that stops working if this site ever disappears.
That is not a feature we added. It is a consequence of the architecture: there is no server here that could sit in the middle of your codes.