Items Added (items_added) is a standard ChatGPT Ads conversion event that fires when someone adds one or more products to a cart, bundle, or selection after clicking an OpenAI-served ad. It sits above the purchase event in the funnel, so it signals buying intent well before order_created confirms a completed sale.
If you run ChatGPT Ads for an ecommerce catalog, you decide whether to feed this mid-funnel signal into OpenAI's optimization or wait for purchases alone. Skip it and the oCPC algorithm learns slower on thin purchase data, so you pay more for every buyer while the model guesses at intent.
The items_added event records an add-to-cart action inside OpenAI's ChatGPT Ads measurement system, logged the moment a shopper places products into a cart or saved selection. OpenAI classifies it under the contents data shape, which means each event can carry the items, their quantities, and their monetary value. Marketers send it through two channels: the browser-based Measurement Pixel and the server-side Conversions API.
For the event to be useful, three things have to be true. The payload needs a contents type, an optional list of item objects with IDs and prices, and the oppref click identifier that ties the action back to a specific ChatGPT ad. Without that click reference, OpenAI cannot attribute the add-to-cart to your campaign, and the signal stops informing bids.
items_added belongs to the same family as contents_viewed, checkout_started, and order_created, each marking a deeper stage of purchase intent. It works as a leading indicator, since plenty of carts never convert. Treat it as directional evidence of interest, and wait for order_created before counting revenue. AirOps helps teams track how AI search surfaces drive these downstream actions, connecting ad-click behavior to the broader visibility picture.
Resources: How to set up ChatGPT Ads conversion tracking with the pixel and Conversions API
items_added moves from a shopper's click to your reporting dashboard in a fixed sequence. Each step hands structured data to the next, and a break anywhere quietly drops the event.
Capture click. The Measurement Pixel reads the oppref token from the landing URL and stores it after a shopper clicks your ChatGPT ad.
Detect add. When the shopper adds a product, your code builds a contents payload with item IDs, quantities, and prices.
Send event. The pixel or the server-side Conversions API posts the items_added event to OpenAI with the oppref value and a shared event ID.
Match and dedupe. OpenAI ties the event to the originating ad click through oppref and collapses duplicate pixel and server copies using the shared ID.
Feed optimization. The confirmed event flows into reporting and, if you select it, into oCPC bidding so the model targets likely buyers.
The reported count tells you how many ad-driven sessions reached the add-to-cart stage. It does not tell you how many of those carts became paid orders, which only order_created confirms.
Whether to track items_added comes down to one question: how fast do you want OpenAI's bidding to find your buyers? ChatGPT Ads is a young channel with sparse conversion history, so every reliable mid-funnel signal shortens the learning curve and lowers what you pay to acquire a customer. Ignore it and you hand the model less to learn from, which usually shows up as a higher cost per purchase.
Faster optimization: Add-to-cart events give the oCPC model far more data points than purchases alone, so it reaches stable targeting sooner on low-volume catalogs.
Funnel visibility: Tracking items_added shows where shoppers drop between interest and checkout, pinpointing whether your problem is traffic quality or cart friction.
Attribution failure mode: If you fire the event without the oppref token, OpenAI counts the add-to-cart but cannot credit your campaign, so your reporting understates performance and you cut spend on ads that were actually working.
SEO managers use items_added to see whether ChatGPT ad traffic behaves like their organic shoppers or bounces before the cart stage.
Growth marketers use items_added as an early optimization signal so oCPC bidding ramps before purchase volume is statistically reliable.
Content strategists use items_added to learn which product pages turn ChatGPT-referred readers into active shoppers worth writing more content for.
The contents shape is OpenAI's event template for commerce actions, and it lets items_added carry an array of individual products with their IDs, quantities, and per-unit prices alongside an event-level monetary total for the whole cart.
oppref is the click identifier OpenAI appends to ad destination URLs, and it is the single value that lets an items_added event be credited back to the exact ChatGPT ad that drove the visit, which is why losing it breaks attribution.
Because the same add-to-cart can fire from both the browser pixel and the server-side Conversions API, a shared event ID tells OpenAI to count the matched pair once instead of inflating your add-to-cart numbers with duplicates.
Sharpen oCPC bidding by giving OpenAI a high-frequency signal that arrives long before purchases do.
Spot cart abandonment by comparing items_added volume against order_created on the same campaign.
Send events reliably in server batches of up to 1,000 through OpenAI's Conversions API, surviving ad blockers that break browser pixels.
Attribute add-to-carts to ChatGPT specifically, separating this channel's intent from Google and Meta traffic.
Reuse your existing add-to-cart tracking, since GA4's add_to_cart event captures the same action that items_added records.
Fire items_added from both the pixel and the Conversions API with a shared event ID, because the server copy survives when a browser blocks the pixel.
Capture oppref on the landing page and store it, so a cart action minutes later still ties back to the ad click.
Send item-level IDs, quantities, and prices in the contents array, since richer payloads let OpenAI weigh value instead of raw counts.
Send every amount as an integer in the currency's standard minor unit, because that is the format OpenAI's Conversions API requires.
Validate events in the Ads Manager Event Stream before trusting the data, so you catch missing fields while they are cheap to fix.
Optimize campaigns toward order_created once purchase volume is sufficient, so bids chase confirmed buyers after the model has enough sales to learn from.
Avoid treating every add-to-cart as a near-sale. Many carts never check out, so optimizing bids directly on items_added teaches the model to chase browsers who load up carts and leave, inflating your cost per real purchase.
AirOps: Connects your ChatGPT Ads performance to the wider AI search picture, so you can see how items_added activity relates to the visibility that drives those clicks.
Google Analytics 4: Captures the add_to_cart event that records the same add-to-cart action as items_added, giving you a tag you can forward to OpenAI.
Google Tag Manager: Deploys the Measurement Pixel and server-side Conversions API, routing items_added events with the right oppref and event ID.
Map your events. List the add-to-cart action in your store and confirm it already fires a GA4 add_to_cart or dataLayer event. You can do this today in your tag manager with no spend.
Create the pixel. In OpenAI Ads Manager, open the Conversions tab and generate a web conversion source to get your Pixel ID and a Conversions API key, which you will need for server-side sending.
Capture oppref. Add logic to read the oppref token from the landing URL and persist it, so later cart actions keep the attribution link.
Send items_added. Wire your add-to-cart trigger to post the items_added event through the pixel and the Conversions API, passing the contents payload and a shared event ID.
Verify and optimize. Watch the Event Stream to confirm events arrive clean, then decide whether to optimize toward items_added or hold for order_created once purchases scale.
items_added is the ChatGPT Ads event that records when a shopper adds products to a cart after clicking an OpenAI-served ad.
It is sent through the Measurement Pixel, the Conversions API, or both, using the contents data shape.
Accurate attribution depends entirely on capturing the oppref click token and passing it with every event.
The biggest risk is optimizing bids on add-to-carts that never convert, which raises your true cost per purchase.
The leverage is speed: mid-funnel signals let ChatGPT Ads bidding learn faster when purchase data is still thin.
items_added fires when a shopper puts products into a cart, while order_created fires only when they complete a purchase. The practical gap matters because carts are far more common than checkouts, so items_added gives you volume and early intent, while order_created gives you confirmed revenue. Most advertisers track both: the add-to-cart event feeds OpenAI's bidding model while purchase history is still thin, and the purchase event becomes the optimization target once enough sales accumulate. Using the two together also lets you measure cart-to-order drop-off on the exact traffic a ChatGPT campaign sends. Treat items_added as a signal of interest and order_created as the outcome you are ultimately paying for. If you can only implement one event first, start with order_created, since OpenAI's oCPC optimization needs purchase data most, then layer items_added in afterward for upper-funnel insight.
Send an items_added event every time a shopper actually adds a product, in real time, and avoid holding them in a schedule that delays the signal. Real-time sending matters because OpenAI's bidding reacts faster when the data arrives close to the action. If you send server-side through the Conversions API, you can still group events into batches, which helps high-traffic stores stay within rate limits. Keep each shopper action as its own event with its own event ID so deduplication works and you do not merge separate carts. Avoid firing duplicate events for a single add from both the pixel and the server without a shared ID, because that inflates your counts. The rule of thumb is one event per genuine add-to-cart, sent promptly, with item details attached whenever your store can provide them.
The two numbers rarely match because they count different things under different rules. GA4 records every add_to_cart from any traffic source and keeps events that OpenAI may discard, while ChatGPT Ads only credits an items_added event it can tie to an ad click through oppref. Deduplication is another cause: when the same add fires from both the pixel and the Conversions API, OpenAI collapses the pair into one, but a misconfigured GA4 setup might log both. Consent and ad-blocking also hit the browser pixel harder than server events, so pixel-only setups undercount. Timing windows differ too, since the platforms attribute and report on different schedules. Instead of chasing an exact match, confirm each event carries oppref and a shared ID, then track the trend over the absolute gap. A persistent, stable difference is normal; a sudden swing is the signal worth investigating.
You can influence the count in two separate ways, and it helps to keep them apart. The first is real: better product pages, clearer pricing, faster carts, and stronger ChatGPT ad targeting all genuinely increase how many shoppers add items, so the event rises because real behavior changed. The second is purely technical: fixing a dropped oppref token, adding server-side sending, or correcting a broken trigger makes you capture adds you were already earning but failing to record. Both move the number, but only the first reflects more actual demand. Before you celebrate a jump, check whether you changed the funnel or just the tracking. The honest answer is that most early gains come from closing measurement leaks, and the durable gains come later from improving the offer and the landing experience. Audit your implementation first so you can trust that later movement reflects real shoppers instead of a tracking artifact.
There is no universal benchmark, because add-to-cart to purchase rates swing widely by product category, price point, and audience. As a rough orientation, many ecommerce stores see a large majority of carts abandoned, so a cart-to-order rate in the double digits is often healthy, and very high rates can actually signal that you are undercounting add-to-carts. The more useful benchmark is your own baseline: measure your items_added to order_created ratio for a few weeks, then watch how it moves as you change ads, pages, and pricing. Compare ChatGPT Ads traffic against your other paid channels on the same ratio to judge whether this audience shops differently. Segment by device and new versus returning buyers, since blended averages hide the real story. Set your target relative to your category and your own trend, and treat a stable, improving ratio as the real win instead of a number borrowed from someone else's store.