Fix "Failed" or "Still Running" in GTM Tags - Full Guide

When a Google Tag Manager tag shows as “Failed” or “Still Running” in Preview Mode, it often indicates ad blockers, consent issues, or JavaScript errors. This guide reveals how to diagnose and fix these GTM firing status issues permanently.
This can be frustrating, especially when you’re unsure whether the tag fired, failed, or is stuck in the endlessly running cycle.

 

In this guide, we’ll explore both statuses and their most common causes, and we’ll provide step-by-step fixes on how to resolve them.

Understanding both statuses  in GTM’s “Tag Assistant”:

Although both “Failed” and “Still Running” signal an error when firing, both need understanding in what they mean and how to resolve them, in short:

• “Failed” – The tag explicitly reported an error or was blocked.
• “Still Running” – The tag hasn’t signaled completion to GTM.

Both statuses can be misleading—sometimes the tag worked, while other times, it genuinely failed. Let’s break down what each status means and how to troubleshoot them. Before we dive deeper into the actual causes, let’s first break down the meaning behind the firing statuses.

 

What Does “Failed” Mean?

A “Failed” status means the tag either:

• Explicitly signaled a failure (e.g., an API error).
• Encountered an uncaught error (e.g., JavaScript exception).
• Was blocked by a critical dependency, such as:
  • gtag.js is being blocked by an ad blocker.
  • A required third-party API (like Google Ads) is failing to load.
  • A namespace conflict where another script overwrote a global variable.

What Does “Still Running” Mean?

A “Still Running” status means GTM hasn’t received a completion signal from the tag. This could happen because:

• The tag is waiting on a slow-loading resource (e.g., Facebook Pixel).
• It’s stuck in an asynchronous callback (e.g., waiting for window.load).
• There’s an infinite loop in custom JavaScript.

These statuses can sometimes be misleading—a “Failed” tag might have partially worked, while a “Still Running” tag could eventually complete or never finish. The key is knowing how to diagnose and resolve each scenario effectively.

By now, we have some understanding about the meaning of both firing statuses; the next step will be to quickly diagnose the cause, where both “Failed” and “Still Running” have their causes and therefore their solutions.

 

What Can Cause The Firing Status “Failed” (Tag Did Not Fire Successfully)?

The most common causes:

• Incorrect Configuration

• • • Missing or invalid fields (e.g., wrong Tracking ID, event name, or parameter).
    • Misconfigured triggers (e.g., firing on the wrong page or event).
• Blocked by Browser/Extensions
• • • Ad blockers (e.g., uBlock Origin, Ghostery) preventing tag execution.
    • Privacy-focused browsers (Brave, Firefox with strict tracking protection).

• JavaScript Errors

• • • Conflicts with other scripts on the page.
    • Syntax errors in custom HTML/JavaScript tags.

• Network Issues

• • • Slow or interrupted connections causing timeout failures.
    • Third-party endpoints (e.g., Facebook Pixel, Google Analytics) being blocked.

• Trigger Conditions Not Met

• • • Triggers set up incorrectly (e.g., firing on a URL that doesn’t match).
    • Dependent variables returning undefined.

• GTM Container Not Published

• • • Changes not published, or an older container version is still active.

• Cross-Domain Restrictions

• • Tags requiring cross-domain access without proper CORS headers.

What Can Cause The Firing Status “Still Running” (Tag Has Not Completed Execution)?

The most common causes:

• Slow-Loading Tags
  → Third-party scripts (e.g., Facebook Pixel, Hotjar) taking too long to load.
• Asynchronous Delays
  → Tags waiting for callbacks (e.g., window.load, dataLayer.push) that haven’t resolved.
• Infinite Loops
  → Custom JavaScript tags stuck in recursive logic.
• Tag Dependencies Not Met
  → Tags relying on other tags/variables that haven’t executed yet.
• Browser Performance Issue
  → Heavy page scripts delaying tag execution.
• GTM Throttling
  → Too many tags firing simultaneously, causing delays.

We’re referring to “False negatives”; yes, you received “Failed” or “Still Running” in Tag Assistant, while everything is in order – or at least will be in the long run. If you’ve checked all other options and still receive one of the statuses. This can be due to an error in Tag Assistant that made our jobs sometimes quite annoying in Q1 and Q2 of 2025, but it seems this error lies mostly in the past.

The other reasons can lie in the fact that consent mode needs time to truly and fully implement; this process can sometimes take months for websites with lower ad spends. Also, this can be due to implementing a high amount of different conversions/events at once, and the running campaigns struggle to fully track all conversion/event goals.

The platform we see this issue the most with is Google Ads (GAds), and the fact that the GAds “Diagnostic” tab under “Goals” shows the message “Consent mode is active!” doesn’t give you a clear signal of what the level of consented data is at the conversion level. GAds can give the all clear signal on account level, but a new conversion can still give issues…in “False Negatives”.

Before we jump into the solution to solving the “False Negatives”, here is a detailed explanation on how to solve the other possible causes for “Failed” or “Still Running”.

 

Solutions for “Failed” and “Still Running” Tags in Google Tag Manager

Now that we’ve covered the common causes behind these frustrating firing statuses, let’s dive into actionable solutions for both “Failed” and “Still Running” tags.

How to Fix “Failed” Tags in GTM:

• Incorrect Configuration

• • Problem: Typos, wrong IDs, or misconfigured triggers can cause tags to fail.
  • Solution: Double-check all fields (e.g., Google Ads Conversion ID, GA4 Measurement ID).
  • Test with GTM Preview Mode (Tag Assistant) to confirm the trigger fires as expected.
  • Use GTM Variables (e.g., {{GA4 Config}}) instead of hardcoded values.
  • Pro Tip: For Google Ads conversions, ensure:
    • The Conversion ID and Conversion Label match those in Google Ads.
    • If using dynamic values (e.g., transaction IDs), validate them with “console.log()”.

 

• Blocked by Browser/Extensions

• • Problem: Ad blockers (uBlock Origin, Ghostery) or privacy settings prevent GTM from loading.
  • Solution: Test in Incognito Mode (Chrome: Ctrl+Shift+N / Command+Shift+N).
  • Check Chrome DevTools > Network Tab for blocked requests. 
    • Filter for: googletagmanager.com, google-analytics.com.
    • If requests show (blocked: extension), disable extensions one by one.
  • Whitelist Domains (for corporate networks):
    • *.google-analytics.com
    • *.googletagmanager.com
    • *.doubleclick.net

• JavaScript Errors

• • Problem: Syntax errors or conflicts with other scripts break tag execution.
  • Solution: Open Chrome DevTools > Console for red error messages.
  • Debug Custom HTML Tags:
    Wrap code in try/catch blocks
  • Avoid Global Variable Conflicts: If using “gtag()” or “fbq()”, ensure they’re not overwritten by other scripts.

 

• Network Issues

• • Problem: Slow connections or third-party API failures (e.g., Facebook Pixel timeout).
  • Solution: Check Network Requests:
    • Look for “status:failed” or “ERR_CONNECTION_TIMED_OUT”.
  • Use a Fallback Trigger:
    • Example: Fire a backup pixel if the primary one fails after 3 seconds:

 

 

• Cross-Domain Restrictions (CORS)

• • Problem: Tags blocked due to missing “Access-Control-Allow-Origin” headers.
  • Solution: Check console for “CORS Errors”:
    • Example: Blocked by CORS policy: No “Access-Control-Allow-Origin” header.
  • Workaround:
    • For self-hosted scripts, add CORS headers on your server: “Access-Control-Allow-Origin: *”

How to Fix “Still Running” Tags in GTM

• Slow-Loading Third-Party Scripts

• • Problem: Tags like Facebook Pixel or Hotjar take too long to load.
  • Solution: Check Network Tab for Pending Requests:

• Filter for facebook.net, hotjar.com, etc.
• Optimize Loading: Use GTM’s Tag Sequencing to delay non-critical tags. Set a Timeout (e.g., 5s) to force completion:

 

 

• Consent Mode Delays

• • Problem: Tags wait indefinitely for” ad_storage” or “analytics_storage” consent.
  • Solution: Check “gcs Parameter” in “Network Requests” in the devTools:

• gcs=G100:
  Consent denied or user did not interact with the consent banner, the “G100” status is also known as the “Modeling State” or “Advanced Implementation” of Google’s Consent Mode V2. In this state, tags may stay in “Still Running“.
• gcs=G111:
  Consent granted, both GAds and GA4 received consent, and tags should fire without any problems.

• Force Consent for Testing:

 

 

• Missing Callbacks in Async Tags

• • Problem: Custom HTML tags with “setTimeout” or “API calls” never signal completion.

Solution: Add “onHtmlSuccess()” manually:

 

 

• For GA4/Ads Google Tags

Use “event_callback” to confirm execution:

 

 

• Page Redirects Interrupting Tags

• • Problem: Tags fired during a redirect (e.g., thank-you page) get cut off.
  • Solution: Enable “Wait for Tags” in GTM:

• Set a 1000–2000ms delay for link/click triggers.
• Use “hitCallback” for GA4:

 

 

Handling “False Negatives”

Now to come back to the “False Negatives”, where GTM’s preview mode “Tag Assistant” reports “Failed” or “Still Running” – even though the tag succeeds (without telling you). If you’d let it run, you’d see that the platform actually will measure conversions/events.

The first thing to check is if the error occurs on all tags with the same trigger (e.g., the GAds purchase reports “Failed” or “Still Running”, but the GA4 purchase tag reports “Succeeded”). When there is a discrepancy in firing statuses for the same trigger, you have a clear signal that the tag with the “Failed” or “Still Running” might be totally fine.

Still, to not fly blind, there is a good way to see if the tag works as intended. Here’s how to verify:

• Check Chrome DevTools > Network Tab
  • Filter for “Tracking Endpoints”:
    • GA4: “/g/collect”
    • Google Ads: “/pagead/conversion” or conversion label (e.g., waENOc1okDhtV4CJ6c6b)
    • Facebook: “/tr/?id=123”
  • Look for status:200 → The tag worked, but GTM didn’t register it.
• Validate in Backend Reports
  • GA4 DebugView: Confirm events appear in real-time.
  • Gads Conversions: Check for recorded conversions.
• Ignore GTM’s Status If:
  • Network requests succeed.
  • Data appears in backend reports.

 

Conclusion

“Failed” and “Still Running” tags in GTM can stem from misconfigurations, ad blockers, consent delays, or async issues. Always verify with DevTools and backend reports—GTM’s Preview Mode “Tag Assistant” isn’t perfect.

By following this guide, you’ll resolve 95% of firing status issues and ensure your tracking works reliably.

You’ll find all the scripts used in this post in the downloadable file!

Happy tagging!