If your Chrome toolbar still shows the old Tag Assistant, it's dead. Google replaced it with the new Tag Assistant, which now opens in its own full page, plus a companion extension that verifies what tags fired on the page you're on.
This guide sorts the working GTM extensions by what you're trying to do: debug a GA4 event, read what a site pushes into its dataLayer, or confirm a Meta Pixel actually fired. You'll get a comparison table, a decision path for picking one in under a minute, and clear warnings on abandoned tools so you don't waste an afternoon on an extension nobody has updated since 2019.
The path in 6 steps
The steps of this page, in order.
-
01 Name your task Debugging a tag, reading the dataLayer, or validating a pixel lead to different extensions.
-
02 Skip dead tools Tag Assistant Legacy and several community extensions are no longer maintained and won't see current GTM features.
-
03 Start with Preview mode GTM's built-in Preview often answers the question before you install anything.
-
04 Add one extension Pick the single extension matching your task instead of stacking five at once.
-
05 Check server-side limits Browser extensions see the browser, not what happens in a server-side container.
-
06 Test on a real page Verify on a staging or low-traffic URL before trusting the extension's output.
01 / 12
Which GTM extension should you actually install?
For most people, two extensions cover everything: Google's official Tag Assistant Companion for checking what fired, and one dataLayer tool for reading what the page pushed.
Start with Google's official Tag Assistant and its Companion extension: both are free, maintained by Google, and show you which tags actually fired. Add one community extension only when you hit a specific gap, such as wanting a readable dataLayer feed inside DevTools.
Remember the dataLayer is a JavaScript array on the page that pushes structured data GTM reads to fire tags. If your container runs server-side, no Chrome extension can see inside it, browser tools stop at the browser.
Minimalist stack
Google Tag Assistant plus its Companion extension, nothing else. Right for small teams that only need to confirm which tags fired on a page.
- Cost
- Free
- Maintained by
- Best for
- Checking tag firing
Key pointInstall Tag Assistant Companion from the Chrome Web Store and pin it.
Analyst stack
Tag Assistant Companion plus one dataLayer inspector extension. Suits analytics specialists who need to read what the page pushes before GTM acts on it.
- Cost
- Free to install
- Adds
- Readable dataLayer feed in DevTools
- Best for
- Debugging events and variables
Key pointPick one dataLayer tool and keep it as your single source of truth.
Pixel-focused stack
Tag Assistant Companion plus an extension that validates a specific pixel, such as Meta or TikTok. Fits marketers who verify ad platform signals rather than site analytics.
- Cost
- Free to install
- Adds
- Per-platform pixel verification
- Best for
- Ad and conversion tracking checks
Key pointOnly add the pixel extension matching the platforms you actually run.
02 / 12
What happened to the old Tag Assistant?
The legacy Tag Assistant extension was retired by Google and replaced by a new Tag Assistant that opens on its own page, paired with a companion extension in Chrome.
Tag Assistant Legacy was the old Chrome extension that monitored whether tags fired, that is, whether they actually sent their request to GA4, Meta, or another endpoint. Google stopped supporting it, and tutorials written before 2022 that tell you to install "Tag Assistant (by Google)" are describing that retired tool. It cannot see tags the way today's Google tools do.
The current Tag Assistant opens as a full page instead of a popup, so it can track more sessions and cross-page journeys while its companion extension watches the tab you are testing. On pages that still mention Tag Assistant Legacy or other abandoned extensions, check the vendor's current documentation before installing anything.
Tag Assistant Legacy
The retired Chrome extension once installed from the Chrome Web Store to check whether tags fired on a page. It no longer receives updates, and its checks do not match how Google Tag Manager debugging works today.
- Status
- Retired and no longer supported by Google
- What it sees
- Limited to the toolbar popup and the tab it was opened on
- Use instead
- Google's current Tag Assistant web page with its companion extension
Key pointRemove it from Chrome so nobody on your team debugs with outdated readings.
Current Google Tag Assistant
Google's official replacement runs as a full web page, so verification happens on a separate tab while a small companion extension watches the page under test. It follows sessions and journeys the old popup could not display.
- Status
- Actively maintained by Google
- What it sees
- Tags, triggers, and dataLayer events across multiple pages in one session
- Setup
- Companion extension in Chrome plus the Tag Assistant page in another tab
Key pointMake this pair your default first check before reaching for any third-party extension.
Going further
Why the switch
Concept
Why Google moved debugging out of the extension popup
Google moved Tag Assistant from a toolbar popup to a full page because a popup cannot hold enough session data to debug modern, multi-page tracking.
A toolbar popup is a small window that closes as soon as you click elsewhere in the browser. That design works for a quick check on one page, but it cannot stay open while you move through a checkout flow, a login sequence, or any journey where tag firing depends on what happened two pages earlier. The full-page Tag Assistant keeps that context alive, which is why it opens in its own tab.
When a tutorial shows a popup interface with a blue or green icon and no separate page, it describes the retired tool. Checking the current Google Tag Assistant help page before following any tutorial is the quickest way to avoid debugging against a tool Google no longer maintains.
- Check the interfaceIf your tool opens entirely inside the toolbar popup, it is the legacy extension.
- Check the URLThe current Tag Assistant serves its interface from a Google web page, not from an extension popup.
- Check the tutorial dateAny guide written before 2022 likely refers to the retired extension and its instructions may not match what you see.
- Check the sourceConfirm against Google's official Tag Assistant help page rather than a third-party blog post.
03 / 12
How do you see what a website pushes into the dataLayer?
The two names that come up most are Adswerve's dataLayer Inspector+ and Analytics Debugger, and they aim at slightly different jobs.
Open DevTools and watch the dataLayer, a JavaScript array on the page where a site pushes structured data that GTM reads to fire tags. Adswerve's dataLayer Inspector+ turns those pushes into a readable feed next to outgoing requests, so you see the event name and its parameters as the page sends them.
Analytics Debugger logs each analytics hit with the details it carried, which is useful when a dataLayer push looks right but the tag still fires wrong. Both are third-party tools, so check the 'last updated' date on the Chrome Web Store listing before you depend on them.
Adswerve dataLayer Inspector+
- Reads dataLayer pushes and outgoing requests in one feed inside DevTools
- Separates events clearly so you can scan what the page sent
- Focused on inspection, not on the full tag-firing picture
- Third-party listing, so check the last-updated date
Pick this when the question is 'what did the page push?'
Analytics Debugger
- Logs analytics hits and the details each hit carried
- Useful when a push looks right but the tag fires wrong
- Shows hits rather than the raw dataLayer array
- Third-party listing, so check the last-updated date
Pick this when the question is 'what did the tag actually send?'
Going further
See a debug session
Method
A concrete GA4 event debug session
A GA4 event debug session: read the push, then confirm the event name and parameters reached GA4.
A typical case: you expect a purchase event with items and value. Open DevTools with the extension active, trigger the action, and find the push in the feed. Check the event name and the parameters you care about, if a parameter is missing here, the tag can't send it.
Then follow the hit in the analytics log. The hit should carry the same event name and parameters. A mismatch means a tag setting, not the page, is dropping or renaming the value. Fix the tag or the push, reload, and repeat the check until the log matches.
- Event nameConfirm the push and the hit use the same name.
- ParametersCompare each parameter you expect in the push against the hit log.
- OrderA push after the tag fires won't be picked up; check timing when values look empty.
04 / 12
Which extension validates a specific pixel?
Pixel validation is a per-platform job: each ad or analytics vendor has its own checker, and TagHound reads tag presence more broadly.
Tag firing is the moment a tag actually sends its request to a platform like GA4, Meta, or a custom endpoint. Meta Pixel Helper confirms what Meta itself received from the page, which can differ from what your GTM container says it fired. TagHound, by contrast, scans the page and reports every tag it detects, which helps when you inherit a site and don't know what's installed.
Run a real check: fire a test event in GTM Preview, then open Meta Pixel Helper and confirm the matching request appears in its list. If it doesn't show up, the problem sits between the trigger and the network request, not in the pixel itself. Use these tools to confirm the final request rather than to debug GTM's internal trigger logic.
component sem obje…Meta Pixel Helper
- Shows the exact parameters and events Meta received, including the pixel ID and event name
- Flags common install problems such as a missing pixel or duplicate fires in plain language
- Covers Meta's own tags only, so it tells you nothing about GA4, TikTok, or a custom endpoint
- A green check means Meta received something, not that your GTM trigger logic is correct
For anyone running paid social on Meta who needs to confirm the ad platform's own data.
TagHound
- Scans the page and lists all detected tags regardless of vendor, useful on an inherited site
- Its Chrome Web Store listing and vendor documentation describe detection and reporting as its core function
- Detection is broad rather than deep, so it does not replace a platform-specific checker for parameter-level detail
- It cannot see inside a server-side container, so server tags stay invisible to it
For audits and discovery, when you need a map of what is on a page before you debug anything.
05 / 12
Preview mode or extension: which one first?
Preview mode should almost always be your first stop, because it shows why a tag did or didn't fire; extensions verify what the browser and vendors received afterward.
Preview mode lives inside GTM: it shows which triggers matched, how variables resolved, and whether a tag moved on to fire. Tag firing is the moment a tag sends its request to GA4, Meta, or your custom endpoint. A browser extension, by contrast, sees the network requests that left the page.
That is why the two tools are not interchangeable. A rejected vendor request or a consent-blocked pixel never appears in Preview mode, only in the network layer. Meanwhile, trigger-match logic and variable resolution are invisible in an extension.
Preview mode vs. extensions: what each layer sees
| Layer | Preview mode | Browser extension |
|---|---|---|
| Trigger matches and variable values | Yes, shows which triggers matched and what variables resolved | No, extensions see requests, not GTM's internal logic |
| Tag firing | Shows whether a tag progressed to fire, and why not | Confirms the request actually left the browser |
| Network request contents | Not visible | Yes, inspect payloads, headers, and vendor responses |
| Server-side containers | Preview works inside the GTM container; server-side tags appear in server preview | Cannot see any request handled inside a server container |
| Consent Mode | Shows how consent state affects trigger evaluation | Shows whether tracking requests fired or were blocked at the browser level |
| Best for | Debugging trigger logic, sequencing, and variable resolution | Verifying that a platform received what you expected |
A browser extension cannot inspect a server container or replace GTM's own preview; use each layer for what it can actually see. Compatibility with server-side tagging and Consent Mode is as described in vendor documentation and dated to the Chrome Web Store listing.
06 / 12
Adswerve dataLayer Inspector+: how it works and who it is for
Adswerve's dataLayer Inspector+ is a free Chrome extension that surfaces what a page pushes into the dataLayer and what happens in Google Tag Manager, aimed at analysts and developers who debug tags in the browser console.
Inspector+ opens a console panel that logs dataLayer pushes, GTM events and outgoing requests as you browse, so you can read the page's tracking flow without switching tabs. It is a browser-side tool only: a Chrome extension cannot look inside a server container, and consent signals it reports reflect what reaches the browser, not what happens after a server-side tag fires.
Adswerve dataLayer Inspector+
A free Chrome extension from Adswerve that shows dataLayer pushes, GTM events and browser requests in a console panel.
- Purpose
- Inspect dataLayer activity and GTM events from the browser console
- Vendor
- Adswerve, a Google Marketing Platform partner
- Price
- Free to install; check the Chrome Web Store listing for current terms (dated Nov 2026)
- Main limits
- Browser-side only: no view inside server containers, no PII masking, no team sharing
- Shows dataLayer pushes and GTM events in a live console log, which speeds up debugging on a page you are testing
- Adds request-level visibility that helps confirm whether a tag fired and where the request went
- Free to install, so there is no budget approval needed to try it
- Useful on pages where you do not control the container or do not have Preview access
- It is a browser extension, so it cannot inspect server-side containers or what happens after a server tag runs
- Console output can get noisy on heavy pages, and you still need to know what you are looking for
- No team features: no shared recordings, notes or permissions, so findings are hard to hand off
- It reflects browser-side consent signals only, not the full consent picture
A good fit for an analyst or developer who needs a quick, free, browser-based view of dataLayer pushes and GTM events, as a complement to GTM Preview rather than a replacement.
07 / 12
Analytics Debugger: how it works and who it is for
Analytics Debugger is a free Chrome extension that logs hits sent to Google Analytics and similar endpoints in a plain table, so you can confirm a tag actually fired without opening DevTools.
It watches outgoing requests from the page and prints them as rows: hit type, tracking ID, event category and parameters. You click one row to see the payload a tag sent to the analytics endpoint.
Its weakness is scope. It only shows what leaves the browser, so it can't prove that a server-side container received or processed anything.
Analytics Debugger
A Chrome extension that displays outgoing analytics hits from the current page in a readable log.
- Category
- Request and hit inspection
- Best at
- Confirming that a GA-style hit left the browser, and reading the parameters attached to it
- Works with
- Hits sent from the page to analytics endpoints; limited by what the vendor documents for the current version
- Pricing
- Free to install at the time of writing (Chrome Web Store listing); any paid tier would be an order of magnitude only
- Readable per-hit log instead of raw Network panel noise
- Useful when a tag fires in Preview but you still doubt the payload
- No GTM container setup required to start checking hits
- Cannot see activity inside a server-side container
- Blind to tags that fail before sending a request
- Does not verify Consent Mode behavior on its own
Best for analytics specialists who need to confirm that hits are actually leaving the page with the right parameters, and who already have another tool for container-level debugging.
08 / 12
TagHound and GTM Variable Builder: how it works and who it is for
TagHound and GTM Variable Builder are two complementary free extensions: one scans a page and reports every tag, pixel and cookie it finds, the other scrapes live values off the DOM to generate ready-to-paste GTM variables.
TagHound runs a passive audit in your browser: it lists every request, script, cookie and pixel the page fires, without you opening DevTools. GTM Variable Builder reads CSS selectors, data attributes and text nodes on the rendered page and writes the matching GTM variable code for you, cutting manual selector work to seconds.
09 / 12
Which extension fits your exact task?
Sort the extensions by task, check what fired, read the dataLayer, validate a pixel, or scan an unknown page, and the choice becomes obvious.
Start from the task, not the tool. If you need to know what fired, official Tag Assistant plus Companion covers it. If you need to read what the site pushes into the dataLayer, a dataLayer inspector is the pick. For vendor receipt, use the vendor's checker.
Two extensions rarely mentioned earn a slot in serious audits. GTM Variable Builder creates GTM variables from values already on the page, and Consent Mode Monitor checks the consent state tags actually received. Remember one limit: with server-side tagging, requests are processed on a server you control, and a browser extension cannot see inside that container.
Confirm what you need to see
If the question is whether a tag fired, use official Tag Assistant. An extension that only reads the dataLayer will not confirm the network request.
Pick the layer you are inspecting
For values a site pushes into the dataLayer, use a dataLayer inspector. For data a vendor received, use that vendor's own checker, such as Meta Pixel Helper.
Match the tool to the page you inherited
On an unfamiliar site, run a scanner like TagHound to build a starting list of tags before you debug anything specific.
Check the less obvious cases
GTM Variable Builder turns values already on the page into GTM variables, and Consent Mode Monitor shows the consent state tags actually received. Server-side containers stay invisible to any extension.
10 / 12
Is it safe to add third-party extensions?
Any extension that can read page data is a trust decision, and some abandoned ones have quietly changed owners, so review permissions and uninstall what you don't use.
Every extension that reads page data can also read what you are logged into, so treat installation as a trust decision. Open the Chrome Web Store listing and check three things: the publisher, the permissions requested, and the last-updated date. A “read and change all your data on all websites” scope is normal for debugging tags, but an extension that has not been updated in over a year is a maintenance risk.
Prefer Google's own extensions for core checks and keep third-party tools single-purpose. Never paste production credentials or customer data into an extension's UI. Note that the current platform is Manifest V3, which replaced the older Manifest V2; extensions still built for V2 no longer run in Chrome and may appear abandoned.
Permissions match the job
A tag debugger needs to read page requests and cookies. Anything asking for your browsing history, downloads, or clipboard is doing more than the task requires.
Last update is recent
Check the “Updated” date on the listing. A tool untouched for over a year can break when Chrome changes the extension platform, and abandoned extensions have historically changed owners.
Publisher is verifiable
Confirm the developer name links to a site or repository you can inspect. Unverified publishers with copied names are the main vector for extensions that quietly start collecting data.
You have a removal plan
Note which of your team members installed it and why, so you can disable it in one step if permissions change. Uninstall extensions you no longer need instead of leaving them idle.
11 / 12
How do you roll this out on your team without chaos?
Standardize on a small stack, test on staging first, and document what each extension is for so teammates don't install five overlapping tools.
Keep the stack small: the built-in preview mode for tag firing checks, plus at most two task-specific extensions for dataLayer work or pixel validation. Anything else is a personal install, not a team standard. Before you trust a result, run the test on a staging or low-traffic URL, because server-side tagging hides requests a browser extension cannot see. Write the extension name, version, and purpose in your analytics runbook, then re-check it after each Chrome update. That record is what stops a new hire from installing five overlapping tools on day one.-
Choose the stack
Agree on preview mode plus a maximum of two extensions, matched to your team's recurring tasks.
-
Test on staging
Reproduce the tag setup on a staging or low-traffic URL and inspect the output there, never on a live campaign page.
-
Verify with the vendor
Confirm the tag really fired in GA4, Meta, or your endpoint before you change any live configuration.
-
Document and review
Log each extension's name, version, and purpose, and revisit the list after major Chrome or GTM updates.
12 / 12










