An event ID is the unique string you attach to a single ChatGPT Ads conversion so OpenAI can recognize that event when it arrives from more than one source. The Pixel ID names the data source that collects your events; the event ID labels one specific conversion inside that stream.
If you run both the OpenAI pixel and the Conversions API, you set the event ID yourself, because OpenAI uses it to deduplicate the browser and server copies of the same conversion. Skip it and one purchase counts twice, inflating your conversion totals and hiding your real cost per acquisition.
In ChatGPT Ads conversion tracking, the event ID is the deduplication key that tells OpenAI two incoming events describe the same action. You generate it when a conversion happens and send the identical value as the pixel's event_id and the Conversions API's id. OpenAI then pairs it with your Pixel ID and the event name to match the pair.
A valid event ID is a non-empty string, and it has to stay identical across every channel that reports the conversion. Most teams build it from data they already hold, such as an order ID or a hash of the session, event type, and timestamp. The pixel can create one for you, but that value lives only in the browser and cannot match a server event.
The event ID works beside two other identifiers. The Pixel ID identifies the data source, and oppref is the OpenAI click reference that ties an ad click to a later conversion. AirOps helps teams launch and measure ChatGPT Ads campaigns next to their organic AI search work.
Resources: See how AirOps launches and measures ChatGPT Ads alongside organic AI search
Deduplication runs on three matched values: your Pixel ID, the event name, and the event ID. Here is how the event ID moves through a single conversion.
Generate: When the conversion fires, create one unique string on your server, often the order ID or a hash of the session and event type.
Send from the browser: Pass that string as event_id in the pixel's oaiq measure call so the browser copy carries it.
Send from the server: Include the same string as the id field in your Conversions API request, with the matching Pixel ID and event name.
Match: OpenAI combines the Pixel ID, event name, and event ID into one key and looks for arrivals that share it.
Keep the first: OpenAI stores the first event it receives for that key and ignores every later duplicate.
The result tells you how many distinct conversions your campaign drove, counted once each. It does not tell you which individual user converted, because OpenAI never shares conversation or profile data.
Resources: Read the AirOps guide to measuring and testing ChatGPT ads
Your ChatGPT Ads numbers drive real budget decisions, and the event ID decides whether those numbers are trustworthy. When you choose where to spend next quarter, you are trusting the conversion count the platform reports back. A broken or missing event ID setup corrupts that count at the very source.
Clean deduplication protects your budget: a shared event ID keeps one purchase from counting twice, so return on ad spend and cost per acquisition stay accurate for the whole campaign.
Missing IDs create a silent failure mode: if the pixel and server send different IDs, OpenAI records two conversions, your reported numbers look better than reality, and every optimization decision built on them is wrong.
Stable IDs make the server channel usable: the Conversions API survives ad blockers and privacy limits, but it only reconciles with the browser when both sides carry the same event ID.
Growth marketers use event IDs to deduplicate pixel and server conversions so their ChatGPT Ads return on ad spend reflects real purchases.
Demand gen leads use event IDs to tie one lead form submission to a single counted conversion across browser and server reporting.
SEO managers use event IDs to keep paid ChatGPT Ads conversions clean while comparing them against organic AI search performance.
OpenAI matches events on three values together, the Pixel ID, the event name, and the event ID, so the event ID only works as a deduplication signal when the Pixel ID and event name line up with it on both sides.
A deterministic ID is a value your systems can recreate identically on the browser and the server, which is why teams derive it from stable data such as an order ID or a hash of session and event type, instead of letting the pixel invent a random one that the server can never reproduce.
OpenAI keeps the first event it receives for a matching key and discards later ones, so the earliest arrival defines the recorded conversion and a corrected value sent afterward has no effect.
Count each conversion once across the OpenAI pixel and Conversions API.
Protect return on ad spend and cost-per-acquisition from double-counting.
Reconcile browser and server events on ChatGPT Ads without guesswork.
Reuse the same ID on retries so network failures do not create duplicates.
Connect confirmed backend conversions to ad clicks when you also pass oppref.
Keep custom events deduplicated by matching the custom event name on both sides.
Generate the event ID on your server, then pass it to the browser pixel, so both channels read one authoritative value.
Build the ID from a stable business key like the order or lead ID, which keeps it reproducible if you ever resend.
Reuse the exact same ID on retries and on any second integration, because a new ID creates a second counted conversion.
Match the event name and Pixel ID alongside the ID, since deduplication needs all three to agree.
For custom events, send the same custom_event_name on the pixel and the server so they still reconcile.
Validate your setup with the Conversions API validate_only flag before real traffic flows, so schema errors surface early.
Avoid letting the pixel auto-generate the event ID whenever a server event also fires for that conversion. The auto value never leaves the browser, so OpenAI sees two unmatched events and counts your conversion twice.
AirOps: launches and measures ChatGPT Ads campaigns beside your organic AI search work, so conversion results and content performance sit in one view.
ChatGPT Ads Manager: the OpenAI console where you provision the Pixel ID and Conversions API key and configure the conversion events your event ID reports against.
Google Tag Manager: deploys the oaiq pixel and injects your event ID into the measure call from a data layer variable at the moment of conversion.
Audit your current setup: Open the conversions tab in ChatGPT Ads Manager and check whether your pixel and server events already share an event ID. You can do this today with no budget approval.
Pick your source value: Choose one stable identifier the browser and server both know at conversion time, usually the order ID or lead ID, a value that stays constant no matter how many times the event fires.
Wire the browser pixel: Pass that value as event_id in your oaiq measure call, injecting it through a data layer variable in your tag manager.
Wire the Conversions API: Send the same value as the id field in your server request, with the matching Pixel ID and event name.
Validate and monitor: Run a test conversion through both paths, confirm one event in the event stream, and watch for duplicate counts in the first days after launch.
An event ID is the unique string that identifies one ChatGPT Ads conversion across every channel that reports it.
You set the event ID yourself and send the identical value as the pixel's event_id and the Conversions API id.
Deduplication only works when the Pixel ID, event name, and event ID all match on both sides.
Mismatched or missing event IDs make OpenAI count one conversion twice and inflate your reported results.
Generating the ID from a stable business key on the server is the single move that keeps paid measurement clean.
The event ID and the Pixel ID answer two different questions. The Pixel ID represents the data source, the container that collects every conversion event for an account or brand. The event ID identifies one specific conversion inside that container, so OpenAI can tell a single purchase apart from the next one. Deduplication actually uses both at once: OpenAI builds its matching key from the Pixel ID, the event name, and the event ID, and all three have to agree before two arrivals are treated as the same action. In practice you provision the Pixel ID once in Ads Manager and reuse it everywhere, while you mint a fresh event ID for every conversion. Confusing the two is a common setup mistake, because reusing a Pixel ID is correct but reusing a single event ID across different conversions would collapse them into one recorded event.
Generate the event ID at the exact moment the conversion happens, on the server, and then hand it to the browser. The timing matters because both the pixel call and the Conversions API request for that one conversion need the identical value, and the cleanest way to guarantee that is to create it once at the source. If a purchase completes on your backend, mint the ID there, write it into the page or a data layer variable, and let the pixel read it. OpenAI also expects a recent timestamp and accepts only events from the last several days, rejecting anything dated far in the future, so do not batch conversions for weeks and send them late. For high-volume sites, generate and send close to real time, which also means a retry reuses the same ID instead of inventing a new one.
Deduplication fails most often because the two sides are not actually sending the same key, even when the event ID looks right. The usual cause is a mismatch in one of the other two components: the pixel fires under one Pixel ID while the server posts under another, or the event name differs, such as a standard event on one side and a custom event on the other. Another frequent cause is an auto-generated ID: if you omit event_id on the pixel, the SDK invents one that the server can never reproduce, so the two events never pair. Custom events add a third trap, because the custom event name also has to match on both sides. Finally, ordering plays a role, since OpenAI keeps whichever event arrives first, so a late correction with the same ID is simply dropped instead of merged.
Yes, and for any serious conversion tracking you should. The event ID is entirely yours to define, because OpenAI treats the id field as a non-empty string that you supply with each event. For browser-only measurement you can let the pixel generate one automatically, which is fine when no server event exists. The moment you add the Conversions API, though, control has to move to you: the only way the browser and server copies pair is if both carry a value you created and shared. The practical pattern is to generate the ID server-side when the conversion is confirmed, pass it into the page for the pixel call, and include the same string in the API request. You can also reuse that value on retries and on any second integration, which keeps one real conversion from fanning out into several recorded ones.
A good event ID is unique per conversion, stable, and reproducible on both the browser and the server. Uniqueness is the baseline: each real conversion needs its own ID, so two different purchases never collapse into one. Stability means the value does not change between the browser call and the server call for the same event, which is why a deterministic source beats a random string. Reproducibility is what makes retries safe: if your first send fails and you try again, regenerating the identical ID keeps the count at one. Most teams hit all three by deriving the ID from a business key they already store, such as an order ID, or a hash of the session, event type, and timestamp. There is no OpenAI-published length benchmark to chase; a non-empty string that satisfies uniqueness, stability, and reproducibility is the standard worth measuring your setup against.