How to Track ChatGPT Ads Conversions on Shopify

How do you track ChatGPT Ads conversions on Shopify?

On Shopify, the simplest route is OpenAI’s free ChatGPT Ads app, open to US stores for now, which connects OpenAI’s pixel for you. Otherwise use a custom pixel, a tracking app or OpenAI’s Conversions API. Send checkouts and purchases from Shopify’s checkout or a server, never from theme code, which doesn’t run there, and give each pixel one sender.

ChatGPT Ads, its measurement tools and OpenAI’s Shopify app have all changed within months, so every OpenAI fact below links its source, checked 24 September 2026.

What does OpenAI need from your store?

A Pixel ID for the browser, a Conversions API key for your server, and events under OpenAI’s own names, with amounts as whole numbers in the currency’s smallest unit. Shopify’s standard events map onto them like this:

• Pixel ID and key. Both come from Tools → Conversions in OpenAI’s Ads Manager. The key belongs on your server: OpenAI says never to call the Conversions API from page code (Measurement Pixel).
• Amounts. Integers in the currency’s standard minor unit: 2599 for USD 25.99, 8900 for JPY 8,900. Shopify’s events carry decimals, so convert them (supported events).
• Click and browser references. A ChatGPT ad click adds oppref to your landing page’s address. OpenAI’s pixel stores it in a __oppref cookie for 30 days, renewed on each new click, beside a browser reference, __obref, kept for a year (Measurement Pixel). The Conversions API doesn’t capture either for you.
• Timing. A server event must be dated within the last 7 days and no more than 10 minutes ahead (Conversions API). OpenAI’s event-quality check looks for server events within an hour of the action.
• One ID per conversion. OpenAI keeps the first event it receives for each Pixel ID, event name and event ID and ignores later copies (Conversions API). Two tools that give one purchase different IDs are counted twice.

Which setup should you use?

Choose OpenAI’s app if your store is in the US and you want campaigns and tracking in one place, or a custom pixel if you write JavaScript and browser events are enough. Choose your own server or a tracking app when you want purchases sent from the order itself.

Whichever you pick, give each pixel ID one sender. Running OpenAI’s app and a second tool on the same pixel creates two copies of every purchase under different IDs.

How do you use OpenAI’s ChatGPT Ads app?

Install it from the Shopify App Store, connect your Ads Manager account and select or create the pixel it calls OpenAI Pixel for Shopify. OpenAI built the app and launched it on 3 September 2026, free to install (App Store listing); for now it serves US stores, with more countries to follow (OpenAI’s Shopify guide, checked 24 September 2026).

1. In Shopify, install or open the ChatGPT Ads app.
2. Select Connect Account, then choose your Ads Manager account, or create one with your website, industry, country, currency and time zone.
3. Select or create OpenAI Pixel for Shopify, and connect it so eligible commerce events flow to Ads Manager.
4. Wait for your products to sync into your ChatGPT Ads product feed. The time depends on the size of your catalogue.
5. Build a campaign in the app with Create Campaign, or in Ads Manager, which has more options.

The listing says the app can edit your store’s web pixels and server pixels, but OpenAI’s guide doesn’t say whether purchases also go through the Conversions API. If products don’t appear, OpenAI’s checklist starts with the connected account, the feed sync and the pixel connection, and asks you to use Chrome or Safari.

How do you add OpenAI’s pixel as a Shopify custom pixel?

Paste OpenAI’s code without its <script> tags into a custom pixel, then subscribe to Shopify’s events and send each one under OpenAI’s name. A custom pixel receives nothing until you subscribe.

Don’t paste the snippet into theme.liquid instead. Your theme’s layout applies only to non-checkout pages (theme layouts) and app embeds can’t load on checkout pages (app embeds), so theme code misses every checkout and purchase.

The subscriptions are where DIY setups fail. In a Shopify Community thread from September 2026, a merchant’s snippet, pasted with its <script> tags, threw a code error; without them it showed 0 events in Shopify’s Pixel Helper. Replies then had to correct the command (measure, not track), the event names and the amounts.

1. From your Shopify admin, go to Settings → Customer events, name the pixel and click Add pixel (managing custom pixels).
2. Under Customer privacy, leave Permission on Required. New pixels require Marketing and Analytics permissions by default (pixels overview).
3. Paste the code below into Code with your Pixel ID, click Save, then Connect pixel.

// OpenAI's loader and init, from its Measurement Pixel guide, without the <script> tags
(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>",
  debug: true, // logs to the browser console while you test; remove it afterwards
});

// Shopify sends decimal prices; OpenAI wants integers in the currency's minor unit
function minorUnits(money) {
  var digits = new Intl.NumberFormat("en", {
    style: "currency",
    currency: money.currencyCode,
  }).resolvedOptions().maximumFractionDigits;
  return Math.round(money.amount * Math.pow(10, digits));
}

function lineContents(lineItems) {
  return lineItems.map(function (item) {
    return {
      id: item.variant?.id,
      name: item.title,
      content_type: "product",
      quantity: item.quantity,
    };
  });
}

analytics.subscribe("page_viewed", function () {
  oaiq("measure", "page_viewed", { type: "contents" });
});

analytics.subscribe("product_viewed", function (event) {
  var variant = event.data.productVariant;
  oaiq("measure", "contents_viewed", {
    type: "contents",
    contents: [{ id: variant.id, name: variant.product.title, content_type: "product" }],
  });
});

analytics.subscribe("product_added_to_cart", function (event) {
  var line = event.data.cartLine;
  oaiq("measure", "items_added", {
    type: "contents",
    amount: minorUnits(line.cost.totalAmount),
    currency: line.cost.totalAmount.currencyCode,
    contents: [
      {
        id: line.merchandise.id,
        name: line.merchandise.product.title,
        content_type: "product",
        quantity: line.quantity,
      },
    ],
  });
});

analytics.subscribe("checkout_started", function (event) {
  var checkout = event.data.checkout;
  oaiq(
    "measure",
    "checkout_started",
    {
      type: "contents",
      amount: minorUnits(checkout.totalPrice),
      currency: checkout.totalPrice.currencyCode,
      contents: lineContents(checkout.lineItems),
    },
    { event_id: checkout.token } // Shopify can fire this again when a shopper re-enters checkout
  );
});

analytics.subscribe("checkout_completed", function (event) {
  var checkout = event.data.checkout;
  oaiq(
    "measure",
    "order_created",
    {
      type: "contents",
      amount: minorUnits(checkout.totalPrice),
      currency: checkout.totalPrice.currencyCode,
      contents: lineContents(checkout.lineItems),
    },
    { event_id: checkout.order?.id } // a server copy of this purchase must use the same value as its id
  );
});

The loader and init call are OpenAI’s own snippet, and the event fields come from Shopify’s Web Pixels API.

Important: A custom pixel runs in a separate frame that can’t read your page, and the address it sees is the sandbox’s, not the shopper’s (Shopify’s web pixels guide). OpenAI’s pixel normally reads oppref from the landing page’s address and, with automatic advanced matching on, customer details from forms; inside the sandbox it may manage neither. Check with debug: true, and send purchases through the Conversions API with oppref attached if ChatGPT clicks matter to you.

To see the whole pattern for any vendor, read how to add a custom pixel on Shopify.

How do you send purchases through the Conversions API?

From a server, never the browser: when Shopify tells your server about a new order, post an order_created event to OpenAI with your Conversions API key, the same ID the pixel used and, if the shopper came from an ad, oppref. The request below follows OpenAI’s own example (Conversions API).

curl -X POST "https://bzr.openai.com/v1/events?pid=<PIXEL-ID>" \
  -H "Authorization: Bearer <API-KEY>" \
  -H "Content-Type: application/json" \
  --data '{
    "validate_only": false,
    "events": [
      {
        "id": "<THE-VALUE-THE-PIXEL-SENT-AS-EVENT_ID>",
        "type": "order_created",
        "timestamp_ms": <ORDER-TIME-IN-MILLISECONDS>,
        "oppref": "<OPPREF-CAPTURED-ON-THE-STOREFRONT>",
        "source_url": "https://shop.example.com/checkout/confirmation",
        "action_source": "web",
        "user": {
          "obref": "<__obref-COOKIE-VALUE-CAPTURED-ON-THE-STOREFRONT>",
          "emails_sha256": ["<SHA-256-OF-THE-TRIMMED-LOWER-CASE-EMAIL>"],
          "ip_address": "203.0.113.1",
          "user_agent": "Mozilla/5.0"
        },
        "data": { "type": "contents", "amount": 2599, "currency": "USD" }
      }
    ]
  }'

• The order. An app or backend subscribed to Shopify’s orders/create webhook receives each new order, whether or not the Thank you page loaded.
• The ID. Use exactly the string the pixel sent as event_id, so OpenAI keeps one copy.
• oppref and obref. Capture them on the storefront, from the landing page’s address and OpenAI’s cookies, and carry them through to the order. Without them, OpenAI relies on hashed customer details and its own modelling.
• Testing. "validate_only": true checks a request without saving it. A batch holds up to 1,000 events, and one invalid event fails the whole batch.

Keep the key on the server. It never belongs in a custom pixel, where any visitor could read it.

How do you set it up with an app?

Install a tracking app that sends ChatGPT Ads checkouts and purchases from its servers, paste your Pixel ID and Conversions API key, and check the first sends before you trust the numbers.

cPixel, which we build, works this way. It sends checkout_started and order_created to OpenAI from its servers, rebuilding each purchase from Shopify’s order, and sends page_viewed, contents_viewed and items_added from your storefront through its app embed, cPixel tracking. A storefront event goes from its servers instead only when it never left the shopper’s browser, for example because OpenAI’s tag was blocked, so each event has one sender. Server sends carry hashed email, phone, customer and device IDs, oppref and obref, and the shopper’s IP address and user agent. OpenAI receives no payment-info event from it.

In cPixel, go to Destinations, click Connect OpenAI Ads, paste the Pixel ID and Conversions API key, then run Test connection. For OpenAI, the test confirms your credentials reach the account rather than sending a test event, so start a session in Live, place a real order (cPixel skips test orders by default) and watch OpenAI’s reply to the purchase. The full walkthrough: connect OpenAI Ads to cPixel.

If OpenAI’s own app already sends to that pixel ID, leave the pixel to one of them: one sender per pixel. More about cPixel, which sends Shopify purchases to seven ad platforms.

How do you check OpenAI received your conversions?

Watch events arrive in Ads Manager as you test, then allow 24 to 48 hours for attributed conversions to reach your reports.

• In the browser. With debug: true, OpenAI’s SDK logs its activity to the console; for a custom pixel, pick the pixel’s frame in the console, as Shopify’s testing guide describes. Shopify’s Pixel Helper shows whether your subscriptions fire. To see OpenAI’s requests next to your other pixels, check every pixel on the page.
• In Ads Manager. Tools → Conversions → Event Stream lists the latest events your data source received. OpenAI’s recent-events endpoint returns a sample from roughly the last 15 minutes and labels browser events pixel_sdk and server events server_to_server (conversion tracking).
• In reports. An event can be accepted and still count 0 if it doesn’t match the conversion event set on the campaign, and fixing the setting doesn’t recount earlier traffic (Measure Results).
• Event quality. Ads Manager scores each data source daily over seven days and lists warnings such as missing click information or delayed server events. OpenAI says the score doesn’t predict campaign results (event quality).

Why don’t ChatGPT Ads conversions match GA4 or Shopify?

Because they count different things: Ads Manager credits purchases to ChatGPT ad clicks, and optionally views, inside its attribution windows and dates them by the ad interaction, while Shopify counts every order on the day it was placed.

• Windows. Ads Manager credits conversions within 7, 14 or 30 days of a click, plus an optional one-day view-through window, using last-touch attribution (Measure Results).
• Dates. By default a conversion sits on the day of the click or impression. Add the Conversions (by conv. time) column to line it up with Shopify.
• Modelling. Totals can include modelled conversions where OpenAI offers them (conversion measurement).
• Refunds. OpenAI’s event list has no refund or cancellation event, so a cancelled order stays in Ads Manager’s revenue.
• Signals. Declined consent, blocked scripts and cleared cookies remove the click reference and other matching details.
• GA4. GA4 counts sessions, which depend on the page loading, consent, blocking and UTM handling, so they won’t equal ad clicks. Ads Manager can append landing page query parameters with macros such as {campaign_id}: add UTMs if you want GA4 to name the campaign.

OpenAI’s own view is that “a difference does not necessarily indicate an error” (conversion measurement).

What about consent in Europe?

Let Shopify’s consent settings gate OpenAI’s pixel, and send no server event for a shopper who declined. ChatGPT Ads reached 31 European markets in August 2026, with self-service from 31 August (OpenAI), and OpenAI asks advertisers to obtain consent wherever the law requires it (conversion measurement).

• In a custom pixel, Shopify runs your code only when the shopper has given the permissions it requires, in markets where your store asks for consent, usually the EEA and the UK (pixels overview). A third-party cookie banner must pass choices to Shopify’s Customer Privacy API, or the pixel won’t fire even after consent.

• Outside Customer events, for example in theme code, OpenAI’s pixel has its own switch. Events blocked while consent is false aren’t replayed:

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

• On the server, follow the same choice: OpenAI says to stop sending the obref browser reference once a shopper revokes consent (Conversions API).

This guide isn’t legal advice. Ask a lawyer what your markets require.

Frequently asked questions

Is there a Shopify sales channel for ChatGPT Ads?

OpenAI’s own ChatGPT Ads app, launched on 3 September 2026, is the nearest thing: it syncs your catalogue to Ads Manager, runs campaigns from Shopify and connects OpenAI’s pixel. Merchants had asked for a channel in the Shopify Community since July 2026 (thread). For now the app serves US stores; OpenAI says it will follow ChatGPT Ads to its other markets.

Do I need both the pixel and the Conversions API?

No, but OpenAI recommends both, with the same event ID for the same conversion. It calls the Conversions API more reliable than the pixel alone, and when both send a purchase with one event ID it keeps a single copy. A server-only setup still needs a Pixel ID to name the data source. The wider trade-offs are in server-side tracking on Shopify.

Where can ChatGPT Ads run?

In more than 60 countries since 23 September 2026. Self-service Ads Manager depends on where the business that pays is based, and OpenAI’s availability page lists the countries. The milestones so far:

• 9 February 2026: ads tested in the US (OpenAI).
• 5 May 2026: a beta self-serve Ads Manager, with pixel and Conversions API measurement recently launched (OpenAI).
• 11 August 2026: launched in the UK, Mexico, Brazil, Japan and South Korea (OpenAI).
• 31 August 2026: self-service across 31 European markets, launched the week before (OpenAI).
• 23 September 2026: Indonesia, Malaysia, the Philippines, Singapore, Thailand, Vietnam and Taiwan (OpenAI).