Exclude duplicate page view image beacon events

Hi @dineshrkumar 

Out of the box there isn't a feature that dedupes page view events.
If your page view event fires multiple times, each beacon will be counted as a separate server call, unless you implement a strategy to dedupe or prevent multiple calls from firing.

A possible solution you could consider is to use a custom flag to check if page views have fired and only fire the event if the flag is set to false, although this would get complex with an SPA. 

Another possible solution is to add a unique identifier to each page view and use processing rules and segments to filter out the duplicated hits, this isn't really recommended as it would be best practice to fix the cause of the issue of the duplicate page loads and not just hide the issue.

Thanks,

Dan

Hi @dineshrkumar ,

I would probably start with detecting the cause of multiple server calls as it leads to unnecessary increase in the server call volume hence the license cost. One potential issue could be using Send Beacon method as well as s.t() call in the custom code or page code. You can write s.t() in console to validate if it is sending only one server call or two to determine if the issue is coming through page. Are both calls exactly identical with no difference?

There is s.abort() method that exists to abort the server call but I have not personally used it so can't advise on implementation. You can refer below articles for more info on this.

https://experienceleague.adobe.com/en/docs/analytics/implementation/vars/config-vars/abort

https://webanalyticsfordevelopers.com/2013/09/03/the-s-abort-flag/

In any case, I would suggest to first try to eliminate duplicate server calls if possible.

Best,

Isha

Hi @dineshrkumar 

Adobe Analytics doesn’t offer a built-in way to automatically dedupe duplicate page view beacons, each server call is counted, even if identical. So the best approach is to identify and fix the root cause of the duplicate firing.

I’d suggest starting by checking the implementation to see if both s.t() and a sendBeacon call are triggering, or if the tracking code is loading more than once (especially common in SPAs or tag misfires). You can test this via the browser console or Network tab and compare payloads.

If preventing it isn’t immediately possible, a workaround could be setting a custom flag to prevent multiple s.t() calls on the same page load. You could also technically filter out duplicate hits using processing rules or segmentation, but that’s more of a patch than a fix and not always reliable.

Hope that helps!

Hi @dineshrkumar , I agree with @isha__gupta @vinay_chauhan @danims1 .

Unfortunately, Adobe Analytics itself doesn't have an explicit built-in function like "deduplicate" at the Analytics reporting backend after the beacon has been collected.

However, there are efficient and recommended approaches to prevent duplicates at collection time (client-side) or mitigate impact through data processing rules or post-processing:

Recommended Approaches to Prevent Duplicate Page Views:

JavaScript Flag (Client-Side Prevention)

if (!window.pageViewSent) {
window.pageViewSent = true;
s.t(); // Adobe Analytics page view beacon firing
}

• How it works:
  You set a JavaScript global flag (pageViewSent) after the first beacon is sent. Subsequent calls to s.t() (page views) won't fire again during the page lifecycle.

• Where to implement:
  Inside your Adobe Launch rules or directly in your page's JS logic that triggers the AA beacon call.

Adobe Launch Rule Conditions:

Set a flag within Adobe Launch (Tag Manager) to ensure a rule triggers only once per page:

Launch custom condition (JavaScript):

// Custom Condition (in Adobe Launch Rule)
if (window.__AA_pageViewed) {
return false; // Beacon already sent, prevent additional beacon
} else {
window.__AA_pageViewed = true;

How it works:
The Launch rule runs the analytics beacon only if the flag hasn't been set yet. After the first execution, the flag is set, preventing further executions.
return true; // Allow first beacon only
}

Adobe Processing Rules (Less Ideal but Possible)

Adobe Analytics Processing Rules can set conditions, but cannot reliably eliminate identical beacon hits sent multiple times, because each beacon is technically independent:

• Processing Rules operate per beacon call (not across calls).

• They can't explicitly deduplicate multiple identical beacon hits sent simultaneously.

Thus, Processing Rules aren't ideal for deduplication.

Post-Processing (Data Warehouse or Query Service)

• You could manually deduplicate using Adobe Data Warehouse or Adobe Experience Platform Query Service after data ingestion.

• Example Query Service SQL:

SELECT visitor_id, page_url, MIN(timestamp) as first_pageview
FROM dataset
GROUP BY visitor_id, page_url, session_id

However, this is manual, post-ingestion, and tedious.

Adobe Analytics does not natively deduplicate beacons post-collection. The best approach is to prevent duplicate beacons at the client-side using JavaScript flags or Adobe Launch conditions.

Thanks.

Pradnya

As others have said, the first step is to identify the root cause of the duplication.

If the same Launch rule is triggering twice, then you can apply conditions on the rule to prevent it from sending multiple times... if you have separate rules that are both triggering this won't work (something like one rule for "window loaded" and another for "history change")... sometimes you need to re-evaluate your rules and combine them into one, so that you can use conditions to prevent duplication.

If your site is a traditional design (i.e. each page is actually a page load), then you can apply a condition of Max Frequency -  Return true no more than once every "1" "Page Views"

However, if your site is an SPA (Single Page Application) the above won't work, as you will only have one "page view" when the site initially loads... however, you can create a time based, like maybe: Return true no more than once every "2" "seconds"

You will have to figure out the logic that works best for your site.

If the rules cannot be combined, then you may need to apply conditions to both rules that ensure both don't trigger on the same page..  And if needed, you can apply a coded solution as a condition to mitigate the duplication.

You know your site better than us, and will have to investigate how your implementation is done and figure out what solution will work best for you.

Fixing the implementation is going to be the best option as this is going to reduce operational costs... even if you can exclude duplications down the line, you've still paid for those server calls... 

To help determine what Launch Rules are triggering on your pages, you can use the Satellite Debugging in your browser console:

This is really helpful as it will tell you all the rules that are triggered, which ones met (or didn't meet) the conditions to run the actions, and help you see what is happening on your site.

Good Luck

@dineshrkumar  No, Adobe Analytics does not automatically exclude duplicate page view events. Every beacon hit is counted. You must fix it at the implementation level by ensuring s.t() fires only once per page load, or apply custom filtering logic manually post-ingestion.