ChatGPT Ads conversion tracking is OpenAI’s system for connecting an ad interaction to a later lead, purchase or subscription. It has three parts: the oaiq browser pixel, a server-side Conversions API, and the oppref click reference OpenAI appends to your landing page. When the browser and the server report the same action, a shared event ID keeps it to one conversion.

I wired this into the Advanced Tracking Academy checkout on 6 August 2026, and this page is the reference I keep for the platform rules. The rules have moved since then: phone hashes are accepted now, the user fields became lists, and Europe and Brazil opened for buying. Everything below was rechecked against OpenAI’s developer docs on 17 October 2026.

Three ways to send an event

The Measurement Pixel loads from bzrcdn.openai.com/sdk/oaiq.min.js and exposes a global called oaiq. The Conversions API is a server-side POST to bzr.openai.com/v1/events, with the Pixel ID as a query parameter and a separate bearer key. The image tag is a 1x1 request for pages that cannot run JavaScript; it carries no user data and does not capture oppref on its own.

OpenAI recommends running the pixel and the Conversions API together and says the API is “a more reliable tracking source than the pixel alone” (Conversions API). A server-only setup still needs a Pixel ID, because the Pixel ID is what names the data source.

Put the snippet near the top of <head>:

<script>
  (function (w, d, s, u) {
    if (w.oaiq) return;
    var q = function () { q.q.push(arguments); };
    q.q = []; w.oaiq = q;
    var js = d.createElement(s); js.async = true; js.src = u;
    var f = d.getElementsByTagName(s)[0]; f.parentNode.insertBefore(js, f);
  })(window, document, "script", "https://bzrcdn.openai.com/sdk/oaiq.min.js");
  oaiq("init", { pixelId: "<YOUR-PIXEL-ID>" });
</script>

The current pixel docs show page_viewed as an explicit oaiq("measure", "page_viewed", ...) call and name no event that fires on init by itself. Call it yourself. In our build, the web container sends page_viewed, lead_created and checkout_started as three separate tags.

If your site sends a Content Security Policy, add https://bzrcdn.openai.com to script-src and connect-src, and https://bzr.openai.com to connect-src and img-src. A pixel blocked by CSP fails quietly.

Flow diagram: the same purchase arrives twice at OpenAI, once from the browser pixel and once from the server, matched on a shared event ID and kept as one conversion.
Two legs, one conversion. The shared ID is what stops the pixel and the server from both claiming it.

oppref carries click attribution

When someone clicks a ChatGPT ad, OpenAI appends oppref to the landing URL. The pixel reads it and stores it in a first-party __oppref cookie, and it sets a second cookie, __obref, as a browser reference for the visitor. The Conversions API does not capture oppref for you: your server has to read it, keep it and send it back on the event.

oppref is what ties a conversion to the click. It is not the only way a conversion reaches your reports. OpenAI now reports view-through conversions within one day of an eligible impression, with no extra field, and its docs say: “We recommend sending all conversion events, not just those with an oppref.” Do not filter out conversions that arrive without one.

Capture rules, cookie lifetimes, redirects and the tracking template that can copy oppref into your own parameter all live in the oppref guide.

Standard events and the data.type field

OpenAI defines twelve standard event types plus custom (Supported Events). Each event carries a data.type, and that field is the one people leave out:

data.type Events
contents page_viewed, contents_viewed, items_added, checkout_started, order_created
customer_action lead_created, registration_completed, appointment_scheduled, app_installed, app_opened
plan_enrollment subscription_created, trial_started
custom custom, with a custom_event_name

app_installed and app_opened go through the Conversions API only, with action_source set to mobile_app. There is no native mobile SDK.

There is no refund event. A custom refund event is fine for your own records, but it does not reverse the original conversion or its reported sales. OpenAI defines subscription_created as the moment “a paid subscription starts” and lists no renewal event (Supported events, checked 2026-10-17). Keep subscription_created for the start. A completed renewal payment fits order_created (“a purchase is completed”); use a clearly named custom event instead if you want renewals reported apart from new purchases. Whichever you pick, write the mapping down.

A server event with current field names

POST https://bzr.openai.com/v1/events?pid=<PIXEL-ID>
Authorization: Bearer <CONVERSIONS-API-KEY>

{
  "validate_only": false,
  "integration_source": "your-platform",
  "events": [{
    "id": "order_12345",
    "type": "order_created",
    "timestamp_ms": <EVENT-TIME-IN-MILLISECONDS>,
    "action_source": "web",
    "source_url": "https://example.com/thank-you",
    "oppref": "<original oppref value, unchanged>",
    "data": { "type": "contents", "amount": 4200, "currency": "USD" },
    "user": {
      "obref": "<__obref cookie, unchanged>",
      "emails_sha256": ["<64 lowercase hex characters>"],
      "phone_numbers_sha256": ["<64 lowercase hex characters>"],
      "external_ids_sha256": ["<64 lowercase hex characters>"],
      "ip_address": "203.0.113.10",
      "user_agent": "Mozilla/5.0 ..."
    }
  }]
}

Four details in that payload matter more than they look:

  • Amounts are integers in the currency’s minor unit. OpenAI’s example is 4200 for USD 42.00. contents[].amount is the price of one unit and the event amount is the whole event. Currencies with no minor unit, such as JPY, follow their ISO 4217 exponent, so check yours before you multiply by 100.
  • timestamp_ms must be within the last 7 days and no more than 10 minutes in the future. A delayed or offline upload job has to run at least weekly.
  • Batches are all or nothing. Up to 1,000 events per request, and one invalid event fails the whole batch.
  • validate_only: true is a dry run. It checks the key, the Pixel ID and the schema and stores nothing. On our account on 6 August 2026 a single test event came back as {"accepted_events":1}.

User data: lists, three values, and one case rule

The Conversions API now takes plural list fields: emails_sha256, phone_numbers_sha256, external_ids_sha256, first_names_sha256, last_names_sha256, countries, regions, cities and postal_codes, plus obref, ip_address, user_agent and an Android android_advertising_id (Send user data, checked 2026-10-17). Each list holds at most three values. A fourth returns HTTP 400; the API does not truncate.

Normalization differs by field, and one of them catches people:

Identifier Normalize before hashing Example
Email trim, lowercase Ana@Example.com becomes ana@example.com
Phone keep country code; drop spaces, brackets, dots, hyphens, the leading + and leading zeros +1 (415) 555-2671 becomes 14155552671
External ID trim only, keep the case Cus_9AbC stays Cus_9AbC
First and last name lowercase, remove whitespace and ASCII punctuation, keep accents O'Connor becomes oconnor

Hash the UTF-8 value with SHA-256 and send lowercase hex. Never send raw email, phone, external ID or names. Geography goes raw.

Lowercasing external IDs is the mistake I would look for first. The Stape server template we installed in August lowercased every value before hashing, external IDs included, and did not send phone hashes at all. The current version on GitHub (stape-io/openai-capi-tag, last updated 2026-10-14, checked 2026-10-17) maps phone to phone_numbers_sha256 and trims external IDs without lowercasing them. If you installed it in the summer, update it from the gallery.

Phone hashes here are not the same as phone hashes in ChatGPT Ads custom audiences. Audience files hash E.164 with the + kept. Conversion events drop it.

Automatic advanced matching is a separate pixel feature: it detects customer details typed into forms, hashes them in the browser and sends only the hash. OpenAI says pixels created through its API use it automatically. Check your own pixel’s setting in Ads Manager if you need to control what leaves the page.

Deduplication keeps the first event

Send the same value as the pixel’s event_id and the API’s id, under the same Pixel ID. OpenAI matches duplicates on Pixel ID, event name and that ID (plus custom_event_name for custom events), and “uses the first event it receives for a matching key and ignores later duplicates.”

oaiq("measure", "checkout_started",
  { type: "contents", amount: 4200, currency: "USD" },
  { event_id: "chk_12345" });

First-in wins has a consequence. A thank-you page that fires order_created before your payment webhook means the browser’s unverified copy is the one that counts, and the verified server event is dropped as a duplicate. Either fire the browser purchase only after payment is confirmed, or do what we did: send checkout_started from the browser and order_created only from the server.

If you already share an event ID between browser and server for Meta, reuse it here. One ID per event is easier to trace when a number looks wrong.

Where measurement needs consent, set it before the pixel initializes:

oaiq("consent", false);
oaiq("init", { pixelId: "<YOUR-PIXEL-ID>" });
// after the visitor grants measurement consent:
oaiq("consent", true);

Consent defaults to true unless you set false or the pixel finds a stored denial. While it is false, the pixel sends nothing, and calling oaiq("consent", false) deletes both __oppref and __obref. Events blocked during denial are not replayed once consent is granted (Control measurement consent).

Map this to your consent platform the same way you map Google’s ad_storage. The pixel’s switch does not reach your server: a webhook sender has to honour the visitor’s decision from your own records and stop forwarding obref after a revocation. Consent is a condition of measuring, never an obstacle to route around.

Setup order, as OpenAI documents it

The Conversion Tracking guide lays it out in this order:

  1. Create a data source (type web). The response holds two IDs: pixel_id for the pixel and the API, and id for event settings. They are not interchangeable.
  2. Install the pixel, create a Conversions API key, or both. The key is separate from the Advertiser API key in Settings.
  3. Send events. For a custom event, send it first, then create a setting whose custom_event_name matches exactly; a matching display name is not enough.
  4. Create the conversion event setting, with attribution_window_days set to 30 as the docs instruct.
  5. Check that events arrive (next section).
  6. Attach the setting to a campaign. Goal reporting starts when you attach it and does not cover earlier traffic, so attach before you spend.

Clicks and impressions campaigns can attach or change settings later; an update replaces the whole list, so send every setting you want to keep. A conversion-optimized campaign needs exactly one active standard event chosen at creation, and that choice cannot be changed. Custom events cannot be the optimization goal.

On 6 August 2026 our self-serve account minted the pixel, the Conversions API key and three event settings through the Advertiser API with no partner enablement. The troubleshooting checklist covers the 404 some accounts get instead.

Confirming events arrive

There is now an endpoint for this:

curl -G "https://api.ads.openai.com/v1/conversions/events" \
  -H "Authorization: Bearer ${OPENAI_ADS_API_KEY}" \
  --data-urlencode "pid=${PIXEL_ID}" --data-urlencode "limit=50"

It returns a sample of events from roughly the last 15 minutes and tags each with an api_channel. The guide says browser events show as pixel_sdk and server events as server_to_server. The API reference describes Pixel SDK events only and says the stream is available to enabled accounts, with a 404 otherwise. validate_only requests never appear in it, and a sampled miss does not prove an event was lost. Use the Advertiser API key, not the Conversions API key.

When the endpoint is unavailable, the Event flow view in Ads Manager or the network requests to bzr.openai.com from a real browser are the fallbacks. Reporting is slower: OpenAI says to “allow at least one day for conversion data to appear” (Reporting).

Limits no tracking setup changes

Where you can buy. OpenAI said ChatGPT Ads were available in more than 60 countries on 23 September 2026, including the European markets that opened in August, Brazil and Mexico (ppc.land summary; OpenAI availability page; checked 2026-10-17). Custom audiences and personalized ads are not available for campaigns targeting the EEA or Switzerland. Check the location list in your own account before you plan a market.

What you can sell. OpenAI screens restricted categories at account level and withholds ads near sensitive topics and around minors. A cleaner signal does not make a restricted category eligible, so confirm eligibility before you spend a week on measurement.

What our build showed. On 6 August our tags went live, the pixel’s beacon left the browser and both cookies were set on the real site. Ads could not serve yet: the first card failed with “couldn’t verify this card for Ads billing”. The pixel and the dry-run API call worked regardless, because billing only gates ad delivery.

If you already run Meta CAPI and want to know which parts of that build carry over, the ChatGPT Ads vs Meta CAPI adapter notes list the field and retry differences. The server-side GTM build notes show how the click reference survives to a Stripe webhook.