Home / GTM debugger

The GTM debugger for live pages

A Chrome extension that debugs Google Tag Manager by reading what the page really sends — on production, on staging, on a site that is not yours.

Google Tag Manager ships with a debugger: Preview Mode. It is good at one thing and structurally unable to do another. It knows your container — every trigger, every variable, every tag that did and did not fire, and why. It knows nothing about the request that left the browser afterwards, and it will not run at all on a site whose container you cannot open.

Tag Master works from the other end. It watches the network, decodes every tracking request the page sends, and links each one back to the dataLayer push that caused it. That means it debugs GTM on a live page with no preview session, no gtm_debug parameter in the URL, and no access to the container at all.

What Preview Mode cannot show you

Four things, and each one is a category of bug that Preview Mode reports as healthy:

• The request itself. Preview Mode says the GA4 tag fired. It does not say that /g/collect went out with an empty items array, or that the currency was missing, or that two of the parameters were truncated.
• Everything that is not a Google tag. Meta, TikTok, LinkedIn, Criteo, Adobe — most containers fire more non-Google tags than Google ones, and Preview Mode is blind to all of them.
• What happens without a debug session. Preview Mode changes the page: it sets a cookie, adds a parameter and puts the container in debug. Consent banners, A/B tests and bot filters all behave differently under it.
• Anyone else's site. Auditing a competitor, a client before the contract, or your own site from a device where you are not signed in — Preview Mode needs container access. Reading the network does not.

What you see instead

Every dataLayer push in order, and under each one the requests it produced. This is the view that answers the question people actually open a debugger to ask — not "did the tag fire" but "did the right values leave the browser".

Alongside it: the container IDs on the page, the measurement IDs each tag is sending to, the consent state at the moment each request went out, and a flag on any request that carries a parameter the platform's own schema does not accept.

Debug a container in four steps

1. Open the side panel next to the page you want to inspect. Nothing is injected into the page and nothing is recorded until you open it.
2. Reload, then do the thing that is broken — view the product, add to cart, submit the form.
3. Find the dataLayer event in the list. If it is not there, the problem is upstream of GTM and no amount of trigger work will fix it.
4. Open the requests underneath it and read the decoded parameters. This is where a missing value, a wrong currency or a duplicate event_id becomes visible.

From there you can pick the event and generate the GTM variables and trigger for it, which is the part of the job that is otherwise typing paths into GTM by hand.

Server-side GTM

A server-side container moves the collection endpoint to your own domain, which is exactly what makes it hard to debug: the request no longer goes anywhere recognisable. Tag Master detects the first-party endpoint, marks it as server-side, and decodes the payload the same way it decodes a request to Google's own domain.

The detail that catches people out is that a first-party endpoint and a Google Tag Gateway look almost identical from the browser. Which one you are looking at changes where the bug can be.

Where Preview Mode still wins

Trigger logic. When a tag does not fire and you need to know which condition failed, Preview Mode's evaluation view is the right tool and nothing that reads the network can replace it — the reasoning happens inside GTM and never reaches the wire. The two are complements: Preview Mode explains the container's decisions, a network debugger shows their consequences.

The same honesty applies to the rest of the field. Tag Assistant, Omnibug and Analytics Debugger each win a row in the full comparison, and it is worth knowing which before you pick one.

Questions

Can I debug GTM without Preview Mode?

Yes. Preview Mode is required only to inspect the container's own logic. To see which tags fired and what they sent, a debugger that reads the network needs no debug session, no gtm_debug parameter and no access to the container.

Does it work on sites I do not own?

Yes. Nothing is required from the site being inspected — no container access, no code change. This is the difference that makes competitive audits and pre-contract reviews possible at all.

Does it debug server-side GTM?

Yes. The first-party collection endpoint is detected and marked, and its payload is decoded like any other request. A Google Tag Gateway endpoint is reported separately, because the two look alike from the browser and mean different things.

Is it a replacement for Tag Assistant?

For everything except Google's own tags it covers considerably more, including 52 platforms and the consent state behind each request. Tag Assistant remains the tool tied into GTM's own preview session. The full comparison lists the rows each one wins.

Does it send my data anywhere?

No. Captured sessions stay in the browser. There is no account, no telemetry and no server to send anything to.

Guides

The longer form, on the parts that catch people out.

• How to debug GTM without Preview mode — Preview needs container access, changes the page, and only speaks for one container. Here is how to verify GTM from the requests it actually produces.
• How to debug server-side GTM — Why proxied hits vanish from most debuggers, the four signals that reveal an sGTM setup, and how to connect a server preview session.
• One click, three pushes: picking the right dataLayer event — Adding to cart rarely fires one event. What a real storefront pushes, which of them a trigger should use, and the four kinds of push that are never the answer.
• Tag Assistant alternative in 2026 — What Google Tag Assistant is good at, where it stops, and what to use for the tags it will never show you.
• Turning captured dataLayer pushes into a GTM container you can import — What a container export file has to contain, the two fields that make GTM refuse the whole import, and why placeholders beat blanks.
• Debugging Consent Mode V2: gcs, gcd and the violations nobody catches — Read consent parameters straight from the hits, tell a default apart from an update, and find the vendors that fire regardless of what the banner says.

The other two: GA4 debugger, dataLayer inspector