How to Set Up the ChatGPT Ads Measurement Pixel

What the ChatGPT Ads Pixel Is

The ChatGPT Ads Measurement Pixel is OpenAI’s JavaScript-based measurement technology. You install it on your website to measure what happens after someone clicks a ChatGPT Ads sponsored card: purchases, lead submissions, registrations, or any other conversion you care about.

The flow is simple: a user clicks a sponsored card, lands on your site with a click reference in the URL, the pixel captures it and later sends a conversion event, and that event appears in OpenAI Ads Manager.

ChatGPT Ad
   ↓
User clicks ad
   ↓
Your website  (landing URL carries ?oppref=...)
   ↓
OpenAI Pixel
   ↓
Conversion event
   ↓
OpenAI Ads Manager → conversion reporting

Pixel vs Conversions API

OpenAI gives you two ways to send conversion data, and they answer different questions:

When you send the same conversion from both channels, reuse the same event_id so OpenAI recognizes it as one event and does not count it twice.

Before You Start: What You Need

• An OpenAI Ads Manager account (self-serve or agency-managed) with access to measurement settings.
• A data source (Pixel) created inside Ads Manager — this produces your Pixel ID.
• A website where you can add a script to the <head> (or a tag manager / plugin / developer).
• The conversion events you want to measure, configured in Ads Manager to match what your website sends.
• If you run the Conversions API: server-side access and a way to keep the access token secret.

Step 1 — Install the Pixel on Your Website

Create a data source in Ads Manager, copy your Pixel ID (pId_...), and add the JavaScript snippet to every page where conversions can happen. A basic implementation looks like this:

<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>

Two details matter. The if (w.oaiq) returnguard prevents double-loading the SDK if the snippet appears twice. And you must use the exact current snippet from OpenAI’s developer documentation, because the SDK evolves — verify the snippet and parameters against the docs before shipping to production.

Step 2 — Configure Conversion Events

Installing the pixel does not automatically make an action a conversion. The event your website sends must match the conversion you configure in Ads Manager.

Website event:    order_created        Ads Manager:   order_created
Website event:    quote_requested      Ads Manager:   Custom → quote_requested

For custom events the name must match exactly — a similar display name is not enough. Event names are lowercase snake_case (order_created, not orderCreated).

Step 3 — Track Purchases

For e-commerce, the purchase event is the conversion that matters most. Send it when the order is confirmed:

oaiq("measure", "order_created", {
  type: "contents",
  amount: 2599,
  currency: "USD",
  contents: [
    {
      id: "SKU-123",
      name: "Starter Bundle",
      content_type: "product",
      quantity: 1
    }
  ]
}, {
  event_id: "order_12345"
});

order_created is the event name, amount and currency describe the value, contents carries the purchased items, and event_idis your unique identifier for deduplication. Follow the current supported event schema in OpenAI’s docs for the exact field contract.

Step 4 — Track Leads

For lead-generation sites, fire a lead event when the form is submitted:

oaiq("measure", "lead_created", {
  type: "customer_action"
}, {
  event_id: "lead_98765"
});

Step 5 — Custom Conversion Events

Not every conversion is a purchase or a lead. Demo requests, quote requests, completed calculators, applications, and booked consultations all fit a custom event:

oaiq("measure", "custom", {
  type: "custom"
}, {
  custom_event_name: "quote_requested"
});

Configure the identical custom event name in Ads Manager. Custom names allow letters, numbers, underscores and dashes (1–64 characters) and must not collide with a standard event name.

Automatic Advanced Matching

When a click identifier does not connect a conversion, Automatic Advanced Matching (AAM) can improve measurement using eligible first-party customer information — for example recognizable form fields. The pixel normalizes and SHA-256 hashes that information inside the browser.

You do not need to hash emails manually.For the standard Automatic Advanced Matching setup, OpenAI’s current guidance is that no separate pixel change is required, and raw customer information is not sent to OpenAI through AAM.

oppref: The Click Reference That Ties It Together

oppref is OpenAI’s click reference signal, appended to landing URLs from ChatGPT Ads:

https://example.com/product?oppref=gAAAAAb123

The pixel captures this value into a first-party cookie so later pages and conversion events still connect back to the original ad interaction. When you send server-side conversion events, preserving oppref when it is available improves measurement quality.

Practical rule: when you build redirects, landing-page routing, or a custom tracking system, never strip oppref from the URL.

Pixel + Conversions API Deduplication

Run both channels and a single order crosses OpenAI twice — once from the browser pixel, once from your server. OpenAI detects duplicates using the Pixel ID, event name, and event_id:

Order ORD-10001
   ├── Browser Pixel ──→  event_id = ORD-10001
   └── Server CAPI ────→  event_id = ORD-10001

OpenAI keeps the first and ignores the duplicate.

Generate the event_id once (a real order ID works well) and reuse the exact same value on both the pixel call and the server call.

Google Tag Manager Setup

Google Tag Manager is a supported way to deploy the pixel — as long as the tag manager does not block or reorder pixel initialization and event calls. Structure your container around three tags:

• Tag 1 — OpenAI Pixel Base: the init tag loaded on every page (fires the pixel snippet with your Pixel ID).
• Tag 2 — OpenAI Pixel Purchase: fires on the purchase/order-confirmation event, using the data layer.
• Tag 3 — OpenAI Pixel Lead: fires on lead-form submission.

Map events from your existing data layer so the pixel fires on the same triggers your other analytics use.

WooCommerce Setup

In WooCommerce the conversion funnel typically looks like: product viewed → add to cart → checkout started → order created. The order event is the business conversion.

WooCommerce
   ↓
Order created
   ↓
Generate unique Order ID
   ↓
Browser Pixel ─────┐
                   ├── OpenAI Ads (same event_id)
Server CAPI ───────┘

Use the WooCommerce order ID as the event_id— a truly unique value makes deduplication reliable. On WordPress, the free Ridoway Pixel plugin handles the pixel, the server call, and event_id deduplication automatically.

Consent and Privacy

Before implementing tracking, review the consent requirements for your country, your users’ jurisdiction, and your privacy policy. OpenAI’s guidance is that you must clearly disclose what data you collect and, where the law requires it, obtain appropriate consent before sending conversion data.

• Publish a privacy policy and a cookie/tracking disclosure.
• Wire consent management where required (GDPR, ePrivacy, and equivalents).
• Define data retention and what channels may receive events.
• Remember the SDK itself defaults consent to true and supports oaiq("consent", false) before init.

Conversions Not Showing? Troubleshoot in Order

The pixel firing does not mean Ads Manager shows a conversion immediately. Check these in order:

• Is the pixel initializing? — Watch DevTools/Network for the SDK to load from bzrcdn.openai.com.
• Correct Pixel ID? — A wrong ID sends events to another data source and your column stays empty.
• Event name match? — Website event must exactly match the configured conversion (exact spelling for custom events).
• Conversion attached? — The campaign must have a conversion event configured from your events.
• oppref preserved? — Lost click references reduce attribution quality.
• Deduplicated incorrectly? — Browser and server events for the same conversion must share one event_id.
• Reporting delay — OpenAI says attributed conversions can take 24–48 hours to appear in Ads Manager.

A fast way to see whether the pixel fires at all is the free ChatGPT Ads Pixel Checker; the Pixel Helper extension shows each init and measure call live.

Why Ads Manager and Google Analytics Differ

Different conversion totals across platforms is normal. OpenAI Ads and Google Analytics simply do not use the same attribution methodology. Differences come from attribution windows, event timestamps, timezones, consent, browser restrictions, storage availability, deduplication, campaign configuration, and modeled measurement.

OpenAI Ads:        100 conversions
Google Analytics:   82 conversions

A gap like that is not proof of a broken pixel. OpenAI itself says totals across analytics platforms may differ.

Current Reporting and Attribution Windows

In the current Ads Manager (Beta), advertisers can see impressions, clicks, spend, CTR, average CPC, average CPM, and — when measurement is configured — conversions. Click-through and eligible view-through conversions are reported separately. As of September 2026 the available attribution window combinations include:

Because reporting and attribution keep evolving with the Ads Manager Beta, verify the current windows and metrics against OpenAI’s documentation before making optimization decisions.

The Complete Measurement Architecture

A modern, resilient setup combines both channels in one flow:

                   CHATGPT ADS
                        │
                        ▼
                   Ad Click
                        │
                        ▼
                Landing Page (oppref)
                        │
            ┌───────────┴───────────┐
            ▼                       ▼
     OpenAI Pixel             Website / Server
            │                       │
            │                 Conversion Event
            │                       │
            ▼                       ▼
         Browser               Conversions API
            │                       │
            └───────────┬───────────┘
                        │
                   Same event_id
                        │
                        ▼
               OpenAI Measurement
                        │
                        ▼
                 Ads Manager
                        │
           ┌────────────┼────────────┐
           ▼            ▼            ▼
        Clicks      Conversions      ROAS

That is the whole architecture in one picture: one ad click, two event channels, one shared event_id, and a single reporting surface in Ads Manager.

Measurement Partners

OpenAI also supports third-party measurement partners when you prefer an external attribution, reporting, or optimization layer. Documented examples as of September 2026 include Fospha, Hightouch, LiveRamp, Triple Whale, and WorkMagic. For mobile measurement, AppsFlyer, Adjust, and Branch integrations are documented. Capabilities vary by partner.

Best Practices

• Install the pixel on every page where conversion measurement matters, not just the homepage.
• Never strip oppref during redirects, routing, or custom tracking.
• Run pixel + Conversions API together where technically and business-wise appropriate.
• Reuse the same event_id for the same conversion across browser and server.
• Match conversion event names exactly — especially for custom events.
• Understand Automatic Advanced Matching: for the standard setup you do not manually hash data.
• Expect a 24–48 hour reporting delay before judging weekend numbers.
• Do not blindly compare Ads Manager, GA4, and other platforms — attribution methodologies differ.

Frequently Asked Questions