OpenAI launched ads in ChatGPT in May 2026. They're currently available to Free and Go plan users in the US, Canada, Australia, and New Zealand — and OpenAI is expanding access quickly. If you're running or planning ChatGPT ads, the measurement question is already urgent: how do you know if any of this is working?
The good news is OpenAI built a measurement infrastructure that follows the same dual-track pattern Meta popularized with CAPI — a browser pixel for speed, a server-side API for reliability, and deduplication via shared event IDs. If you've implemented Meta CAPI before, the concepts are identical. If you haven't, this guide walks through the entire setup from scratch.
How ChatGPT Ads Work — What Advertisers Need to Know
Ads in ChatGPT appear below relevant responses. Each ad unit includes an advertiser name, favicon, headline, description copy, landing page URL, and an image asset. Crucially, OpenAI's system selects ads based on the conversational context of the current chat thread — not keyword bidding in the traditional sense.
Advertisers provide "context hints" at the ad group level — descriptions of the conversations, topics, or scenarios where their products might be relevant. These hints guide matching but aren't exact-match keywords. The auction uses a relevance-weighted, second-price model, and advertisers can buy on CPM (default bid: $60) or CPC (recommended starting bid: $3–5).
From a measurement standpoint, the key difference from search or social ads is the intent signal. ChatGPT users are often mid-research — comparing options, asking detailed questions, and requesting recommendations. That's a high-intent audience, but conversion timing can be longer than a search click. Your attribution window setup matters.
Pixel, CAPI, or Both — Choosing Your Setup
OpenAI's measurement system has two delivery paths. You don't have to run both — each works on its own — but each configuration has meaningful trade-offs.
Track 1 — The OpenAI Measurement Pixel is a browser JavaScript SDK (oaiq.min.js) that loads on your site pages. It automatically captures the oppref identifier from the landing page URL when a user arrives from a ChatGPT ad, stores it in a first-party cookie for later page views, and fires conversion events to OpenAI's servers when you call oaiq("measure", ...). The pixel handles oppref capture, source URL tracking, event timestamping, and batching automatically.
Track 2 — The Conversions API is a server-to-server integration that sends conversion events directly from your backend to bzr.openai.com/v1/events. Server-side events bypass ad blockers and browser restrictions entirely. The API accepts batches of up to 1,000 events per request and supports the same event taxonomy as the pixel.
Here's how to think about each configuration:
- Pixel only — Quick to implement with no backend work required. The pixel handles oppref automatically, so attribution setup is minimal. The downside: browser ad blockers and privacy restrictions can suppress events, meaning you'll miss conversions from a portion of your traffic. Fine for a quick start; not a permanent solution for high-spend campaigns.
- CAPI only — More reliable signal since server-side events can't be blocked. The trade-off: you need to manually capture
oppreffrom the landing page URL and pass it with each event yourself, since the pixel SDK handles that automatically. Make sure your implementation reads and stores theopprefparameter on arrival — without it, attribution accuracy degrades significantly. - Pixel + CAPI together — Maximum coverage. The pixel handles oppref automatically and fires quickly; the CAPI fills in the gaps for blocked or missed browser events. When running both, you must deduplicate using a shared
event_idacross both tracks, otherwise conversions get double-counted in Ads Manager reporting.
Installing the OpenAI Measurement Pixel
The pixel snippet goes in the <head> section of every page where you want to capture conversions — ideally all pages, so page view events fire correctly and oppref is captured on arrival regardless of which page a user lands on.
Place it near the top of <head>, before other scripts, to ensure early conversions aren't missed while the rest of the page loads. Your Pixel ID is provisioned in the Conversions tab of OpenAI Ads Manager.
After initialization, you fire conversion events by calling oaiq("measure", eventName, eventProps, eventOptions). The eventName is one of OpenAI's supported standard names (or "custom"). The eventProps object contains the event data — the type field, monetary values, and item details. The eventOptions object is where you put event_id for deduplication and custom_event_name for custom events — not in eventProps.
For an ecommerce purchase, the event call looks like this:
oaiq("measure", "order_created", {
type: "contents",
amount: 12999, // $129.99 in cents — always integers
currency: "USD",
contents: [{
id: "sku_123",
name: "Starter Bundle",
content_type: "product",
quantity: 1
}]
}, {
event_id: "order_98765" // Store this — you'll reuse it server-side
});A critical detail: monetary values must be integers in the currency's lowest denomination. $129.99 is 12999 with currency: "USD". Sending 129.99 as a decimal is a common error that corrupts revenue reporting in Ads Manager.
Setting Up the OpenAI Conversions API
The Conversions API requires two credentials from Ads Manager: your Pixel ID and a Conversions API key. Both are available in the Conversions tab of your account.
Requests go to POST https://bzr.openai.com/v1/events?pid=YOUR-PIXEL-ID with an Authorization: Bearer YOUR-API-KEY header. The body is a JSON object with an events array.
The most important field difference between the pixel and the CAPI: oppref is not captured automatically server-side. The pixel handles this for you in the browser. On the server, you need to capture the oppref value from the ad click URL when the user arrives (ideally storing it in your session or database), then pass it explicitly in the server-side event.
Each server-side event needs: a unique id (reuse the same value you sent in the pixel's event_id), a type (the event name), a timestamp_ms (in milliseconds, within the last 7 days and no more than 10 minutes ahead), the oppref value if available, the source_url of the conversion page, and a data object matching the event's schema.
Before going live, use "validate_only": true in the request body. This validates your event structure and returns errors without saving any data — it's the equivalent of GTM Preview mode. Only remove the flag once you've confirmed all events are passing validation cleanly.
Deduplicating Pixel and Server Events
When both tracks fire for the same conversion, OpenAI deduplicates on the combination of Pixel ID + event name + event_id. This means the same conversion gets counted once in Ads Manager reporting, not twice.
The mechanism is straightforward: generate a unique event_id for each conversion on your backend (e.g., your order ID, lead submission ID, or a UUID). Pass it in eventOptions.event_id on the pixel call and in the id field on the server-side event. OpenAI matches them.
For custom events, also ensure custom_event_name matches on both sides. Deduplication for custom events matches on Pixel ID + custom_event_name + event_id.
One thing to verify after implementation: check Ads Manager's conversion counts against your actual backend conversion data. If numbers are significantly higher than actual conversions, deduplication likely isn't configured correctly. If numbers are lower than expected, the server-side API may not be firing or oppref may not be passing through.
Capturing oppref for Better Attribution
The oppref identifier is OpenAI's privacy-preserving click identifier — analogous to Meta's fbclid or Google's gclid. When a user clicks a ChatGPT ad, OpenAI appends oppref as a URL parameter on the landing page URL.
The pixel SDK captures this automatically in the browser and stores it in a first-party __oppref cookie so it's available for later page views in the same session. On the server side, you need to capture it yourself — typically by reading the URL parameter when the user first arrives and storing it in your session, database, or a cookie you can access later.
When firing server-side Conversions API events, pass the captured oppref value in the oppref field. Without it, OpenAI can still count the conversion, but attribution accuracy — linking the conversion back to the specific ad and conversation that drove it — degrades. This directly impacts Ads Manager's reported ROAS and conversion rates.
Tracking ChatGPT Ad Traffic in GA4 with UTM Parameters
OpenAI Ads Manager shows you impressions, clicks, spend, CTR, and conversions within the platform. But it tells you nothing about what happens after the click — bounce rate, pages per session, checkout funnel drop-off, or how ChatGPT converts compared to your other paid channels. That's where GA4 comes in.
The setup is simple: add static UTM parameters to your ChatGPT ad landing page URLs. OpenAI passes these parameters through on ad clicks, so GA4 reads them and attributes the session correctly. At minimum, configure:
utm_source=chatgptutm_medium=cpcutm_campaign=your-campaign-nameutm_content=your-ad-group(optional but useful for A/B testing creative)
With UTMs in place, GA4's Acquisition reports will show ChatGPT as a source/medium alongside Google / cpc, facebook / cpc, and organic. You can build custom explorations comparing engagement metrics — session duration, pages per session, conversion rate — across channels. You can also create GA4 audiences based on ChatGPT traffic and use them for remarketing on Google Ads, closing the loop between channels.
If you're building UTM URLs manually, use a tool like UTM Buddy to generate clean, consistent parameter strings across your team. It removes the copy-paste errors and inconsistent naming conventions that turn GA4 acquisition reports into a mess — especially when you're managing UTMs across multiple ad platforms simultaneously.
One thing to note: GA4 and OpenAI Ads Manager will likely report different conversion numbers. GA4 attributes on last-click by default; OpenAI uses its own attribution based on oppref. Neither is wrong — they're measuring different things. Treat OpenAI Ads Manager as the source of truth for in-platform performance, and GA4 as your cross-channel intelligence layer.
Supported Events and Data Shapes
OpenAI supports 11 standard event types. Each event requires a data object with a type field that must match the event's expected shape. There are three data shapes:
contents — used for page views, product views, add to cart, checkout started, and purchases. Supports an optional contents array of items, each with id, name, content_type, quantity, and amount. This is the most common shape for ecommerce.
customer_action — used for leads, registrations, and appointments. Simpler structure with optional amount and currency at the event level. This is the standard shape for lead gen and SaaS sign-up flows.
plan_enrollment — used for subscription and trial events. Supports an optional plan_id string for your internal plan identifier alongside amount and currency.
For any event that doesn't fit these categories, use the custom event type. Keep eventName as "custom", set eventProps.type to "custom", and put your event label in eventOptions.custom_event_name. Custom event names must be lowercase letters, numbers, underscores, or dashes — between 1 and 64 characters — and cannot reuse a standard event name.
The most common implementation error: putting custom_event_name and event_id inside eventProps instead of eventOptions. These fields belong in the fourth argument, not the third. OpenAI's SDK will silently ignore them in the wrong location, breaking both deduplication and custom event reporting.
What This Means for Your Measurement Stack
ChatGPT ads add a new data source that needs to connect to your existing measurement infrastructure — not exist in isolation. The brands that will get the most out of this channel are the ones who treat it like any other paid channel: proper pixel implementation, server-side backup, UTM attribution, and GA4 integration from day one.
The comparison to Meta CAPI isn't accidental — the pattern is the same because the underlying measurement problem is the same. Browser restrictions, ad blockers, and attribution window limitations affect every ad platform. Dual-track measurement (pixel + server API) with deduplication is the current standard, and OpenAI has built to that standard.
If you're already running Meta Conversions API and server-side tagging via sGTM, adding OpenAI CAPI to your existing infrastructure is relatively straightforward. Your server container already handles event routing — ChatGPT is another endpoint to forward to. If you're not yet on server-side infrastructure, this is a good forcing function to build it.
For brands already investing in UCP measurement and agentic commerce readiness, ChatGPT ads are a natural complement — you're already capturing intent signals from AI-powered interactions. The same infrastructure that handles UCP conversion events can extend to ChatGPT ad attribution.
Frequently Asked Questions
Not necessarily — it depends on your setup and tolerance for implementation complexity. Each configuration has real trade-offs:
- Pixel only: Quick to implement with no backend work. The pixel handles
opprefcapture automatically, but events can be blocked by ad blockers and browser privacy restrictions — meaning you'll miss a portion of conversions. - CAPI only: More reliable signal since server-side events bypass blockers entirely. The catch: you need to manually read and store the
opprefURL parameter when the user arrives, then pass it with every server event. Without it, attribution accuracy drops significantly. - Pixel + CAPI together: Maximum coverage, but both tracks must use a shared
event_idto deduplicate. Without deduplication, conversions get double-counted in Ads Manager reporting.
Add static UTM parameters to your ChatGPT ad landing page URLs — at minimum, utm_source=chatgpt, utm_medium=cpc, and your campaign name. GA4 reads these on arrival and attributes the session correctly. You can then analyze ChatGPT traffic in Acquisition reports alongside Google, Meta, and other paid channels, and compare engagement metrics across sources in the same reporting interface.
OpenAI supports 11 standard event types: page_viewed, contents_viewed, items_added, checkout_started, order_created, lead_created, registration_completed, appointment_scheduled, subscription_created, trial_started, and custom. Each maps to a data shape (contents, customer_action, or plan_enrollment). Monetary values must be integers in the currency's lowest denomination — $129.99 sent as 12999 with currency: "USD".
Need Help Setting Up OpenAI Ads Tracking?
We implement the full measurement stack — Pixel, Conversions API, deduplication, UTMs, and GA4 integration — so you're not flying blind on a channel that's only getting bigger.
Schedule a Free Call