How to integrate Unify with Google Tag Manager
To integrate Unify with Google Tag Manager, add the account-specific Unify snippet as a Custom HTML tag, select All Pages, enable document.write support, and publish the container. Verify that the website client initializes once and that activity reaches Unify.[1]
- Connection
- Website tag
- Website tracking
- Tool
- Google Tag Manager
- Unify
- Data flow
- Google Tag Manager → Website → Unify
- Account-specific configuration
At a glance
- Use Custom HTML with the snippet from your own account
- Enable document.write and publish the container
- Check for duplicate initialization and CSP restrictions
When this workflow makes sense
Start with the decision your team needs to make, then choose the connection that supports it.
A website-intent process needs a trustworthy collection path. Before adding another tag, check whether the site already sends activity through a direct Unify installation, Segment, or PostHog. Once collection is intentional, the team can evaluate the account context and decide which visits matter for follow-up.
A good fit when
Teams that manage website scripts through Google Tag Manager and want a deliberate collection path for Unify website intent.
Reconsider the plan when
If the same activity already reaches Unify through another path, resolve the overlap before adding a tag or interpreting event counts.
Design the handoff
Use this framework to agree on the input, the next action, and who owns the result.
Suggested workflow design, based on the documented capabilities below.
| Stage | Decision to make |
|---|---|
| Ownership | Identify the person responsible for the GTM container and the Unify account snippet. |
| Collection path | Inventory existing tags and analytics forwarding before choosing the installation. |
| Validation | Inspect a controlled page visit and confirm that the client initializes once. |
| Activation | Review actual activity before designing the audience or follow-up rule that uses it. |
Explore the scenarios
Choose the situation that fits your team and work through the proposed plan.
Open a scenario to explore its plan. Checklists track your selections in this page only.
Install the tag for the first time
Google Tag Manager already owns the website scripts and no Unify client is installed.
Use the account-specific snippet and publish the correct container. Avoid reconstructing the script from examples.
- Add a Custom HTML tag with the Unify snippet
- Choose All Pages and enable document.write support
- Publish the container and inspect page collection
Audit a site that already has tracking
A site has existing scripts or analytics destinations and you want to avoid counting activity twice.
Inventory the collection paths before adding another tag. Segment and PostHog guides warn about overlap with the Unify Tag.
- Locate any existing direct Unify tag installation
- Check for Segment or PostHog forwarding on the same pages
- Choose the intended collection path and validate it
Illustrative workflow, not a preconfigured automation. Complete these checks in your own account.
Define success before launch
Inspect the data and the intended outcome separately. Connection status is only the first check.
Expected, not tested
The published website loads the Unify client and collects page visits without a duplicate installation.
Check the published container, the browser request to the tag, and resulting activity in Unify. Saving a draft tag is not the same as publishing it.
Documentation-based reference. This workflow has not been tested end to end. Use a record or event you control before enabling live activity.
Questions answered
Common decisions when connecting Unify and Google Tag Manager.
Can I install Unify with Google Tag Manager?
Yes. Unify documents a Custom HTML tag containing the script copied from your Unify settings. Use the documented trigger and publish the container after saving the tag.[2]
Which Google Tag Manager trigger should I use?
The Unify installation guide specifies All Pages. Validate that the published container is installed on the website you intend to track.[2]
Does the Unify tag need document.write support?
Yes. The current Unify website-tag guide explicitly requires document.write support in the tag settings.[2]
Can I keep a second Unify tag in my site code?
The guide says to initialize the Unify client only once. Check the existing installation before adding another copy through Google Tag Manager.[2]
Which domains must a Content Security Policy allow?
The documented additions are https://tag.unifyintent.com in script-src and https://api.unifyintent.com in connect-src. Preserve any other directives your website needs.[2]
Limits & decisions
Check these boundaries before designing a live workflow around the connection.
- Use the snippet generated for your Unify account; no generic executable tag is supplied here
- Publishing and live data collection still need to be tested on your own site
What the connection supports
Understand the connection, the data involved, and the behavior that matters for a Unify + Google Tag Manager workflow.
Custom HTML on your website
| Decision | What to know |
|---|---|
| Tag type | Custom HTML[2] |
| Documented trigger | All Pages[2] |
| Required option | Enable document.write support[2] |
| Initialization | Only one client initialization on the site[2] |
| CSP script-src | https://tag.unifyintent.com[2] |
| CSP connect-src | https://api.unifyintent.com[2] |
Copy the complete website tag from your account. The client automatically collects page visits after installation; additional custom interactions use the separate client usage instructions.
Technical setup reference
References and requirements for the Google Tag Manager connection.
Connection requirements and setup checklist
Before connecting
- Access to the Google Tag Manager container associated with your website
- Permission to publish the container
- The website-tag snippet from your Unify settings and a check for any existing installation
Copy the account-specific tag
Open the Unify website-tag settings and copy the supplied script. Use the account snippet rather than constructing a script URL yourself.[2]
Create a Custom HTML tag
Select the website container in Google Tag Manager. Open Tags → New → Tag Configuration → Custom HTML, then paste the Unify snippet.[2]
Configure triggering and document.write
Choose All Pages under Triggering and enable document.write support as required by the Unify installation guide. Ensure another installation is not already initializing the client.[2]
Publish and inspect
Save the tag and select Submit to publish the container. Visit the website and verify that the tag fires and page activity reaches Unify.[2]
Troubleshooting
Start with the stage where the expected data or action stops appearing.
The tag is saved but does not fire
Check that the correct website container was published with Submit and that its trigger applies to the page you are testing.[2]
The browser blocks the script or its requests
Review Content Security Policy. The guide lists tag.unifyintent.com for script-src and api.unifyintent.com for connect-src.[2]
Visits are counted twice
Check for another Unify client installation. The documentation says to initialize the client only once.[2]
Sources & review
Official documentation reviewed on September 15, 2026.
Technical claims link to primary documentation from Unify and the destination tool. Scenarios, field choices, and recovery plans are editorial implementation examples. Documentation review is separate from execution testing.
Documentation reviewed; end-to-end execution not tested. No named technical reviewer has signed off on these articles yet.
Content updated: . Report a correction to Unify with the tool name, source URL, and behavior you observed.
Keep exploring
