Google Tag Manager noscript is a fallback method that tracks users with JavaScript disabled. There is only a small population that this method applies to, but ignoring it causes tracking gaps.
It ensures that pageview tracking remains available on the site at a bare minimum with no JavaScript. This guide will walk the user through what it does, when it matters, and how they should install it on their site.
What is Google Tag Manager noscript?
Google Tag Manager’s <noscript> tag is a backup version of your GTM code. It runs when a visitor’s browser has JavaScript turned off or blocked. Instead of regular script tags that load the GTM container, it loads a small iframe window that still allows for simple page view tracking.
This helps make sure you don’t lose important tracking details from users who have their browser configured with such strict settings. Whilst it cannot register sophisticated events, it does register the simple ones for reporting.
This goes right after the opening <body> tag of your website. When implemented properly, it works in unison with the main GTM script to provide fuller tracking coverage.
Why use Google Tag Manager noscript?
While most users browse with JavaScript enabled, there’s always a chance that some don’t. Using GTM’s <noscript> iframe ensures you’re not blind to those visitors and maintains more reliable tracking across all browsers.
Here’s how enabling the <noscript> tag improves your tracking strategy and data accuracy.
Capture visits from users with JavaScript disabled
According to W3Techs, roughly 0.2%–1% of users browse with JavaScript disabled. Usually, this is due to a lack of privacy or performance. This category matters very much for high-traffic and compliance-heavy websites.
With this in mind, the <noscript> iframe loads a tracking pixel so that GTM can log pageviews even if JS is disabled, which is very useful in a government’s or financial services’ circumstances.
Support better tag firing consistency
In complex JS environments, delays in tag firing sometimes occur or sometimes tags do not fire at all, mostly when the scripts involved are poorly sequenced or in competition with one another. An enterprise-grade setup will have lots of such scripts in play.
However, by including <noscript>, you guarantee GTM at least once-ever loading through an iframe, preserving the second-level session information and mitigating some well-known pitfalls of attribution in GA4.
Improve compatibility with privacy-focused browsers
Modern browsers like Firefox with strict tracking policies may block JS-based tags altogether. Yet, they often still permit static iframes.
As a result, <noscript> increases the baseline reliability of tracking, particularly for things that are not ad-related: consent logging, verification, and basic analytics.
How does the Google Tag Manager noscript iframe work?
The <noscript> tag kicks into action when JavaScript fails to load or execute for reasons such as user-defined settings, limitations in a given browser, or an installed script blocker. Hence, it acts as a fallback mechanism to authorize the firing of key tags even without JavaScript support.
Google Tag Manager specifically embeds an iframe inside the <noscript> block. This iframe sends a small HTTP request to Google’s servers, just like a tracking pixel, and includes some of the following basic information:
- URL of the page
- Timestamp
- Container ID
- Referrer (if available)
It does not support more advanced event tracking (such as clicks or scrolls); however, it ensures that at the very least, a hit gets registered for each pageview.
This solution is especially useful for:
- Tracking traffic coming from browsers with JS disabled
- Supporting server-side tagging set-ups
- Auditing or compliance processes (e.g., in healthcare, finance, or government).
👉 Technically, the iframe points to this URL:
This will load the lightweight container that will execute without relying on JavaScript, so the container’s data can maintain a consistent trail through all visits.
What tags work when JavaScript is disabled?
When JavaScript is disabled, the majority of dynamic tags will not function, but not all tracking opportunities are missed. Certain tags can still fire via the <noscript> iframe, leveraging image pixels or basic HTTP requests.
These include:
- Google Analytics pageview hits via image requests
- Conversion tracking (limited) using fallback pixels
- Floodlight and Facebook tracking pixels in basic image format
- Consent pings or verification signals (if embedded as static tags)
However, tags that require JavaScript, for example, event listeners or scroll-depth triggers, or form tracking, do not work in this mode. Your options are restricted to what can be loaded inside a static iframe or pixel.
For important metrics such as visits, timestamps, or referring information, noscript tracking might be a good fallback. However, when it comes to rich behavioral data, JavaScript must be turned on.
| 💡 Tip: Use server-side tagging to complement noscript tracking and thereby preserve data integrity regardless of browser type. |
How to add Google Tag Manager noscript to your site
Here’s a simple way to add the <noscript> tag to your site and make sure your Google Tag Manager setup still works when JavaScript is off.
Step 1: Get your GTM snippets
In the Google Tag Manager UI, click Admin > Install Google Tag Manager to get both snippets.
- The <script> snippet loads GTM via JavaScript
- The <noscript> snippet is an iframe fallback
Step 2: Add the <script> snippet in <head>
Paste the <script> snippet immediately after your <head> tag. This ensures early loading for optimal tag performance.
Place it before other scripts to avoid conflicts and ensure tag sequencing (best practice).
Step 3: Insert <noscript> immediately after <body>
Right after the opening <body> tag, insert the <noscript> code exactly as provided:
<noscript>
<iframe src=”https://www.googletagmanager.com/ns.html?id=GTM-ABC123″
height=”0″ width=”0″ style=”display:none;visibility:hidden”></iframe>
</noscript>
Placing it here ensures fallback container loading and Search Console verification.
Step 4: Verify placement and functionality
Use Google Tag Assistant or Preview Mode to ensure both scripts load correctly.
View your page source (Ctrl+U) to confirm:
- <script> in <head>
- <noscript> right after <body>
If misplaced, GTM may still work, but a misplaced <noscript> could break the iframe or make HTML invalid.
A Simpler Way to Manage GTM on Shopify
If manual tag placement is overwhelming for you, especially when trying to deal with both <script> and <noscript> snippets, then TagFly is your go-to solution. The app is designed for Shopify merchants aspiring to have full control over Google Tag Manager without the trouble of fiddling with theme files or indenting thousands of lines of code.
With TagFly, you can:
- Automatically inject GTM <script> and <noscript> snippets in the correct locations.
- Manage your GTM containers across multiple stores with one dashboard.
- Set up advanced event tracking and conversion pixels, no developer required.
Whether it’s for ads, better analytics, or privacy compliance, TagFly makes sure that your GTM setup is functional, complete, and scalable.
Best practices for using the noscript tag
After 10 years working with GTM implementations for various businesses, I can confidently say that these best practices for the noscript implementation guarantee that tracking is accurate and compliant.
1. Always place after the <body> tag
The <noscript> tag should be positioned immediately after the opening <body> tag to guarantee consistent tracking behavior. If placed somewhere else, like within the <head> tag, it messes up the page structure and invalidates the HTML.
This placement allows the GTM iframe to load early in the browser’s render process. This early load helps to capture pageviews even before JavaScript gets loaded, providing better data integrity for session analytics.
2. Don’t skip it for non-JS users
While quite unusual, such users do exist, mostly in high-security environments. Not providing <noscript> will mean you lose visibility into this select yet important segment.
Noscript-oriented tracking closes any gaps in your funnel. In industries like finance or healthcare, where every session matters, omitting this tag poses a risk to compliance and the accuracy of insights.
3. Keep it clean and unmodified
Use the exact iframe snippet provided by Google; do not resize, style, or add any custom attributes to it. By default, the iframe is set to height=”0″ and width=”0″ with an inline style of display:none, all to keep it invisible and lightweight.
A custom iframe design will cause layout shifts or display bugs on mobile or AMP pages at worst, and will absolutely invalidate the tag and render it ineffective for tracking.
4. Use with consent mode or server-side tagging
Together with Consent Mode v2 or server-side tag deployment, <noscript> is even more crucial because it retains signal data generated under limited cookie availability or regulatory environments.
Such hybrid methods achieve privacy compliance without foregoing essential analytics. They preserve the user’s trust while collecting basic user metrics such as pageviews or bounce rates.
5. Validate after deployment
Whenever a tag is added to a page, its presence must be validated using utilities such as Tag Assistant or Chrome DevTools. Next, confirm it is firing correctly by viewing the source code or testing it in an environment where JavaScript is disabled.
Even a small typo (such as placing it outside <body>) can disable the tag from functioning. QA checks at regular intervals will protect the GTM setup from recording erroneous or unreliable data.
Common Mistakes to Avoid
1. Placing <noscript> Inside the Wrong Part of the Page
Many developers mistakenly place the <noscript> tag at the bottom of the body or in a random location. This reduces its effectiveness, especially if the page loads slowly or fails before the tag executes.
Google recommends that the <noscript> tag should follow immediately after the opening <body> tag, so tracking can still fire if JavaScript fails at this early stage, ensuring that the reliability of the data capture is maximized.
2. Forgetting to Replace the GTM Container ID
Copying a GTM noscript iframe from some documentation snippet is common, forgetting to replace GTM-XXXXXXX with the correct ID is a serious missed step. This means your noscript tag won’t load the appropriate container.
Always check the container ID in the noscript tag to ensure it matches the one in the script tag. If it doesn’t, then the no-script fallback becomes just a silent failure.
3. Duplicating Conversion Tags in Script and Noscript
Some users make the mistake of placing their conversion or remarketing tag both within the standard script and the <noscript> fallback. This duplicate firing inflates metrics such as double conversions or double pageviews.
Use <noscript> only for simple fallback tracking, such as pageviews. Keep advanced or value-based event tracking to pure JavaScript, because then you can properly manage the conditionality.
4. Treating <noscript> Like a Full GTM Alternative
The easiest misconception is to regard noscript as a backup form of GTM, which it is not. Noscript iframes allow no variables, triggers, or data layer logic.
At best, it serves to fire a static image pixel (to register a pageview). Do not expect clicks or dynamic values to be supported via this method.
5. Not Testing Your NoScript Implementation
Most QA processes do not perform testing when JavaScript is disabled, thereby allowing <noscript> errors to pass undetected. Thus, the tracking may have been silently broken for privacy-conscious users.
If you want to test it properly, install browser extensions or developer tools that provide simulated JS-off scenarios. Also, check your analytics for noscript-specific hits, just to be sure.
FAQs About Google Tag Manager Noscript
1. Is the <noscript> tag required for Google Tag Manager to work?
No, but without it, tracking of visits from users with JavaScript disabled might fall through the cracks. For a site heavy on compliance, like a government or healthcare site, that little slip is critical.
2. Does the noscript iframe slow down page performance?
Not at all. It is a small amount of markup that gracefully falls back while loading asynchronously and invisibly in an attempt not to degrade page speed while making for improved data reliability.
3. Does noscript tracking impact GDPR or privacy compliance?
Yes, if not configured properly. Make sure your Consent Mode settings and the tag behavior reflect user preferences, even for iframe-based fallback tracking.
Conclusion
Google Tag Manager Noscript may be viewed as a minor detail, but it’s an important part in the setup, to make sure it doesn’t miss tracking even the tiniest bits of traffic. From those users disabling JavaScript to privacy-focused browsers, this fallback method ensures that data stays reliable and compliant.
Shopify sellers looking to easily set up GTM and manage tags at an advanced level might find TagFly to be right for them: an app and easy-to-use interface that assists in the management of GTM tags, noscript, and conversion pixels-without any code.
Even the coolest setup needs a fallback. Don’t let any data slip through; get noscript right!
