On 6 August 2026 we added ChatGPT Ads conversion tracking to the Advanced Tracking Academy checkout. It went onto the same server-side Google Tag Manager setup that sends our Stripe subscriptions to Meta, on the live site, before any client had asked for it.

When we built it, no campaign could run on the account: the first billing card failed OpenAI’s check with “couldn’t verify this card for Ads billing”, and ads do not serve until billing clears. So these notes cover what can be proven without spend: that the tags fire, that OpenAI accepts the payload, and that the click reference reaches the webhook. They do not claim an attributed conversion. The platform rules themselves live in the conversion tracking guide.

Two Stape templates, two settings to check

We did not hand-roll tags. Stape publishes OpenAI Ads Pixel for the web container and OpenAI Ads Conversions API for the server container, both Apache 2.0.

The web template maps GA4-style names onto OpenAI’s, so page_view becomes page_viewed and purchase becomes order_created. Anything unmapped goes out as a custom event. It takes an event ID for deduplication and can follow Google Consent Mode.

The server template takes the Pixel ID and the Conversions API key, inherits GA4 event names, hashes user data, skips values that are already hashed, and resolves the click reference from URL, cookie or event data in a fixed order.

Two things in the server template deserve a look before you publish:

  • The version you install. The copy we installed on 6 August lowercased every value before hashing, external IDs included, and did not send phone hashes. OpenAI’s rules are now that external IDs keep their case and phone hashes are accepted. The repository’s current version (updated 2026-10-14, checked 2026-10-17) maps phone to phone_numbers_sha256 and trims external IDs without lowercasing them. Update from the gallery if your copy is from the summer.
  • Which amount field you fill. The template has an amount “in the currency’s lowest unit” and one “in the currency’s regular unit”, and the first wins if both are set. Stripe’s amount_total is already in minor units; a GA4 value is not. Map one or the other, so nothing gets multiplied by 100 twice.

Our configuration

Web container, three tags, all sharing our existing unique event ID variable with the Meta pixel tags:

Tag OpenAI event Fires on
01 page_viewed consent update
02 lead_created form submission
03 checkout_started begin_checkout

There is deliberately no browser order_created. OpenAI keeps the first event it receives for a matching Pixel ID, event name and ID, so a thank-you-page purchase would beat the Stripe webhook and the verified copy would be dropped as the duplicate. Purchases come only from the server.

Server container, two tags:

  • All events forwards the GA4 stream, with event names inherited. It runs only when ad_storage consent is granted.
  • Conversions fires on our Stripe webhook events. It reads oppref, obref, the hashed email, our own index ID as the external ID, IP and user agent from the Stape Store, not from the request, because the webhook request carries none of them.

The webhook trigger also covers refund and cancel_subscription. With inherited names, the template sends those as custom events. That gives us a record; it does not reverse anything on OpenAI’s side, because there is no refund event to send.

The join between click and webhook

Our conversions happen when Stripe tells our server a payment settled. The Stripe conversion tracking guide explains why we count there and not on a thank-you page. A webhook has no cookies and no URL, so at the moment we most want to name the ad, we know the least about the visitor.

The answer was already in the stack. A Stape Store collection called index holds one document per visitor, and it is how Meta’s _fbc and _fbp survive to our Meta conversions tag. We added three fields to the two writers that fill it at lead and checkout time:

oppref      <- __oppref cookie
oppref_url  <- oppref read from the page URL
obref       <- __obref cookie

Empty values are skipped, so those writers stayed harmless until the pixel existed. A third writer, which re-keys the document when Stripe assigns a customer ID, carries oppref and obref forward next to _fbc and _fbp. When the webhook arrives, two Store lookups read them back and the conversions tag sends oppref at event level and obref inside user.

Flow diagram: a click ID captured in the browser is written to a store, then read back when a payment webhook fires server-side and attached to the conversion.
The click ID has to outlive the browser session. A store keyed on an ID the webhook also carries makes that possible.

Adding a platform to a stack that already round-trips identifiers took three rows per writer. Building that round trip from nothing is the real work, and the first-party click ID index guide covers it.

Three limits shape the webhook leg:

  • Event age. timestamp_ms must be within the last 7 days. A webhook that retries for longer than that, or a backlog replayed after an outage, will be rejected.
  • Click window. OpenAI’s default click window is 30 days, and __oppref expires 30 days after the pixel last captured a value. A renewal months later will not be credited to the original click. Give each payment its own event ID, so a renewal is never mistaken for a retry.
  • Retries. A Stripe retry of the same payment should send the same event ID. OpenAI ignores later copies with a matching key, which makes the retry harmless.

Consent works differently on the two server tags. The all-events tag can check the visitor’s consent state on each request. The webhook tag cannot, since Stripe’s request has no browser behind it, so it relies on what the browser side was allowed to store. That only holds if your stored copy follows the visitor’s later choices. The pixel deletes its own cookies on a revocation; a Store document does not delete itself.

What each test proved

Our first idea was the Advertiser API’s conversion insights. It reports attributed conversions at campaign, ad group and ad level. With no campaign linked, it returned nothing, however many events had landed. That taught us to separate receipt from attribution.

Three checks did run without a campaign, and each proves one layer:

Browser transport. A scripted load of the live site with a test oppref on the URL. The pixel’s beacon left the browser and both __oppref and __obref were set. This proves the pixel loads and sends. It does not prove OpenAI stored anything, and a made-up oppref proves nothing about attribution.

Payload validation. A Conversions API request with validate_only: true returned {"accepted_events":1}. That shows the Pixel ID, the key and the schema agree. A validation call stores nothing.

Server tag execution. In GTM’s server Preview, the all-events tag fired. That proves the server container picks up the event and builds the request.

The missing piece is proof of receipt. OpenAI now documents a recent-events endpoint, GET /v1/conversions/events?pid=..., that samples the last 15 minutes and labels browser events pixel_sdk and server events server_to_server; its API reference says it works only on enabled accounts. We have not captured its output on our pixel yet.

If you script the browser check, set an ordinary Chrome user agent. On 6 October 2026 we found that Meta’s pixel sends nothing when the user agent contains HeadlessChrome and the dataset is real. We have not tested whether OpenAI’s pixel filters the same way, so do not read a silent headless run as a broken install.

Where the build stands

This page does not yet show an attributed conversion. That needs billing to clear and a small campaign, so a real click, its stored oppref and an attributed order_created can be shown together. So far we have observed browser transport, validated the server payload and seen the server tag execute. Stored-event receipt and attribution remain unverified.