The Conversions API (CAPI) is OpenAI's server-to-server method for sending ChatGPT Ads conversion events, such as purchases, leads, and sign-ups, directly from your backend to OpenAI instead of from a visitor's browser. It is not a replacement for the measurement pixel; the pixel captures browser activity, while CAPI reports the conversions your backend confirms.
If you run ChatGPT Ads and rely on the pixel alone, ad blockers, privacy browsers, and cross-device journeys quietly drop conversions before OpenAI's optimization ever sees them. Send those same events server-side through CAPI and OpenAI's bidding gets cleaner signals, so your campaigns optimize toward real revenue instead of an undercounted fraction of it.
The Conversions API is a measurement integration that lets advertisers report ChatGPT Ads conversions from their own servers, CRM, or app instead of depending on a tag firing in the user's browser. It tells OpenAI what actually closed in your systems.
Each event carries a name like purchase, lead, or sign-up, a unique event ID, a timestamp, and hashed customer data such as an email or phone number that OpenAI uses to match the conversion to an ad interaction. Authentication runs through an API key tied to your Pixel ID, and OpenAI recommends sending the same event through both the pixel and CAPI with one shared event ID so duplicate reports collapse into a single conversion.
CAPI sits next to the measurement pixel and the oppref click parameter as the three pieces of ChatGPT Ads tracking, and its server-side design mirrors the conversion APIs advertisers already run on other ad platforms. AirOps shows how your brand appears across ChatGPT answers, so paid conversion data from CAPI and organic AI visibility sit side by side.
For a walkthrough of pixel and CAPI setup before you scale spend, see how to track ChatGPT Ads conversions with the pixel, CAPI, and a holdout.
CAPI runs as a server-to-server pipeline that fires after a conversion happens in one of your systems. Here is the sequence each event follows.
Capture the click. When someone clicks your ChatGPT ad, OpenAI appends an oppref attribution token to the landing page URL; store it with the user's session so you can attach it to later conversions.
Detect the conversion. Your backend, CRM, or e-commerce platform confirms a qualifying action, such as a completed purchase or a qualified lead.
Build the event. Assemble the payload: event name, unique event ID, timestamp, the stored oppref value, and hashed customer identifiers like email and phone.
Send the batch. Your server makes an authenticated POST to OpenAI's events endpoint using your Pixel ID and API key; OpenAI accepts up to 1,000 events per batch.
Deduplicate and attribute. OpenAI matches the event to an ad interaction and, when the pixel reported the same event ID, collapses the pair into one conversion.
The result tells you which campaigns drove confirmed conversions and feeds OpenAI's bidding. It does not reveal which conversation your ad appeared in or any individual user's identity.
Whether ChatGPT Ads earns a place in your paid mix depends on whether you can prove it drives revenue, and that proof lives in your conversion data. CAPI is what makes that data trustworthy enough to budget against, because it closes the gaps a browser-only setup leaves behind.
Recovered signal: Browser pixels miss events to ad blockers, privacy browsers, and short cookie lifetimes; server-side events fire regardless, so you stop underreporting conversions that actually happened and stop undervaluing the channel.
Smarter optimization: OpenAI's bidding learns from the conversions you report, so feeding it confirmed backend events like completed purchases steers spend toward real buyers and away from clicks that never convert.
Downstream truth: Lean on the pixel alone and a lead that closes in your CRM a week later never reaches OpenAI, so the system optimizes against an incomplete view of your pipeline, scales the wrong ad groups, and pauses the ones quietly driving revenue.
Growth marketers use the Conversions API to feed server-confirmed purchases into ChatGPT Ads so bidding optimizes toward revenue instead of landing-page views.
Demand gen leads use the Conversions API to send CRM-qualified leads back to OpenAI days after the click, capturing conversions the pixel never sees.
SEO managers use the Conversions API to reconcile ChatGPT Ads conversions with organic AI visibility, giving one view of paid and earned ChatGPT presence.
When the pixel and CAPI both report the same conversion, a shared event ID tells OpenAI to count it once, so running both sources together gives you fuller coverage without inflating your numbers or double-counting a single sale.
CAPI matches server events to ad clicks using customer identifiers like email and phone that are hashed with SHA-256 before they leave your systems, so OpenAI receives usable match keys while raw personal data stays on your servers.
The oppref value OpenAI adds to your landing page URL is the key that links a later backend conversion to the original ad click, so capturing it at click time and forwarding it with every event is what makes server-side attribution work at all.
Recover conversions that browser pixels lose to ad blockers, privacy browsers, and short cookie lifetimes.
Send batched conversion events to OpenAI's endpoint in a single authenticated call, so reporting scales with volume.
Attribute delayed and cross-device conversions by matching hashed identifiers after the click.
Improve the Event Quality Score OpenAI uses to rate your signals, which sharpens optimization.
Deduplicate pixel and server events with a shared event ID to keep reporting clean.
Run the pixel and CAPI together: send each conversion through both with a shared event ID so you get browser coverage and server reliability without double-counting.
Forward the oppref token: capture it on the landing page and store it with the session so backend conversions stay attributable to the original click.
Hash every identifier: normalize and SHA-256 email and phone before sending so match rates stay high and raw data never leaves your servers.
Send events close to real time: fire the server call as soon as the conversion is confirmed so OpenAI's bidding learns while the signal is fresh.
Validate before you scale: use the API's validate-only mode to confirm events parse correctly, then watch your Event Quality Score before raising budgets.
Map a holdout group: keep a slice of traffic unexposed so you can measure incremental lift instead of raw reported conversions.
Avoid treating CAPI as a drop-in substitute for the pixel. Teams that move everything to server-side lose same-session conversions that fire before any backend event exists, and their reported numbers quietly fall even when performance has not changed.
AirOps: tracks how your brand appears across ChatGPT and other AI answers, so you can read organic AI visibility alongside the paid conversions CAPI reports.
Google Tag Manager (server-side): routes conversion events from a server container to OpenAI's endpoint without custom backend code for every change.
Google Analytics 4: captures the oppref parameter and on-site conversions so you can reconcile ChatGPT Ads performance with your wider analytics.
Create your Pixel and API key. In the ChatGPT Ads dashboard, provision a Pixel ID and a Conversions API key. This takes minutes and needs no budget approval, so you can do it this week.
Install the measurement pixel. Add OpenAI's pixel to your site and map standard events like page view, purchase, and lead, so you have a browser baseline before layering server events on top.
Capture the oppref token. Update your landing pages to read the oppref parameter from the ad click URL and store it with the user's session or order record.
Build the server call. Have a developer assemble the event payload with hashed identifiers and the stored oppref, then POST it to OpenAI's events endpoint on each confirmed conversion.
Validate, then scale. Run events in validate-only mode, confirm they match pixel events by event ID, check your Event Quality Score, and expand coverage to more conversion types.
The Conversions API is OpenAI's server-to-server way to report ChatGPT Ads conversions straight from your backend, CRM, or app.
You send events with a name, a unique event ID, a timestamp, and hashed customer data to OpenAI's measurement endpoint.
OpenAI never shares individual conversations or user identities, so CAPI measures outcomes without ever exposing who converted.
Moving everything to server-side and dropping the pixel loses same-session conversions and quietly corrupts your reporting.
The biggest gains come from forwarding the oppref token and sending confirmed backend events that the browser pixel would otherwise miss.
They solve different halves of the same measurement problem, so the right setup runs both at once. The pixel is a browser tag that fires when a visitor loads a page or completes an action on your site, which makes it good at catching same-session, on-site conversions but vulnerable to ad blockers, privacy settings, and short cookie lifetimes. The Conversions API runs on your server, so it reports conversions the browser never sees: a sale confirmed in your backend, a lead your CRM qualifies days later, or a purchase on a device different from the one that clicked the ad. Because both can report the same conversion, you attach one shared event ID to the matching pair and OpenAI deduplicates them into a single count. Used alone, each source leaves a gap; used together, they give OpenAI a fuller and more resilient picture of what your ChatGPT Ads actually drove.
Send each event as soon as the conversion is confirmed, so near real-time is the target for most advertisers. When a purchase clears, a lead qualifies, or a sign-up completes, your server should fire the call within minutes, because fresher signals help OpenAI's bidding optimize while the ad interaction is still recent. If a real-time call is not practical, grouping works too: OpenAI accepts batched events, so you can collect conversions and send them on a short schedule, such as every few minutes or hourly. Avoid long delays of many hours or a full day, since late events can miss attribution windows and give the optimization system stale information. The volume you send depends on your own conversion rate; a high-traffic store may send continuously, while a B2B advertiser might send only a handful of qualified leads a day. Match the frequency to how often your conversions actually happen.
Your CAPI conversions and your own analytics rarely match exactly, and that gap is expected instead of a sign something broke. The two systems count different things. OpenAI attributes a conversion to a ChatGPT ad only when it can tie the event to an ad click through the oppref token or matched user data, within its attribution window. Your analytics platform counts every conversion from every channel, applies its own attribution model, and uses its own lookback window. Deduplication, hashing match rates, and events that fail to link to a click all shift the ChatGPT-attributed number. Timing adds more drift, because server events and browser events arrive at different moments. The practical move is to watch trends and relative changes in your CAPI data instead of expecting the absolute count to equal your analytics total. Treat each system as answering a different question, and reconcile the direction of change instead of demanding identical totals.
Yes, match rate is something you directly control, mostly through the quality and completeness of the customer data you send. OpenAI matches your server events to ad interactions using hashed identifiers, so the more reliable identifiers you include, such as email and phone number, the more events it can connect to a click. Normalize that data before hashing: lowercase emails, strip spaces, and format phone numbers consistently, because a formatting mismatch breaks the hash comparison. Always forward the oppref token captured at click time, since it gives OpenAI a direct link that does not depend on probabilistic matching. Send events promptly so they land inside the attribution window, and avoid sending thin payloads that strip out identifiers. Running the pixel alongside CAPI also helps, because browser-side data can fill fields your server lacks. Each of these is a setup decision you own, so your match rate climbs as your implementation gets more disciplined.
There is no single published number that counts as good, so treat Event Quality Score as a relative gauge you work to raise over time. OpenAI uses the score to rate how useful your conversion signals are for measurement and optimization, and it rewards events that arrive complete, well matched, and on time. A healthy score generally means you are sending rich customer data, forwarding the oppref token, hashing identifiers correctly, and firing events close to the conversion. If your score sits low, the usual causes are missing identifiers, formatting errors that hurt matching, or events that land outside the attribution window. The useful benchmark is your own trend: watch the score climb as you add data fields and tighten timing, and compare it across campaigns to spot weak implementations. Instead of chasing a universal target, aim for steady improvement and parity with your best-performing campaigns.