---
title: "Duplicate OpenAI Pixel events: how to find and remove them"
description: "ChatGPT Ads events sent twice? Find the second OpenAI Pixel installation (site code, Tag Manager, plugin or app), keep one, and check your measure calls."
updated: "2026-10-23"
url: "https://ispixelworking.com/guides/openai.duplicate_pixel/generic"
---

# Duplicate OpenAI Pixel events: how to find and remove them

Fix guide · Any website · easy · about 20 min · updated 2026-10-23

For the finding “Duplicate OpenAI events” (`openai.duplicate_pixel`).
Also for: [Shopify](https://ispixelworking.com/guides/openai.duplicate_pixel/shopify), [WordPress](https://ispixelworking.com/guides/openai.duplicate_pixel/wordpress), [Webflow](https://ispixelworking.com/guides/openai.duplicate_pixel/webflow), [Framer](https://ispixelworking.com/guides/openai.duplicate_pixel/framer).

## What this means

The same event (for example `page_viewed` or `lead_created`) was sent twice for the same OpenAI Pixel ID within about a second. In almost every case, the pixel or one of its event calls is simply installed twice.

OpenAI does throw away exact repeats: it keeps the first event with the same Pixel ID, event name and event ID. But when your code passes no `event_id`, the pixel gives each call its own random ID, so two calls for one action look like two different conversions.

Why it costs you money:

- ChatGPT Ads counts some conversions twice, so reports look better than reality and your cost per conversion looks lower than it is.
- Conversion-optimized campaigns learn from inflated, noisy data and may optimize toward the wrong results.
- Decisions based on these numbers (raising a budget, judging an ad) rest on wrong data.

This is about two identical **browser** events. A browser event and a server (Conversions API) event for the same action are expected; OpenAI counts that pair once when both carry the same event ID (see "OpenAI events have no event ID").

## How to confirm it yourself

Our check runs from a browser in the EU and accepts the cookie banner before looking for duplicates.

1. Open a **private (incognito) window**, open developer tools (F12), go to the **Network** tab and filter by `bzr.openai.com`.
2. Load the page and accept cookies.
3. Click the requests and look at the payload: each request carries a list of `events`, and the pixel batches events that happen close together, so one request can contain both copies. The Pixel ID is the `pid` value in the request address. Two events with the **same `type`** for the **same `pid`** fired at almost the same moment are a duplicate.
4. Two different `pid` values are not duplicates: that is two pixels, which may be intended (for example an agency pixel and a client pixel).
5. In the **Console** tab, the pixel's `debug: true` option (on a test copy of your site) logs each `measure` call, which makes double calls easy to spot.

## How to fix

1. **List every place the pixel or its events can come from.** Search the page source (right-click, *View page source*) for `oaiq.min.js` and `oaiq(`. Then check:
   - the site header or theme code, or a "custom code" setting;
   - your Google Tag Manager (GTM) container: Custom HTML tags containing `oaiq`, OpenAI's own GTM template, and community templates such as Stape's **OpenAI Ads Pixel** tag;
   - plugins and apps that install the OpenAI pixel or send ChatGPT Ads conversions;
   - your own code that calls `oaiq("measure", ...)`, for example in a form handler or on a "thank you" page.
2. **Choose one installation to keep.** If a tool sends both browser and server events (so it can share event IDs between them), keep that one and remove the manual snippet. If you manage everything in GTM, keep GTM and remove the others.
3. **Remove the other copies, including their event calls.** OpenAI's snippet checks whether `oaiq` already exists, so a second copy usually does not load the SDK twice, but its own `init` and `measure` calls still run. Remove the whole second copy, not just the `<script>` line.
4. **Check event calls as well as the base code.** Two tags may send the same event: for example a `lead_created` tag on a form trigger and another `lead_created` call on the "thank you" page. Keep one.
5. **Check page views on single-page sites.** If your site changes pages without a full reload, make sure only one piece of code sends `page_viewed` for each page change (for example, not both a "History Change" trigger in GTM and your own router code).
6. **Add event IDs.** With your own `event_id` on each action, an accidental second call for the same action carries the same ID, and OpenAI keeps only the first. That is a safety net, not a replacement for removing the extra copy.
7. **Publish** your changes and clear any cache.

## Common causes

- The snippet is in the site's header code **and** in a tag manager.
- A plugin, app or tag template adds its own pixel, and the original snippet was never removed.
- The GTM container itself is installed twice (once by hand, once by a plugin), so every tag fires twice.
- Two tags or two pieces of code send the same event on overlapping triggers.
- A page view is sent on the initial load and again by a history-change trigger on the same page.

## How to verify the fix

1. In a private window, accept cookies and check the Network tab: each event appears once per Pixel ID.
2. Click a button or submit a test form that sends an event, and check that it appears only once.
3. Re-run the check on IsPixelWorking. The issue should be gone.

## Sources

- OpenAI Developers, Measurement Pixel (installation snippet, batching of closely grouped `measure` calls, `event_id`, OpenAI uses the first event for a matching key and ignores later duplicates, debug option): https://developers.openai.com/ads/measurement-pixel
- OpenAI Developers, Multiple Pixel IDs (load the SDK once, initialize each Pixel ID): https://developers.openai.com/ads/multiple-pixels
- Stape, OpenAI Ads Pixel tag for web GTM: https://stape.io/helpdesk/documentation/openai-ads-pixel-tag