ChatGPT ads conversion tracking: pixel and CAPI setup

How do you track conversions from ChatGPT ads?

Install two things and connect them with one shared id. OpenAI’s JavaScript pixel reports conversions from the browser, the Conversions API (CAPI) reports them from your server, and a shared event id lets OpenAI deduplicate the two so a single purchase counts once. You provision a Pixel ID and a CAPI key from the Conversions tab in Ads Manager, then send standard events like order_created or lead_created from your site.

Do it before you launch, not after. This is the same order the setup guide insists on, and the reason is mechanical: the platform cannot optimize toward conversions it never saw, and the eligibility rule for conversion bidding made that literal.

What is the difference between the pixel and the CAPI?

The pixel runs in the browser. The CAPI runs on your server. The pixel is a script you add near the top of your site’s head, initialize with your Pixel ID, and fire on a conversion. It sees client-side context, but it disappears when an ad blocker, a privacy setting, or a cookie reset gets in the way. The CAPI sends the same events server-to-server, where none of that reaches it.

OpenAI recommends the CAPI as the more reliable source and treats the pixel as the complement, not the other way round. The pixel uses a privacy-preserving identifier (oppref) stored in a first-party cookie, so even the browser path is built to avoid sharing personal detail with advertisers. Run both, and you get the browser’s context plus the server’s reliability. Run only the pixel and you will undercount by however much of your traffic blocks it, which for some audiences is a quarter or more.

How do you install the pixel?

Create a Pixel ID in the Conversions tab of Ads Manager, then add the pixel script near the top of your site’s head so it loads before a fast converter can leave. Initialize it with your Pixel ID, and call the measure function when a conversion happens, passing the event name and its data. Place the script sitewide rather than only on conversion pages, so page views and earlier funnel events are captured too.

oaiq("measure", "order_created", {
  type: "contents",
  amount: 12999,        // $129.99, in cents
  currency: "USD",
  event_id: "order-5821"
});

That snippet is illustrative. Build against the pixel reference for the exact call shape, since this platform changes weekly. The two things to get right regardless of syntax are the event name (use a standard one where it fits) and the value format (an integer, covered below).

How do you set up the CAPI?

Provision a CAPI key alongside the Pixel ID in the Conversions tab, then send the same events from your backend at the moment they happen. A purchase fires order_created from your order-processing code; a signup fires registration_completed from your auth flow. Because the call originates on your server, it is not exposed to ad blockers, browser privacy settings, or a user closing the tab before the pixel fires.

The CAPI is also where value-based optimization gets its honest numbers. Your backend knows the real order total, the refunded amount, and whether a lead was qualified, in a way the browser does not. Sending server events with accurate amounts is what lets conversion bidding optimize toward revenue rather than raw conversion counts. Treat the CAPI as the system of record and the pixel as the real-time supplement.

Which conversion events should you send?

Send the standard event that matches the action, and reserve custom for what the taxonomy does not cover. OpenAI defines a fixed set of standard events, each with a data shape. Use page_viewed for an important page load and contents_viewed when someone views a specific product or item, including interactions after the page has loaded.

The standard events as of June 2026:

• page_viewed, contents_viewed, items_added, checkout_started, order_created (the contents data shape)
• lead_created, registration_completed, appointment_scheduled (the customer_action shape)
• subscription_created, trial_started (the plan_enrollment shape)
• custom, for a user-defined event the taxonomy does not cover

Match the event to your funnel rather than firing everything. An ecommerce store cares about items_added, checkout_started, and order_created; a B2B site cares about lead_created and appointment_scheduled; a SaaS product cares about trial_started and subscription_created. Sending the events you will actually optimize toward keeps the data legible and the bidding focused.

What value should you send with a conversion?

Send monetary values as integers in the currency’s lowest denomination, with the currency code. A $129.99 order is amount: 12999 with currency: "USD", not 129.99. Include the currency whenever you include an amount. This is the single most common tracking bug, because a number that looks right in testing ($129.99) is off by a factor of 100 once it reaches the platform.

The data shape carries the value. contents events can include an amount and an array of items, each with its own id, quantity, and amount. customer_action events like lead_created can carry an amount if a lead has a modeled value. plan_enrollment events can carry a plan_id and the subscription value. Getting the value right is what separates “we got 20 conversions” from “we got $4,000 in tracked revenue,” and only the second number lets you judge return.

How does event deduplication work?

Send the same conversion from both the pixel and the CAPI with the same event_id, and OpenAI counts it once. Without a shared id, a purchase that fires from the browser and from your server lands as two conversions, your CPA looks half what it is, and conversion bidding optimizes toward a number that is not real.

This is the same pattern Meta’s CAPI uses, so if your team has set up server-side conversions before, the model transfers. The discipline is to generate the event_id once, at the moment of the conversion (your order id is a natural choice), and pass that same value to both paths rather than letting each side mint its own. Test this deliberately: fire a single real conversion, confirm it appears once in reporting, and only then trust the counts.

How do you verify tracking is working?

Run a real conversion through the full path and confirm it shows up once, with the right value, in Ads Manager reporting. Do this before you spend a dollar on traffic. A campaign that launches on broken tracking loses more than its first week of optimization. It teaches conversion bidding the wrong lesson, and that is harder to unwind than a clean start.

Check the three failure modes specifically. Confirm the value is the integer you expected and not 100 times too small or large. Confirm the pixel and CAPI events for the same conversion deduplicate to one rather than counting twice. And confirm events fire from the real production funnel, not from a test page alone, because a pixel that works in isolation can still miss the production checkout. The complete guide explains why this rigor pays off: clean conversion data is the asset that compounds while the auction is thin.

Why does conversion tracking gate CPA bidding?

Because conversion-optimized bidding is, by definition, optimization toward conversions, and it cannot start from zero. OpenAI opened CPA bidding in early access on June 5, 2026, and the eligibility rule made the dependency literal: accounts needed at least one conversion event already flowing through the pixel or CAPI before June 1 to qualify. Tracking first, bidding second, in that order.

There is a practical version of this even without the eligibility gate. A bid strategy that targets a cost per acquisition needs enough conversions to learn what drives them. A few per week is not enough. The cost breakdown shows how a modest test budget produces roughly 20 conversions a month, which is the lower end of usable, so the move is to run CPC until the pixel has logged real volume, then switch.

What can you measure, and what can’t you?

You measure outcomes in aggregate: how many conversions a campaign drove, at what value, at what cost. You do not get individual conversations or user-level detail, by design. Advertisers receive aggregated performance, and ChatGPT keeps the conversation itself private, which is one of OpenAI’s stated advertising principles rather than a temporary limitation.

The honest gap is independent verification. OpenAI has said third-party measurement is coming and named technology partners, but a fully independent measurement layer is still being built as of June 2026. For now, your pixel and CAPI data, read against your own backend, is the source of truth, which is one more reason to make that data clean from day one.