ChatGPT Ads QA Checklist: What Should You Check Before Launch?

You've created your ChatGPT Ads campaign, prepared your ads, and set your budget. Everything looks ready to launch.

But there's one important question: Is your conversion tracking actually working correctly?

With ChatGPT Ads, advertisers need to pay attention to new measurement components, from the OpenAI Pixel and Conversions API to click attribution and event deduplication.

In this guide, we'll walk through a practical ChatGPT Ads QA checklist you can use before and after launching your campaigns.

The goal is simple: make sure your ads are not only running but also generating reliable performance data.

1. How Does ChatGPT Ads Conversion Tracking Work?

Before jumping into the QA checklist, let's understand how ChatGPT Ads measurement works.

There are two main ways to send conversion events to OpenAI:

OpenAI Pixel: A browser-based tracking solution that sends conversion events when users take actions on your website, such as completing a purchase or submitting a form.

OpenAI Conversions API (CAPI): A server-side measurement solution that sends conversion events directly from your backend to OpenAI. It can be particularly useful for purchases and lead events confirmed by your server.

Here's a simplified example of the measurement flow:

ChatGPT Ad → Website → Purchase → OpenAI Pixel / Conversions API → Ads Manager

You can also use Google Analytics 4 (GA4) to analyze campaign traffic, user behavior, and conversions.

However, there's something important to remember:

Just because an event is successfully sent doesn't mean it's being measured correctly.

An event might fire twice, contain an incorrect purchase value, or lose important attribution information along the way.

That's why a proper ChatGPT Ads QA process should cover everything from event triggering to attribution and reporting.

2. Check UTM Parameters and Landing Page Tracking

Let's start with a simple but essential question:

When someone clicks your ChatGPT Ad, do they land on the correct page, and is their traffic source recorded accurately?

For example, you might use a landing page URL like this:

https://example.com/product?utm_source=chatgpt&utm_medium=paid&utm_campaign=fall_campaign

These UTM values are just an example of a campaign naming convention. Your actual naming structure should follow your analytics strategy.

What Should You Check?

• Does the landing page URL load correctly?
• Are UTM parameters preserved after redirects?
• Does GA4 record the expected source and medium?
• Are UTM naming conventions consistent across campaigns?
• Are campaign names correctly reflected in your analytics reports?

For example, if you're using utm_source=chatgpt and utm_medium=paid, you should verify that GA4 records the session with those source and medium values.

Small inconsistencies in UTM parameters can split campaign traffic across multiple reporting dimensions.

And that makes performance analysis unnecessarily complicated.

3. Verify the OpenAI Click Reference (oppref)

If you've worked with Google Ads or Meta Ads, you're probably familiar with tracking parameters like gclid and fbclid.

ChatGPT Ads also has a click reference parameter called oppref.

This identifier helps OpenAI associate eligible ad clicks with conversions that happen later.

For example:

https://example.com/product?utm_source=chatgpt&oppref=EXAMPLE_CLICK_REFERENCE

The oppref parameter can support click-through attribution when the reference is correctly captured and passed through the measurement flow.

Where Can Things Go Wrong?

Imagine this scenario:

A user clicks your ChatGPT Ad, lands on a product page, and then moves to checkout.

During that journey, your website redirects the visitor to another URL.

If the click reference isn't preserved or made available to the conversion tracking setup, attribution quality may be affected.

The OpenAI Pixel can capture oppref and store it in a first-party cookie, subject to applicable consent and browser conditions.

However, the Conversions API doesn't automatically capture this parameter. Your server-side implementation needs to pass the original value when it's available.

oppref QA Checklist

• Is the oppref parameter present on the landing page after an eligible ad click?
• Is the reference preserved during redirects?
• Is it captured and stored appropriately when consent and applicable requirements allow?
• If you're using CAPI, is the original reference included in the conversion event?
• Does the measurement flow continue to work when users navigate to other pages?

One important detail: The oppref parameter doesn't need to appear in every page URL.

What matters is whether the reference remains available when it's needed for conversion attribution.

Also, don't assume every conversion will include an oppref. Server-side events without this reference can still be useful for supported measurement scenarios.

4. Test OpenAI Pixel and Conversions API Deduplication

This is one of the most important parts of the ChatGPT Ads QA process.

Let's say you're running an e-commerce website.

When a customer completes a purchase, your website sends the same conversion through two different methods:

• OpenAI Pixel from the browser
• OpenAI Conversions API from the server

This can be a perfectly valid tracking setup.

In fact, combining browser-side and server-side tracking can improve measurement reliability.

But there's a potential problem.

If the two events aren't correctly matched, the same purchase could be counted more than once.

How Can You Prevent Duplicate Conversions?

When sending the same purchase through both Pixel and CAPI, make sure the events use:

• The same Pixel ID
• The same event name
• The same event ID

For example:

Browser Event

event_name: order_created
event_id: purchase_12345

Server Event

event_name: order_created
event_id: purchase_12345

These are simplified event records to demonstrate the deduplication logic, not actual OpenAI API payloads.

In the actual Conversions API, the event ID is sent using the id field, while browser-side tracking uses event_id.

Using consistent identifiers allows OpenAI to recognize that both events represent the same conversion.

Pixel and CAPI Deduplication QA Checklist

• Do browser and server events use the same event ID for the same conversion?
• Are both events associated with the same Pixel ID?
• Do they use the same supported event name?
• Does refreshing the thank-you page trigger another conversion?
• Can backend retries accidentally create duplicate events?
• Are retries using the original event ID rather than generating a new one?

The goal isn't to disable Pixel or CAPI.

The goal is to make sure both integrations describe the same conversion consistently, without inflating your reporting.

5. Validate Conversion Events and Revenue Data

Your events might be firing correctly.

But are they sending the right information?

Let's look at a simple example.

A customer completes a purchase on your website:

• Actual order value: 1,500 TRY
• Reported conversion value: 150 TRY

The purchase event was successfully triggered, but the revenue data is incorrect.

This creates a serious problem when analyzing campaign performance, especially if you're using metrics such as Return on Ad Spend (ROAS).

A campaign could appear less profitable than it actually is simply because the measurement implementation is sending incorrect values.

What Should You Validate?

There's one important technical detail here.

OpenAI purchase amounts use minor currency units.

For example, a purchase worth 1,500.00 TRY should be represented as 150000 in the amount field when the currency uses two decimal places.

Sending the value in the wrong unit can significantly distort revenue reporting.

Also, make sure the conversion event configured in Ads Manager matches the event your website or server is sending.

For instance, if your campaign is optimized for purchases, you should verify that your implementation uses the appropriate supported conversion event, such as order_created.

Recommended QA Test

Create at least three test orders and compare the results across:

1. Your backend or order management system
2. Browser-side and server-side event records
3. OpenAI's conversion event monitoring tools

Check the event ID, order value, currency, and timestamp for every test.

A successful event request alone isn't enough. You need to confirm that the data matches the actual transaction.

6. Check Consent and Privacy Settings

If you're using server-side measurement, there's another critical area you shouldn't overlook: user consent.

Sending data from your server doesn't automatically mean you're allowed to collect or share it without the appropriate permissions.

This is especially important for websites using Google Tag Manager (GTM), server-side GTM (sGTM), or a Consent Management Platform (CMP).

Scenario 1: Consent Accepted

A user accepts the relevant tracking permissions.

Check whether the permitted OpenAI Pixel and CAPI events are sent correctly.

Scenario 2: Consent Rejected

A user rejects the relevant tracking permissions.

Verify that tracking and data-sharing activities requiring those permissions are blocked.

This includes making sure server-side integrations don't continue forwarding restricted information after browser-side tracking has been disabled.

Scenario 3: Consent Updated

A user changes their consent preferences.

Does your measurement setup respond correctly?

For example, if a user withdraws consent, your tracking configuration should respect that change across the relevant browser and server integrations.

One Important Reminder

If you've already configured Google Consent Mode, don't automatically assume those settings also control your OpenAI Pixel and Conversions API integration.

Consent behavior for OpenAI measurement should be tested separately.

The objective is to collect accurate measurement data while respecting user preferences and applicable privacy requirements.

ChatGPT Ads QA Checklist: Final Pre-Launch Checks

Before launching your ChatGPT Ads campaign, use this checklist to verify your measurement setup.

Landing Page & Attribution

• Landing page URLs work correctly.
• UTM parameters are preserved after redirects.
• GA4 records the expected traffic source and medium.
• Campaign naming conventions are consistent.
• The oppref reference is available when required for attribution.

OpenAI Pixel & Conversions API

• OpenAI Pixel events fire correctly.
• CAPI events are successfully delivered.
• Browser and server events use matching event IDs.
• The same Pixel ID is used for events that require deduplication.
• Conversion event mapping is configured correctly.
• Page refreshes and backend retries don't create duplicate conversions.

Revenue & Data Quality

• Event IDs and order identifiers can be matched to actual transactions.
• Conversion values reflect real purchase amounts.
• Currency codes are correct.
• Amounts use the expected currency units.
• Event timestamps are accurate.
• Test conversions have been compared with backend records.

Consent & Reporting

• Consent acceptance, rejection, and update scenarios have been tested.
• OpenAI Pixel and CAPI respect applicable consent requirements.
• GA4 and OpenAI Ads Manager reports have been reviewed.
• Attribution windows and reporting delays have been considered.
• Differences between analytics platforms have been investigated where necessary.

Keep in mind that GA4 and OpenAI Ads Manager may report different conversion totals because they use different attribution methods, reporting settings, and measurement signals.

A reporting difference doesn't automatically mean that your tracking is broken.

The important thing is to understand why the difference exists.

Conclusion: Reliable Tracking Starts Before Your Ads Go Live

ChatGPT Ads introduces a new opportunity for advertisers to reach potential customers and measure campaign performance.

But many of the tracking challenges we've already seen with Google Ads and Meta Ads can also appear in ChatGPT Ads campaigns.

That's why I'd focus on five areas before launching any ChatGPT Ads campaign:

UTM tracking, oppref attribution, Pixel and CAPI deduplication, conversion event mapping, and GA4 reporting validation.

These checks help you identify measurement problems before they start influencing your campaign decisions.

Because getting your ads to run is one thing.

Knowing whether those ads are actually performing is something else entirely.

And without reliable conversion tracking, even the best campaign optimization strategy can lead to the wrong decisions.