Static or dynamic? It depends on one question.
The question is whether you'll ever need to change where the code points after it's printed. Everything else follows from that.
Static vs dynamic QR codes: the short answer. A static QR code stores the final data directly in the QR pattern, so changing that data requires generating a new code. A dynamic QR code usually stores a redirect URL managed by a service, which lets the destination behind that redirect be changed later and often enables scan analytics.
A simple example makes this concrete. A static QR code for a restaurant
menu might directly contain: https://example.com/menu
A dynamic QR code might instead contain something like:
https://qr-provider.example/abc123
That redirect address then sends the visitor on to https://example.com/menu
or wherever the provider has it pointed. The printed QR pattern itself doesn't change in
either case — with a dynamic code, what changes is the destination the provider's redirect
points to, on their server, not the pattern on your printed material.
The final data is encoded directly into the black-and-white pattern — a static code containing a website address is that address, written in a form cameras can read. No redirect service sits between the scanner and the destination, and Frame's static codes are generated entirely in your browser with no account required. A static code can hold a URL, plain text, WiFi credentials, contact/vCard details and more, and there's no scan tracking built into the QR pattern itself.
One nuance worth noting: for a static code that links to a page you own, your normal website analytics can still measure visits to that page. It just isn't QR-specific tracking unless you use a dedicated URL or campaign parameters — it's not accurate to say a static QR code "cannot be tracked at all."
A dynamic QR code's pattern usually encodes a short redirect or tracking link belonging to a QR service rather than the final destination. Scanning goes to that service first, which then forwards to the real destination. Because the destination is a setting on the provider's server rather than part of the printed pattern, it can often be changed after printing, and because scans pass through the provider, they can often be counted.
Providers vary — pricing, analytics detail, and what happens if you cancel are all set by the specific service, not by "dynamic" as a category. Don't assume every dynamic QR provider offers identical plans, tracking depth or redirect-continuity policy.
| Feature | Static QR | Dynamic QR |
|---|---|---|
| Data encoded | The final destination/data itself | Usually a redirect link controlled by a provider |
| Edit destination after printing | No | Often, through the provider's system |
| Scan analytics | Not built in; website analytics can measure visits to a URL you own | Often available, since scans pass through the provider's redirect |
| Third-party redirect required | No | Yes |
| Account/service dependency | None | Depends on the provider staying active and reachable |
| Ongoing cost | Usually none to generate the QR | Depends on the provider and plan — some offer free tiers |
| Offline/self-contained data | Yes, for data types like WiFi, vCard or plain text | No — reaching the destination needs the redirect to be reachable online |
| Pattern density | Depends on how much data is encoded | Often lighter, since a short redirect link is brief — not guaranteed |
| Best for | Fixed destinations, data you want self-contained, no redirect dependency | Destinations that may change, per-code analytics, managed campaigns |
A static QR pattern doesn't contain a timer. But it can become practically useless if its destination stops working — a URL is removed, a PDF is deleted, phone or contact details become outdated, or WiFi credentials change.
A dynamic QR pattern also doesn't physically expire — the printed square stays scannable. But it points to a redirect managed by a provider. If that redirect is disabled or deleted, the provider shuts down, or a plan or policy change stops the redirect from forwarding, scans may stop reaching the intended destination even though nothing about the printed code changed. Whether that happens, and under what conditions, depends on the specific provider — it isn't accurate to say dynamic QR codes universally "expire when you stop paying."
Static: no — not the data physically encoded in it. Once printed, the pattern stays fixed.
Dynamic: the printed QR pattern itself isn't edited either. What changes is the destination behind its encoded redirect, updated through the provider's system.
There's an important workaround worth knowing: if a static QR code points to a URL you
control — say example.com/menu — you can update the content published at that
same address without changing the QR code at all, since the code just keeps opening the same
address. This does not make the QR code dynamic; the encoded URL itself is
still fixed, and this only helps when you already own the destination.
The QR pattern itself doesn't report anything — there's no built-in mechanism for a static code to record who scanned it. But for a static QR that links to a page you own, normal web analytics can measure visits to that page. It can be difficult to isolate QR scans specifically from other traffic unless you use a dedicated URL or path, or add campaign parameters to the link. Dynamic services can often provide scan-specific analytics because scans route through their redirect server first — but the depth of that data varies by provider, not by "dynamic" as a category.
This depends on what's encoded, not simply on static vs dynamic:
This is more accurate than a blanket "static works offline, dynamic doesn't" — offline capability tracks the data type, not the static/dynamic label.
A QR pattern generally becomes denser as more data is encoded into it. Dynamic services often encode a short redirect link, which can produce a less dense — and sometimes easier-to-scan — pattern compared with encoding a very long destination URL directly. But this isn't guaranteed simply because a code is labelled dynamic: a static code with a short URL can be just as light, and a dynamic code pointing at an unusually long tracking link won't automatically stay simple.
Dynamic is a genuinely better fit in several situations:
Frame currently generates static QR codes, but that doesn't make dynamic the wrong choice for these cases — when per-code tracking or a changeable destination genuinely matters, a dynamic QR service is the more suitable tool.
Yes, within a specific limit. If a static QR code encodes
https://yourdomain.com/menu, you can update the content published at that exact
address — new prices, new text, a redesigned page — and the QR code keeps opening the same
address without needing to change. What you cannot do is change the encoded URL itself after
printing; if the content moves to a different address, a new QR code has to be generated.
This applies especially to restaurant menus, PDF or document landing pages, and business
websites where you control the destination. It's a useful workaround, but it is not the same
as dynamic QR functionality.
Frame currently generates static QR codes. That means no Frame redirect is involved, no account is required to generate a code, the QR data is built entirely in your browser, and there's no Frame subscription needed to keep a generated QR code usable.
If you specifically need an editable redirect after printing, or provider-hosted per-code scan analytics, a dynamic QR service is likely a better fit for that need — that's a genuine trade-off, not a shortcoming to work around.
| Choose static if… | Choose dynamic if… |
|---|---|
| The destination or data is fixed | The destination may change after printing |
| You don't need built-in scan analytics | Scan-specific analytics matter to you |
| You'd rather not depend on a redirect service | Campaign management across multiple codes matters |
If you're unsure, decide before printing — a static code's destination can't be changed afterward, so it's worth being confident in the URL, file or credentials before committing to a print run. Before printing at volume, check the size guide and run the artwork through the QR code checker.
A static QR code stores the final data directly in the pattern, so changing that data means generating a new code. A dynamic QR code usually stores a redirect URL managed by a service, so the destination behind that redirect can be changed without reprinting.
The pattern itself has no built-in timer or account attached. It can become practically useless if its destination stops working — a page taken down, a file moved, a password changed — but that's a property of the destination, not an expiry of the QR code itself.
The printed pattern doesn't physically expire either. But it points to a redirect managed by a provider, so if that redirect is disabled, the provider shuts down, or a plan lapses in a way that stops forwarding, scans may stop reaching the intended destination. This depends on the specific provider's policy, not a universal rule.
Not the data physically encoded in a static QR code. With a dynamic QR code, the printed pattern itself isn't edited either — the destination behind its encoded redirect is changed through the provider's system.
The QR pattern itself doesn't report anything. But if a static code links to a page you own, your normal website analytics can measure visits to it — though it can be hard to distinguish QR scans from other traffic unless you use a dedicated URL or campaign parameters.
Not the printed code itself — its destination is part of the pattern. You'd need to generate a new dynamic code through a redirect provider and reprint.
It depends on what's encoded, not simply static vs dynamic. A static code containing plain text, WiFi credentials or contact details can be read without internet. A static URL still needs a connection to load the website, and a typical dynamic code needs a connection to reach its online redirect.
Not guaranteed. A QR pattern generally gets denser as more data is encoded, and a short redirect link can produce a lighter pattern than a very long destination URL. But that's a result of data length, not something automatic about being labelled dynamic.
Static usually fits when the destination or data is fixed and you don't need built-in scan analytics or a redirect dependency. Dynamic usually fits when the destination may change, you need scan-specific analytics, or you're managing multiple campaign redirects.
No. Frame currently generates static QR codes only, built in your browser with no account required. If you specifically need an editable redirect or provider-hosted scan analytics, a dynamic QR service is likely a better fit.