---
title: "OpenAI Pixel event_id missing: fix ChatGPT Ads deduplication"
description: "Without your own event_id, the ChatGPT Ads pixel makes up a random ID your server never sees, so pixel and Conversions API events can't be deduplicated."
updated: "2026-10-23"
url: "https://ispixelworking.com/guides/openai.missing_event_id/generic"
---

# OpenAI Pixel event_id missing: fix ChatGPT Ads deduplication

Fix guide · Any website · advanced · about 60 min · updated 2026-10-23

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

## What this means

Each event the OpenAI Pixel sends can carry an **event ID** that your site sets: the `event_id` option in the fourth argument of `oaiq("measure", ...)`. Your site calls `measure` without one.

The tricky part: the requests still contain an ID. When your code passes no `event_id`, the pixel puts a random value in the event's `id` field by itself (OpenAI does not document this, but you can see it in the request payload). That value exists only in the visitor's browser. Your server never learns it, so it cannot send the same ID with its copy of the event.

Whether this costs you money depends on one question: **does your site also send these events to OpenAI from a server, through the OpenAI Conversions API?**

- **Yes, or you are not sure:** OpenAI recognizes a browser event and a server event as the same conversion when they share the Pixel ID, the event name and the event ID (`event_id` in the pixel, `id` in the Conversions API). With a random browser ID, the two never match, so the same purchase or lead can be counted twice and conversion-optimized campaigns learn from inflated numbers.
- **No, you only use the browser pixel:** there is nothing to deduplicate yet, so this has little effect today. It matters the day you add the Conversions API, and it helps to have the IDs in place before then.

We cannot see server-to-server traffic from a browser, so we cannot tell whether your Conversions API works. We only see whether your site passes its own event IDs to the pixel.

## How to confirm it yourself

Because the pixel fills in an ID on its own, the Network tab cannot tell you whether your site sets one. Look at the calls your site makes instead.

1. Search your site code, theme, tag manager tags and plugins for `oaiq("measure"` (or `oaiq('measure'`).
2. For each call, look for a fourth argument with `event_id`:

   ```js
   // No event ID: the pixel makes one up
   oaiq("measure", "lead_created", { type: "customer_action" });

   // Your own event ID
   oaiq("measure", "lead_created", { type: "customer_action" }, { event_id: "lead-8f3a2c" });
   ```

3. If you use a tag manager template, open the tag and check its event ID field. In Stape's **OpenAI Ads Pixel** template, the ID goes in the **Server-side tracking settings** section; if that field is empty, the pixel uses its own random value.
4. To see the effect, trigger the event and compare the `id` in the request payload (Network tab, filter `bzr.openai.com`) with the ID your server sends for the same action. If they differ, deduplication fails. On a test copy of your site, `debug: true` in the `init` call also logs each `measure` call in the console.

## How to fix

OpenAI deduplicates a browser event and a server event when both use the **same Pixel ID**, the **same event name** (for custom events, the same `custom_event_name`) and the **same event ID**. OpenAI keeps the first event it receives with that combination and ignores later duplicates. So the fix has two halves: give the browser event your own ID, and send exactly the same ID from the server.

1. **Generate one unique ID per action.** Order numbers work well for purchases (`order_12345`), form submission IDs for leads, and a random string for page views and clicks. Never reuse a fixed value: OpenAI keeps only the first event with a given ID, so a repeated ID silently drops real conversions.
2. **Pass it to the pixel** as `event_id` in the fourth argument:

   ```js
   oaiq(
     "measure",
     "order_created",
     { type: "contents", amount: 2599, currency: "USD" },
     { event_id: "order_12345" }
   );
   ```

3. **Send the same value as `id` from your server**, with the same event `type` (`order_created` here) and the same Pixel ID in the request address (`pid`). For custom events, the server event also needs the same `custom_event_name`.
4. **Make both sides read the ID from one place.** Typical patterns: the order confirmation page renders the order number into the page, and the server uses the same order number; or the browser generates the ID, sends it with the form submission, and the server reuses it.
5. **If you use Google Tag Manager with a server container:** generate the ID with a variable such as Stape's **Unique Event ID** variable, put it into the event ID field of the web tag, and map the same value to the event ID in the server tag (Stape's **OpenAI Ads Events API** tag has an **Event ID** parameter for this).
6. **If a tool sends your server events:** check its documentation for how it sets event IDs. It can only match browser events that it sends itself. A second, manually installed pixel will keep sending events with random IDs (and usually also shows up as "Duplicate OpenAI events").
7. **Publish** your changes.

## Common causes

- The installation snippet and the example `measure` calls were copied without the optional fourth argument.
- The Conversions API was added later, and the browser calls were never updated.
- Both sides generate their own random ID, so each event has an ID, but they never match.
- In a tag manager, the event ID field of the web tag is empty, or the server tag reads a different variable.

## How to verify the fix

1. Every `oaiq("measure", ...)` call for your key events passes an `event_id`, and the value changes from one action to the next.
2. For one test conversion, the `id` in the browser request equals the `id` your server sends.
3. With access to the Advertiser API, OpenAI's recent-events endpoint (`GET /v1/conversions/events?pid=<PIXEL-ID>`) lists a sample of events from roughly the last 15 minutes with their channel: `pixel_sdk` for the browser and `server_to_server` for your server.
4. Re-run the check on IsPixelWorking. The issue should be gone.

## Sources

- OpenAI Developers, Measurement Pixel (`measure` arguments, `event_id` option, deduplicating browser and server events, first event wins): https://developers.openai.com/ads/measurement-pixel
- OpenAI Developers, Conversions API (event `id`, deduplication on Pixel ID, event name and `id`): https://developers.openai.com/ads/conversions-api
- OpenAI Developers, Conversion Tracking (use the same Pixel ID, event name and event ID through both integrations; Monitoring Events): https://developers.openai.com/ads/conversion-tracking
- Stape, OpenAI Ads Pixel tag (Server-side tracking settings): https://stape.io/helpdesk/documentation/openai-ads-pixel-tag
- Stape, OpenAI Ads Events API tag (Unique Event ID variable, Event ID parameter): https://stape.io/helpdesk/documentation/openai-ads-events-api-tag