How to monitor and audit tags with Google Tag Manager

Author:

Monitoring and auditing tags with Google Tag Manager (GTM) is a crucial part of ensuring that your tags are firing correctly and providing accurate data. A robust monitoring and auditing process can help you identify potential issues, such as tags not firing as expected or conflicting tags that might cause inaccurate tracking. Here’s a guide on how to effectively monitor and audit your GTM tags:

1. Use GTM’s Built-in Preview and Debug Mode

The Preview and Debug mode in GTM allows you to test and troubleshoot the tags you’ve set up before they go live.

Steps to Use Preview and Debug Mode:

  1. Enable Preview Mode:
    • Log into your Google Tag Manager account.
    • Select the container you want to test.
    • Click on “Preview” in the upper-right corner of the GTM interface.
    • Enter the URL of the website where you want to test the tags, and click “Start”.
  2. Inspect Tags and Triggers:
    • Once Preview Mode is enabled, you’ll see a debug panel at the bottom of your website page.
    • This panel displays detailed information about each tag, including whether it has fired, when it fired, and which triggers caused it to fire.
    • You can review each tag’s execution in the “Tags Fired” and “Tags Not Fired” sections.
    • Use the “Variables” tab to inspect all available variables for debugging.
    • The “Errors” tab will show if any tags failed to fire, helping you identify potential problems.
  3. Test Different Pages and Events:
    • Navigate through various pages or interact with elements on the site that should trigger specific tags (such as form submissions or button clicks).
    • Ensure that tags are firing correctly for each action and page view.
  4. Debugging:
    • If a tag isn’t firing as expected, review the trigger conditions to ensure they are correctly set.
    • Use the “Preview Mode” console to see the order in which tags are firing and make adjustments as needed.

2. Leverage Tag Assistant (by Google)

Tag Assistant is a Chrome extension that helps you verify that the correct tags are installed on your website and that they are firing as expected. It also checks for errors or misconfigurations.

Steps to Use Tag Assistant:

  1. Install the Tag Assistant Extension:
    • Download and install the Tag Assistant (by Google) extension from the Chrome Web Store.
  2. Activate Tag Assistant:
    • After installation, click on the Tag Assistant icon in your browser toolbar.
    • Click “Enable” and refresh the page you wish to check.
  3. Check Tag Firing:
    • Tag Assistant will show you which tags are firing and will alert you if there are issues like missing tags, incorrect configuration, or conflicting tags.
    • You can click on any tag to get additional details about its status and performance.
  4. Audit for Common Issues:
    • Look for warning signs such as “Multiple Tags Firing”, “Failed Tags”, or “Unverified Tags”.
    • Use the insights from Tag Assistant to improve tag setup in GTM.

3. Audit Tags Using Google Analytics Real-Time Reporting

If your tags are set up to track data for Google Analytics, you can use Google Analytics’ Real-Time reporting to monitor if the tags are sending data as expected.

Steps to Monitor Real-Time Data:

  1. Go to Google Analytics:
    • Log into your Google Analytics account.
    • Select the property you are monitoring.
  2. Use Real-Time Reports:
    • Navigate to Real-Time > Overview to see if data is coming through from your website.
    • You can also use Real-Time > Events to monitor specific events like button clicks or form submissions that are triggered by your GTM tags.
    • If you see events being tracked, it indicates that your tags are firing correctly.
  3. Cross-check with GTM Preview:
    • Use Google Analytics alongside GTM’s Preview Mode to cross-reference tag firing and event data. If a tag fires correctly in Preview Mode but no data appears in Google Analytics, it could be a tracking issue within Analytics itself.

4. Use Google Tag Manager’s Version History for Audits

GTM keeps a version history of all changes made to your container. This can be helpful for auditing and tracking the changes made to tags, triggers, and variables over time.

Steps to Use Version History:

  1. Access Version History:
    • In GTM, go to the “Admin” tab and select “Version History” under the container settings.
    • Here, you’ll see a list of all the versions, including details of each version (who made the change, when, and what was changed).
  2. Compare Versions:
    • Select different versions to compare changes made between them.
    • Look for any unintended modifications that might have impacted tag firing.
  3. Restore Previous Versions:
    • If something goes wrong after a recent change, you can restore a previous version of the container that was working properly.

5. Use Data Layer Monitoring

The Data Layer is a critical part of GTM because it stores data that tags use to trigger actions. Monitoring the data layer is essential for ensuring that the correct data is being passed to your tags.

Steps to Monitor the Data Layer:

  1. Enable Data Layer Debugging in Preview Mode:
    • When in GTM’s Preview Mode, you can use the Data Layer tab to see what values are being pushed to the data layer.
    • Look for key values that should be passed to your tags (like user data, page information, event names).
  2. Check Data Layer with Browser’s Developer Tools:
    • Open the Developer Tools in your browser (usually by pressing F12).
    • Go to the Console tab and type dataLayer to inspect the array of data that is being passed to GTM.
    • Verify that the correct data is being pushed at the right moments.
  3. Set Up Data Layer Variables in GTM:
    • Make sure that GTM is correctly configured to use the data in the data layer.
    • Use the Variables section in GTM to create variables that pull data from the data layer and use them in triggers or tags.

6. Regularly Review and Test Triggers and Tags

A critical part of auditing tags is regularly reviewing their setup and triggers to ensure they are still relevant and functioning correctly.

Steps for Ongoing Auditing:

  1. Test Tags After Website Changes:
    • Every time significant updates are made to the website (new pages, changes in layout, updates to forms), retest your GTM tags to ensure they are still firing as expected.
  2. Set Up Custom Alerts in Google Analytics:
    • You can set up custom alerts in Google Analytics to notify you when unexpected data spikes or dips occur. This can be an indicator that a tag has stopped working or is firing incorrectly.
  3. Periodic Audits:
    • Schedule regular audits to review all GTM tags, triggers, and variables. This helps ensure the setup remains optimal and identifies any issues with firing or missing data.

Conclusion

Monitoring and auditing tags in Google Tag Manager is essential for ensuring accurate data tracking and efficient website performance. By using GTM’s Preview and Debug Mode, Tag Assistant, Google Analytics, version history, and data layer monitoring, you can ensure your tags are working correctly. Regular testing and audits will help maintain the integrity of your tracking setup and allow you to catch potential issues before they affect your data.

Categories: Digital Marketing