ChatGPT Ads Conversions API: how to set up the Pixel and server events

ChatGPT Ads measures conversions with two OpenAI tools: the Measurement Pixel in the visitor’s browser and the Conversions API, which your server calls. Use the Pixel to capture the ad click, and the Conversions API for anything your backend confirms. Send both with one shared event ID, from a server container on your own domain.

What conversion tracking does ChatGPT Ads offer?

ChatGPT Ads is a new ad platform, and its measurement tools are new too. As of October 2026, OpenAI’s conversion measurement guide says you create a data source in Ads Manager, then send conversion events with the OpenAI Pixel, the Conversions API, or both. OpenAI credits a conversion when the event matches a conversion event set on the campaign, falls inside its attribution window, and can be connected to an eligible ad click.

The pieces available today:

• Measurement Pixel. A JavaScript tag loaded from OpenAI’s CDN. It sends browser events and captures the click reference.
• Conversions API. A server endpoint for the same events, plus app events and events with an offline action source.
• Image tag. OpenAI’s image tag sends one page-load event without JavaScript. It cannot send customer data or measure later clicks and form submits.
• Partner integrations. OpenAI’s partner guide lists measurement partners such as LiveRamp, Hightouch and Northbeam, and names Stape and Datahash as tools for implementing the Pixel and Conversions API.
• Conversion-optimized campaigns. Per OpenAI’s campaign guide, these need conversion tracking through the Conversions API and/or the Pixel, and optimize toward one standard event. Custom events are not supported as the goal.

The click reference. OpenAI appends an oppref parameter to the landing page URL. The Pixel stores it in a first-party __oppref cookie for 30 days. The Conversions API does not capture it, so your server has to read it and send it with each event. OpenAI also documents automatic advanced matching, where the Pixel hashes customer details it finds on the page, and modeled conversions where available.

Pixel vs Conversions API: what each one does

You can run either one alone. OpenAI recommends both together “for more resilient measurement.” Click through to see how they differ.

What you need before you start

1. 1An active OpenAI Ads Manager account with access to the ad account you advertise from.
2. 2A data source in the Conversions section of Ads Manager, and its Pixel ID. The Conversions API needs a Pixel ID even if you never install the browser Pixel.
3. 3A Conversions API key from the same Conversions section. It is separate from the Advertiser API key under Settings, which is for setup and reporting calls. LiveRamp’s setup guide says the key is generated once, so copy it into a secret store straight away.
4. 4A custom tracking domain for your server container, such as sgtm.example.com, if you send server events through server-side GTM.
5. 5A consent management platform that sets the visitor’s choice before the Pixel loads, where your consent policy requires one.
6. 6A short list of the events you will send, mapped to OpenAI’s standard names, such as lead_created or order_created.

How to set up ChatGPT Ads conversion tracking

The order below follows OpenAI’s developer docs. Do the browser side first, because the server side depends on what it captures.

1. Install the Pixel

OpenAI’s Pixel guide loads the script oaiq.min.js from bzrcdn.openai.com near the top of the <head>, then initializes it with your Pixel ID. Send each conversion with a measure call, and pass an event ID in the options:

oaiq("init", { pixelId: "<PIXEL-ID>" });

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

If you use Google Tag Manager, Stape publishes a web tag for the Pixel. Where consent is required, call oaiq("consent", false) before init and set it to true once the visitor agrees. While consent is false, OpenAI says no measurement events are sent, and blocked events are not replayed later.

2. Keep the click reference

Make sure redirects and landing pages keep the oppref parameter, so the Pixel can store it. If a lead or order is saved on your backend, save the __oppref cookie value with it. OpenAI says to pass it exactly as received, and never to invent one or reuse another visitor’s.

3. Send server events

Every server event goes to the same endpoint: POST https://bzr.openai.com/v1/events?pid=<PIXEL-ID>, with the Conversions API key as a Bearer token. There are two ways to make that call.

Server-side GTM on your own domain (our default). Run a GTM server container on a subdomain of your site, such as sgtm.example.com, and add a Conversions API tag to it. Stape’s OpenAI Ads Events API tag takes the Pixel ID, the API key and an action source, and can store the click reference as an __oppref cookie from the server. Google’s custom domain guide says a server container on its default domain “can only set JavaScript cookies,” so map your own subdomain before launch. Use the host’s default URL only while you test.

A direct call from your backend. Use this for outcomes your systems confirm after the visit, such as a paid order or a qualified lead in your CRM. Your server builds the event, adds the saved click reference and hashed customer data, and posts it:

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

{
  "events": [{
    "id": "lead_8f2k91",
    "type": "lead_created",
    "timestamp_ms": 1793000000000,
    "action_source": "web",
    "source_url": "https://www.example.com/contact",
    "oppref": "<value of the __oppref cookie>",
    "user": {
      "emails_sha256": ["<SHA-256 of the normalized email>"],
      "ip_address": "203.0.113.7",
      "user_agent": "Mozilla/5.0 ..."
    },
    "data": { "type": "customer_action" }
  }]
}

The OpenAI Pixel script itself still loads from OpenAI’s CDN. OpenAI’s docs don’t describe serving it from your own domain, so the custom domain applies to your server container.

4. Attach the conversion to your campaigns

OpenAI’s conversion tracking guide connects events to campaigns through a conversion event setting: the event type, an attribution window and the data source. A campaign only reports events that match a setting attached to it. For a conversion-optimized campaign, pick one standard event when you create it, because it can’t be changed later.

Field mapping: Pixel to Conversions API

Most fields have the same meaning on both sides but a different name or place. These are the ones that matter for matching and deduplication.

In our own integration, we send source_url as the page’s origin and path only, without the query string, so no form values or email addresses in a URL reach the platform.

How deduplication works

When the Pixel and your server both send the same conversion, OpenAI needs a way to count it once. Its Conversions API reference matches on three values: the Pixel ID, the event name and the event ID. The event ID is event_id in the Pixel and id in the API. For custom events, the custom_event_name must match too. OpenAI keeps the first copy it receives and ignores later ones.

• Generate the event ID once per conversion, for example from your lead or order ID, and use it on both sides.
• Keep the same ID and timestamp when you retry a failed request. A new ID looks like a second conversion.
• Use a new ID for each different action, even when the same person converts twice.
• Check for a second sender, such as a Shopify app, a duplicate tag or a partner integration, that sends the same event with its own ID.

OpenAI’s docs don’t state a time window for deduplication. Meta, by comparison, documents 48 hours, as covered in Meta Conversions API deduplication. Send the server copy promptly and don’t rely on late matches.

How to check that it works

1. 1Turn on Pixel debug mode (debug: true in init), complete one real action, and confirm the event and its event ID appear in the browser console and the network request.
2. 2If you use server-side GTM, run Preview on the web and server containers together and confirm the Conversions API tag fires once, on your own tracking domain.
3. 3Send a server request with validate_only: true to check its format. Validate-only events are not saved and do not appear in monitoring.
4. 4Call the recent events endpoint (GET /v1/conversions/events with your pid) using the Advertiser API key. It returns a sample from roughly the last 15 minutes. Browser events show as pixel_sdk and server events as server_to_server.
5. 5Repeat the action with consent declined, and confirm that neither the Pixel nor the server sends an event.
6. 6Remove validate_only and debug settings before production traffic.
7. 7After 24 to 48 hours, compare Conversions in Ads Manager with your own lead or order records for the same dates.

Ads Manager also shows an event quality score for a data source. OpenAI’s troubleshooting guide says a low score does not by itself mean tracking is broken, and warns against sending extra events or invented identifiers to raise it.

Common errors and fixes

How ChatGPT Ads fits with your other platforms

The pattern is the same as on other ad platforms: one browser tag, one server event, one shared ID. Only the field names change. If you already run server-side tagging, ChatGPT Ads is one more server tag in the same container, on the same tracking domain, with the same event ID you send to other platforms.

• Meta matches its Pixel and Conversions API on event name and event ID within 48 hours. See Meta Conversions API deduplication.
• Google Ads adds hashed customer data to conversions you already track. See the enhanced conversions guide.
• Offline and CRM conversions are sales or qualified leads confirmed after the visit. The Conversions API accepts offline, phone_call and physical_store action sources, within its 7-day limit. LiveRamp also runs an OpenAI Conversions API program for offline conversions, which it says is in limited availability and by invitation only. Our ChatGPT Ads offline conversions guide covers which CRM stages to send and how the timing limits work. For the general approach, read our beginner’s guide to offline conversions.

Maven sends conversions from a CRM, payment or commerce system to OpenAI Ads through its Conversion Events API, alongside Google Ads and Meta. If you want to start with the browser side, a Free Tracking Scan shows which tags load on your site today.