How To Enable Interaction Tracking

The Wheremore pixel collects eligible visitor interactions from the pages configured in Manage Session Tracking. This data supports User Behaviour, Session Replay, Page Engagement and Conversion reporting.

Overview

Installing the pixel is one part of the setup. Interaction tracking works only when all of the following are true:

The website belongs to the active Wheremore workspace.
The page is listed under Tracked URLs.
The Wheremore pixel loads on the live page.
Tracking enabled is switched on for the website.
The selected Cookie or Cookieless mode permits the session.
The visitor does not match an exclusion rule.
Cookie mode has recognised the required analytics consent.

A successful script download confirms installation, but it does not by itself confirm that activity is eligible or has reached a report.

Before you begin

You need:

access to the website’s code, theme, tag manager or custom-code settings;
access to the relevant website in Wheremore;
permission to add pages and change tracking settings;
at least one page to test; and
access to a browser’s developer tools.

If another person manages the website, send them the script and the General HTML instructions below.

The Wheremore pixel

Add this script once to the <head> of the website:

<script data-no-minify="1" data-nowprocket src="https://app.wheremore.com/wp-content/uploads/wheremore/pixel.js" defer></script>

The defer attribute allows the browser to download the script without blocking HTML parsing and runs it after the document has been parsed.

The two data- attributes prevent compatible optimisation tools, including WP Rocket, from copying, rewriting or delaying the Wheremore loader. Browsers and platforms that do not use these attributes safely ignore them.

Customers always install pixel.js . This is a small loader that automatically downloads the current versioned pixel, such as pixel.1.1.15.js . Do not replace the installation URL when Wheremore releases a new version.

Do not add the script more than once. Duplicate installations can generate duplicate listeners or requests and make testing harder.

Complete the Wheremore setup first

Open Manage Session Tracking.
Select the correct workspace.
Select the website.
Add the page you will use for testing, or import it from a sitemap.
Open Settings.
Choose Cookieless or Cookie.
Switch Tracking enabled on.
Review authenticated-user exclusions.
Review excluded URL paths and advanced rules.
If using Cookie mode, configure the relevant consent signal.

The pixel may be installed site-wide, but Wheremore records interactions only on eligible pages in Tracked URLs.

Choose an installation method

Platform	Recommended method
General HTML	Add the script directly inside `<head>`
WordPress	Use a trusted header-code plugin or a small custom plugin
Shopify	Add it to `layout/theme.liquid`
Wix	Use Custom Code and load it on each page
Squarespace	Use Header Code Injection
Webflow	Use site-wide Head code
Google Tag Manager	Use a Custom HTML tag

Platform menus can change. If a label differs, look for the platform’s site-wide Custom code, Header code or Edit theme code area.

General HTML website

Open the shared site template or layout that supplies the page <head> .
Find the closing </head> tag.
Paste the Wheremore script immediately before it.
Save and deploy the change.
Clear server, CDN and page caches.
Confirm the script is present in the live page source.

Add the script to the shared layout rather than editing every page separately.

WordPress

Method 1: Header-code plugin

This is usually the simplest method and normally survives theme updates.

Install and activate a trusted header-code or code-snippet plugin.
Open its site-wide header area.
Paste the complete Wheremore script.
Enable it on the public site.
Save the change.
Clear WordPress, host and CDN caches.

If you use WPCode, the relevant area is normally its header and footer settings. WordPress plugin interfaces can change, so follow the current instructions supplied by the plugin.

Method 2: Custom plugin or theme hook

Developers can add the script through wp_head :

add_action('wp_head', function () {
    echo '<script data-no-minify="1" data-nowprocket src="https://app.wheremore.com/wp-content/uploads/wheremore/pixel.js" defer></script>';
});

Place this in a small custom plugin where possible. A child theme is safer than a parent theme, but theme changes can still affect the installation.

WordPress cache and optimisation

After saving:

purge the page-cache plugin;
clear the host cache;
purge the CDN;
retain data-no-minify="1" and data-nowprocket in the script tag;
exclude wheremore/pixel.js from any additional JavaScript minification, combination or delay rules that still modify it; and
test while signed out of WordPress.

Testing while signed in can be misleading when the WordPress authenticated-user exclusion is enabled.

WP Rocket must leave the Wheremore URL unchanged. If the live page points to a local path under /wp-content/cache/min/ or changes the script type to text/rocketlazyloadscript , clear WP Rocket's cache and confirm the two protective attributes are present in the original installation.

Shopify

Editing theme code should be performed carefully and preferably after duplicating the current theme.

In Shopify admin, open Online Store → Themes.
Open the current theme’s actions menu and select Edit code.
Open layout/theme.liquid .
Find </head> .
Paste the Wheremore script immediately before it.
Save the file.
Open the live storefront and verify the installation.

Do not use a sandboxed custom-pixel feature unless it has been specifically validated with Wheremore. The Wheremore pixel needs access to the live page context and its interactions.

Theme replacement or an incompatible theme update can remove custom code. Recheck the installation after changing theme.

Wix

Open the website dashboard.
Go to Settings.
Open Custom Code under Development & integrations.
Select Add Custom Code.
Paste the Wheremore script.
Give it a recognisable name.
Apply it to All pages.
Choose to load it on each page your visitor opens.
Place the code in Head.
Apply the change and publish if required.

Loading the code only once per visit can miss page initialisation in a single-page navigation flow, so use the per-page option.

Squarespace

Open the website’s code-injection settings.
Locate the site-wide Header field.
Paste the Wheremore script.
Save the change.
Open a live page and verify it.

Code Injection availability can depend on the Squarespace plan. If the option is unavailable, use a supported tag-manager or code-injection method for the site.

Do not treat the Squarespace cookie banner alone as proof that Wheremore Cookie mode recognises consent. Test the actual consent signal and add a custom consent cookie in Wheremore if necessary.

Webflow

Open Site settings.
Open Custom code.
Paste the Wheremore script into Head code.
Save changes.
Publish the website.
Test the published site rather than relying only on Designer preview.

Site-wide Head code applies to the whole published site. The Wheremore defer attribute is already present.

Google Tag Manager

Use this method when the Tag Manager container is already installed correctly.

Open the appropriate web container.
Select Tags → New.
Choose Custom HTML.
Paste the Wheremore script.
Add an Initialization – All Pages trigger, or an appropriate All Pages trigger.
Review the tag’s consent settings against the website’s consent design.
Save the tag.
Use Preview mode to test it.
Publish the container.

Do not use Consent Initialization for the Wheremore tag merely because tracking involves consent. That trigger is intended for tags that establish or update consent state. Wheremore Cookie mode should instead receive the consent state established by the website’s consent platform.

If Tag Manager is configured to require additional consent before the tag fires, ensure this agrees with Wheremore’s Cookie or Cookieless setup. Conflicting conditions can prevent the pixel from loading at all.

Cloudflare and other CDNs

After installing or changing the script:

Purge the affected page or site cache.
Clear any HTML edge cache.
Check whether script optimisation or rewriting is enabled.
Test the original site and any cached version.
Purge the full cache only if a targeted purge does not update the live HTML.

Also clear any cache inside the CMS or hosting platform.

Configure tracking mode

Cookieless mode

Cookieless mode avoids a persistent Wheremore visitor cookie and uses a session-scoped identifier.

It is useful where persistent recognition is unnecessary, but it is not a substitute for deciding and documenting the website’s lawful and appropriate tracking configuration.

Cookie mode uses a persistent visitor identifier for eligible visits. Wheremore waits for a recognised analytics-consent signal before recording in this mode.

Use a supported consent-platform signal or add a custom consent cookie under Manage Session Tracking → Settings → Advanced.

Changing mode

Changing a website’s mode can deactivate active conversion paths. Wheremore warns before doing this because the identity basis of the sessions is changing.

Review and reactivate suitable conversion paths after the change.

Configure exclusions

Before testing, review:

authenticated-user platform presets;
excluded URL paths;
custom cookie-name rules;
cookie-prefix rules;
JavaScript-variable rules; and
Exclude versus Flag mode.

An Exclude rule prevents a matching session from being recorded. A Flag rule retains it for supported downstream use.

Test the website both signed in and signed out. Staff sessions are often excluded intentionally.

Verify the installation

Use a tracked, public URL for the test.

1. Confirm the script is present

Open the live tracked page.
View the page source or inspect the document.
Search for app.wheremore.com or wheremore .
Confirm there is one installation tag pointing to pixel.js .
Confirm an optimisation tool has not replaced it with a locally cached or delayed copy.

2. Confirm it downloads

Open browser developer tools.
Select Network → All.
Reload the page.
Filter for wheremore .
Confirm pixel.js downloads successfully.
Confirm a versioned file, such as pixel.1.1.15.js , downloads from app.wheremore.com .

Seeing both files is expected: pixel.js selects the current versioned pixel. This proves only that the scripts downloaded.

3. Confirm the configuration

In Network, select the request ending in /config .
Confirm it succeeds.
Check that the response contains trackingEnabled: true .
Confirm the test page is represented by the returned allowedUrls configuration.

If /config does not appear, the pixel has not started. If it returns no usable configuration, review the registered website, hostname and tracking settings.

4. Confirm tracking is eligible

Check:

the active Wheremore workspace and website;
the page in Tracked URLs;
Tracking enabled;
the page path against exclusions;
the current signed-in state;
the selected tracking mode; and
consent in Cookie mode.

5. Generate a clean test

Open a private or incognito window.
If using Cookie mode, make the intended consent choice.
Load the tracked page.
Scroll and interact naturally.
Navigate to another tracked page where appropriate.
Leave enough time for ingestion and background processing.

6. Confirm interactions are accepted

In Network, select a request ending in /track .
Confirm the request contains an interactions array and pixel version.
Confirm current interactions include an event_id .
Confirm the response contains status: "success" and acknowledgedEventIds .

Interaction batches contain no more than 25 events. A smaller batch is normal when fewer events are waiting. A successful acknowledgement confirms that the server has finished handling those events; downstream reports may still require background processing.

7. Review Wheremore

Check the relevant User Behaviour, Session Replay or Conversion area. The report may not update immediately.

Content Security Policy

A restrictive Content Security Policy can block either the script or its data requests.

Allow the Wheremore application origin where appropriate in:

script-src , so the pixel can load; and
connect-src , so the browser can send tracking requests.

The exact policy depends on the website’s existing CSP. Ask the person responsible for website security to update and test it rather than copying a generic policy blindly.

What the pixel records

For eligible tracked pages, the pixel can collect the interaction data required for supported features such as:

page visits and navigation;
scroll progress;
clicks and other configured interactions;
device and page context;
session replay inputs; and
conversion-path measurement.

The exact behaviour depends on tracking mode, consent, exclusions and the current Wheremore feature configuration.

Data timing

The browser sends eligible activity during the visit, but downstream reports can rely on background ingestion and processing.

Do not promise that all data will appear within a fixed number of minutes. When validating a new installation, allow for cache propagation and processing before diagnosing a failure.

Troubleshooting

The script is absent from the live page

Confirm the change was saved and published.
Confirm the correct theme, environment or tag-manager container was edited.
Clear CMS, host, CDN and browser caches.
Check whether the code is restricted to particular pages.
Confirm an optimisation plugin did not remove it.

The script request is blocked

Review the browser console and Network result.
Check Content Security Policy.
Check browser privacy extensions.
Check a tag manager’s consent or trigger conditions.
Exclude the script from incompatible optimisation rules.

An optimisation plugin rewrites or delays the script

Confirm the installation uses data-no-minify="1" and data-nowprocket .
Check that pixel.js still loads from app.wheremore.com rather than /wp-content/cache/min/ on the customer website.
Check that its script type has not changed to text/rocketlazyloadscript .
Exclude wheremore/pixel.js from any remaining JavaScript minification, combination or delay settings.
Clear the optimisation plugin, host and CDN caches before retesting.

The script loads but no Wheremore data appears

Confirm the page is in Tracked URLs.
Confirm Tracking enabled is on.
Confirm the URL hostname and path match.
Test signed out.
Review authenticated-user, path and advanced exclusions.
In Cookie mode, confirm recognised consent.
Check for blocked Wheremore connection requests.
Allow background processing time.

The script appears twice

Check the theme, plugin, tag manager and platform integrations. Keep one installation method and remove the duplicate.

WordPress works only while signed out

This may be intentional. Check the WordPress authenticated-user exclusion.

Accept the intended analytics consent.
Verify the consent-management platform’s signal.
Check the custom consent cookie name and accepted values.
Confirm the cookie is readable in the page context.

The basic installation is probably loading. Focus on consent recognition, custom consent values and conflicting tag-manager consent rules.

Data stopped after a redesign or migration

Confirm the pixel remains installed.
Check that live URL paths still match Tracked URLs.
Update tracked pages after URL changes.
Recheck the active theme, CSP, consent manager and exclusions.

Ensure the pixel loads for each page view or route initialisation supported by the platform.
In Wix, choose the option to load custom code on each page.
Review tag-manager history-change or page-view behaviour for the application.
Confirm the destination routes are also tracked URLs.

Frequently asked questions

Does a successful `200` response mean tracking works?

For a script request, it confirms only that the file downloaded. A successful /config response confirms configuration, while a successful /track response containing acknowledgedEventIds confirms that the server finished handling those events. Report processing may still take additional time.

Why do two pixel files appear in Network?

This is expected. The installed pixel.js file is a small loader. It downloads the current versioned pixel, such as pixel.1.1.15.js .

Must the installation URL change for a new pixel version?

No. Keep using https://app.wheremore.com/wp-content/uploads/wheremore/pixel.js . Wheremore updates the loader to select the current version automatically.

Must the script be added to every HTML file?

No. Add it once to a shared site-wide header, theme layout or tag-manager configuration.

Should it be placed before `</body>` ?

The supported Wheremore installation is in <head> using the supplied defer attribute.

Does the script track every page automatically?

No. Pages must be configured in Tracked URLs.

Does the pixel create page screenshots?

No. HTML and screenshot capture are managed separately in Manage Session Tracking.

Can the installation use Google Tag Manager?

Yes, provided the container, trigger and consent settings allow the tag to load correctly.

Does the pixel affect page speed?

The script uses defer so it does not block HTML parsing. Actual impact depends on the website, network and other scripts; verify it with the website’s normal performance testing.

What happens after a theme change?

Recheck the installation. Theme replacement can remove code added directly to a theme.

Which tracking mode should be used?

Choose the mode that fits the required analysis and the website’s consent approach. Wheremore configuration is not legal advice.