ChatGPT Ads Tracking: The Complete Measurement Guide

OpenAI Ads tracking works by combining a browser-side JavaScript pixel with a server-side Conversions API (CAPI) call for the same event, so you keep one accurate count of what your ads actually produced. The pixel alone misses a meaningful share of conversions to ad blockers and browser privacy limits; CAPI fills those gaps by sending the same event directly from your server. Together, deduplicated by a shared event ID, they give OpenAI Ads Manager the signal it needs to optimize your campaigns.

This guide covers the full picture: how the pixel and Conversions API fit together, which standard events OpenAI Ads recognizes, why pixel-only setups quietly undercount, and the exact steps to get a hybrid setup running. If you've been running ChatGPT Ads on nothing but a pixel and the numbers don't match what your backend shows, this is the guide that explains why — and what to do about it.

Who this guide is for

This guide is for anyone running ads on ChatGPT who needs to know what happened after the click: marketers setting up measurement for the first time, developers asked to "add the pixel" without much context, and agency or in-house teams auditing an existing setup that looks incomplete or inconsistent. If you already have a Pixel ID from Ads Manager and just need install steps, skip ahead to the getting-started checklist. If you're deciding what to build first and why, read the architecture section below — it explains why "just add the pixel" is rarely the whole job, even though it's the part most teams do first.

We assume you have (or can request) admin access to OpenAI Ads Manager, and either a developer on hand or the willingness to paste a short script tag yourself. Nothing here requires you to be a backend engineer, but the Conversions API portion does involve a server-side request with an API key, which is where most teams either loop in a developer or bring in outside help for a day.

One more note on scope: this guide is about measurement — knowing what happened — not about campaign strategy, creative, or bidding. Good measurement is what makes those other decisions reliable, but it's a distinct piece of work with its own setup steps, and it's worth treating it that way rather than as an afterthought bolted onto a campaign launch.

The measurement architecture: pixel, Conversions API, and Ads Manager

OpenAI Ads measurement has three moving parts, and understanding how they connect is the difference between "we installed something" and "we can trust our numbers."

1. The JavaScript pixel. A small SDK script loaded on your site from https://bzrcdn.openai.com/sdk/oaiq.min.js. You initialize it with your Pixel ID (oaiq("init", {pixelId: "..."})), and it fires events client-side as visitors browse — page views, cart adds, purchases — via calls like oaiq("measure", eventName, eventData, options). The pixel also captures a first-party __oppref cookie from the landing URL, which gives you roughly a 30-day attribution window for tying a later conversion back to the ad that drove the visit. Full setup detail lives in the OpenAI Ads developer docs and the measurement pixel reference.

2. The Conversions API (CAPI). A server-side endpoint that accepts the same event types directly from your backend, bypassing the browser entirely. Your server sends a POST request to https://bzr.openai.com/v1/events?pid=PIXEL-ID with an Authorization: Bearer API-KEY header. Because this happens server-to-server, it isn't affected by ad blockers, cookie restrictions, or a visitor closing the tab before a script finishes loading. It's worth noting that CAPI does not automatically pick up the __oppref cookie the way the pixel does — if your server-side events need that attribution signal, your backend has to read the cookie and forward its value explicitly as part of the event payload. Details are in the Conversions API docs.

3. Ads Manager and the Insights/Ads API. This is where it all surfaces. Once events land — from the pixel, from CAPI, or both — Ads Manager attributes them to campaigns and uses them as an optimization signal for bidding and budget allocation. Your Pixel ID itself is created in the conversions tab of Ads Manager before you write a line of code anywhere else, so this is genuinely the first step, not an afterthought.

The pixel gives you speed and richness of client-side context — referring page, on-page behavior, the attribution cookie mentioned above. CAPI gives you reliability, because it doesn't depend on what happens inside someone's browser after they leave your ad. Neither one is "the tracking system" on its own; they're two inputs into the same event stream, and OpenAI's own guidance (see the measure results article) treats them as complementary rather than either/or. Teams that only implement one and consider the job finished are, in effect, choosing to leave one of the two available signal sources unused.

Supported standard events at a glance

OpenAI Ads recognizes a set of standard event names so Ads Manager can interpret them consistently across advertisers, rather than every business inventing its own naming scheme for "someone bought something." You can also send custom events for anything that doesn't fit a standard name. The full reference is in supported events; here's the shape of it:

Three things worth flagging before you start mapping events to your site. First, amounts must be integers expressed in the currency's smallest unit (cents for USD, so $129.99 becomes 12999), and every amount field needs a currency code attached — an amount without a currency is not a valid event. Second, the two app events can only be sent through CAPI; there's no browser-side equivalent, since app installs and opens don't happen inside a web pixel's execution context at all. Third, custom events are matched during deduplication by name as well as ID, which matters more than it sounds like — more on that below.

Why pixel-only tracking undercounts

If you install only the JavaScript pixel and stop there, you will under-report conversions — not by a rounding error, but structurally, because of how browsers and ad blockers behave:

• Ad blockers and privacy extensions block many tracking scripts by domain or pattern before they ever load. A pixel that never loads never fires, and there's no client-side fallback for a script that was never allowed to run.
• Safari's Intelligent Tracking Prevention (ITP) and equivalent browser privacy features restrict cross-site scripts and limit how long client-side identifiers persist. This affects both whether an event fires cleanly and how far back attribution can reasonably reach.
• Users close the tab early. If someone completes a purchase and closes the browser before your confirmation page's script finishes executing — a slow page load, a flaky connection, someone tapping away on mobile — that pixel event never fires, even though the order is entirely real in your backend order system.
• Corporate networks, VPNs, and strict browser privacy settings sometimes block third-party or even first-party script domains outright, independent of any ad-blocking extension.
• JavaScript errors elsewhere on the page can prevent a pixel call from executing if it's queued behind broken code, particularly on sites with a lot of third-party scripts competing for the same page.

None of this means the pixel is badly built. It means client-side JavaScript, by its nature, only works when the client — the browser, the network, the user's settings — cooperates all the way through. That's precisely the reason a server-side option exists at all: your backend knows an order was placed regardless of what happened in the customer's browser five minutes earlier.

The pixel + CAPI hybrid model and deduplication

The fix isn't choosing pixel or CAPI — it's sending the same event through both channels and deduplicating on the backend so you don't double-count a single real conversion as two. This is standard practice across server-side measurement generally, and OpenAI Ads implements it directly:

• On the pixel side, you pass an event_id in the options argument of your oaiq("measure", ...) call.
• On the CAPI side, you send the matching value as id in the event payload.
• As long as both events carry the same Pixel ID and the same event_id / id value, OpenAI's system treats them as one event, not two.
• For custom events specifically, the system also matches on custom_event_name — so if you're sending a custom event through both channels, make sure the event name is identical in both payloads, not just the ID. A mismatch here (say, lead_form_submit client-side and lead_submitted server-side) can defeat deduplication even with matching IDs.

Get the dedup key wrong — mismatched IDs, or generating a fresh ID server-side instead of reusing the one the client already created — and you'll see conversion counts inflate, sometimes significantly, right after you "improve" measurement by adding CAPI. This is one of the most common reasons a pixel+CAPI setup looks worse than pixel-only until the dedup logic is fixed. If you're implementing this yourself, our guide to the Conversions API setup walks through the payload structure in more depth, and our pixel install guide covers the client-side event_id piece specifically.

A few other technical constraints worth knowing before you build this out:

• Batching. CAPI accepts up to 1,000 events per request, but one malformed event fails the entire batch — so payload validation on your side matters more as volume increases, not less.
• Timing window. Event timestamps (timestamp_ms) must fall within the last 7 days and no more than 10 minutes in the future. This isn't a system designed for backfilling months of historical order data; it's built for near-real-time reporting.
• Attribution cookie gap. As mentioned above, CAPI does not automatically capture the __oppref cookie the pixel captures. If your server-side events need that ~30-day attribution signal, your backend has to read and forward it explicitly — it won't show up for free just because CAPI is connected.
• Debug mode. Keep debug: true set on the pixel while testing so you can confirm events are actually received and formatted correctly before you rely on the data for decisions. Turn it off once you've validated the setup.

A 6-step getting-started checklist

1. Create your Pixel ID. Log into OpenAI Ads Manager, go to the conversions tab, and generate a Pixel ID. You'll need this exact ID for both the pixel and the CAPI setup — it's the shared key that ties everything together.
2. Install the JavaScript pixel. Add the SDK script tag loading from bzrcdn.openai.com, initialize with your Pixel ID, and confirm your Content Security Policy allows script-src bzrcdn.openai.com plus connect-src and img-src for bzr.openai.com. A CSP block here is one of the most common "pixel installed but nothing is firing" causes. Full walkthrough: how to install the OpenAI Ads pixel.
3. Map your standard events to your funnel. Decide which of page_viewed, contents_viewed, items_added, checkout_started, order_created, lead_created, registration_completed, subscription_created, or trial_started apply to your business, and identify exactly where on your site each one should fire.
4. Fire pixel events with a generated event_id. Wire up oaiq("measure", ...) calls at each funnel step, generating a unique event_id per event that you'll reuse later for deduplication — don't wait until you build CAPI to think about this.
5. Build the server-side CAPI call. Set up the POST to https://bzr.openai.com/v1/events?pid=PIXEL-ID with your API key in the Authorization header, reusing the same event_id as id in the payload, and matching custom event names exactly if you're using them. Details: Conversions API setup guide.
6. Test with debug mode, then go live. Keep debug: true set while testing so you can confirm events are received correctly, verify in Ads Manager that pixel and CAPI events are deduplicating as expected rather than double-counting, then turn debug mode off and let it run.

If steps 4 through 6 feel like more engineering time than your team has available this quarter, that's exactly the gap a done-for-you setup is meant to close — see the Pixel + CAPI complete setup below.

What good measurement actually requires

None of the six steps above are individually hard. What's easy to get wrong is the combination: a CSP header that silently blocks the pixel script from ever loading, an event_id that isn't actually shared between the client call and the server call, a currency field left off an order_created event so it gets rejected, or a CAPI batch that's technically "connected" but sending one malformed event that fails the whole request without an obvious error surfacing anywhere you'd normally look.

These are exactly the kinds of issues a tracking audit is built to catch in under 48 hours. If you're not sure whether your current setup has problems like these, an audit is the cheapest way to find out before you spend ad budget on campaigns that are optimizing against incomplete or inflated data — and the audit fee is credited toward a setup if you decide to move forward with one.

If you're building this from scratch and want it handled end-to-end — Pixel ID creation, JavaScript pixel install, server-side CAPI, event mapping, and deduplication testing — that's the complete package described below. And if you'd rather get a quick read on where your current setup stands before committing to anything, the free readiness audit is a good starting point.

Measurement is the foundation everything else in ChatGPT Ads sits on: budget decisions, creative testing, and bidding all depend on knowing what actually converted and what didn't. Get the pixel-plus-CAPI architecture right once, with deduplication working correctly, and every campaign decision you make after it benefits from accurate data instead of a partial picture stitched together from browser events alone.