Contents Viewed (contents_viewed) is a standard ChatGPT Ads conversion event that fires when a visitor views a specific product or content item after clicking an OpenAI ad. It differs from page_viewed, which marks a general page load; contents_viewed marks interest in one specific item, even when that view happens after the page has loaded.
If you advertise on ChatGPT, this event is how you tell OpenAI which product views your campaigns drove, so the system can optimize bidding toward people who browse what you sell. Skip it, and you report only purchases and clicks, leaving mid-funnel interest invisible and starving OpenAI's optimization of the signal it needs to find buyers.
The contents_viewed event records a mid-funnel action: a shopper examining an individual item on your site after arriving from a ChatGPT ad. OpenAI classifies it as a standard conversion event, which means it belongs to a taxonomy OpenAI already understands, so you need no custom event name. You attach it to the moment a product or article is viewed.
Every contents_viewed call carries the contents data shape. That payload accepts a contents array where each item carries an id, a name, and a content_type such as product or page. You send it two ways: through the browser-based Measurement Pixel using an oaiq("measure", ...) call, or server-side through the Conversions API. Both paths share the same event name and data shape, which is what lets OpenAI match and deduplicate them.
Within the ChatGPT Ads event taxonomy, contents_viewed sits between page_viewed, which marks any important page load, and items_added or order_created, which mark deeper commerce intent. It signals consideration. The purchase itself shows up in order_created. AirOps AI Ads shows which prompts surface your ads in the first place, connecting the views this event captures to the conversations that drove them.
Resources: See how to set up conversion tracking and measurement for ChatGPT ads
The contents_viewed event moves from a browser action to a line in your ChatGPT Ads report through a fixed sequence. Here is how one product view becomes attributed data.
Install the pixel: Add the oaiq snippet to your site's head and initialize it with your Pixel ID from Ads Manager.
Fire the event: When a visitor opens a product or content page, send a contents_viewed call with a payload describing the item.
Attach identifiers: The pixel captures the oppref identifier from the landing page URL and stores it in a first-party cookie so later views reuse it.
Match and deduplicate: OpenAI matches the event to a click or impression, and if you also send it server-side, removes duplicates using your Pixel ID, event name, and event_id.
Report the conversion: Ads Manager credits the view under your configured click window, with any view-through counted separately within one day.
The result tells you how many ad-driven sessions reached a real product view and which campaigns produced them. It does not tell you who those people are, because OpenAI returns aggregated reporting and never shares individual identities or chats.
Whether ChatGPT Ads earns a place in your budget depends on proving it drives more than clicks. Contents Viewed is the first event that shows real interest, and it feeds the optimization that decides who sees your ads next. It is a reporting detail that carries real weight on performance.
Optimization needs the signal: OpenAI's bidding learns from the events you send, so without contents_viewed it optimizes toward clicks and purchases while ignoring the browsing behavior in between. That gap compounds the longer a campaign runs.
Mid-funnel visibility: If you track only order_created, a long consideration cycle looks like failure, and you may cut a campaign that was quietly driving product views that convert weeks later.
Cross-channel comparison: Because it maps cleanly to a product-view event in your analytics, you can compare ChatGPT ad interest against the same action from search or social on equal terms.
SEO managers use Contents Viewed to compare how often ChatGPT ad clicks reach a product page against the same views earned through organic AI answers.
Growth marketers use Contents Viewed to give OpenAI's bidding a mid-funnel signal so campaigns optimize toward people who browse and research before buying.
Demand gen leads use Contents Viewed to spot which ad-driven product views later turn into pipeline, informing where they raise or cut ChatGPT ad spend.
The payload format that contents_viewed requires, carrying a contents array in which each item can describe what was viewed through an id, a human-readable name, and a content_type such as product, page, or article, plus an optional quantity or amount.
The fixed set of event names OpenAI already recognizes, which is why contents_viewed needs no custom definition, fires with a predictable data shape, and reports consistently across every advertiser using the ChatGPT Ads platform, with no setup beyond sending it.
The rule that keeps a single view sent from both the browser pixel and the server-side Conversions API from being counted twice, matched on the combination of your Pixel ID, the event name, and a shared event_id you generate yourself.
Signals mid-funnel intent that raw clicks and impressions miss.
Feeds OpenAI's bidding the data it needs to optimize ChatGPT Ads toward likely buyers.
Maps directly to GA4 product-view events like view_item, so your analytics and ad data line up.
Works through both the Measurement Pixel and the Conversions API for resilient coverage.
Captures views that fire after the page loads, including interactions beyond the initial load.
Reports alongside click-through conversions while keeping view-through counts separate and clear.
Fire contents_viewed only on genuine item views, so the signal reflects real interest instead of incidental page loads.
Send a populated contents array with id, name, and content_type, because richer item data sharpens matching and reporting.
Use a shared event_id when you send the same view through the pixel and the Conversions API, so OpenAI can deduplicate it.
Run the pixel and Conversions API together, because the server path covers ad-blocked and cookie-restricted sessions the browser misses.
Place the pixel snippet near the top of your head, so early views are captured before the rest of the page loads.
Set amount and currency only when an item view has a real monetary value, so your reporting stays honest.
Avoid firing contents_viewed on every page as a substitute for page_viewed. Overloading the event floods your reports with low-intent views, muddies OpenAI's optimization, and makes genuine product interest harder to read.
AirOps: Shows where your ChatGPT ads and competitors' ads appear across the prompts you track, connecting the product views contents_viewed captures to the conversations that triggered them.
Google Tag Manager: Deploys the oaiq pixel and fires contents_viewed on product and content pages without hard-coding each call into your site.
Google Analytics 4: Mirrors the same product-view behavior through events like view_item, giving you a cross-channel baseline to compare against ChatGPT ad data.
Map your key views: List the product, listing, or content pages where a view signals real interest. You can do this today from your existing site map, with no budget or approvals.
Install the Measurement Pixel: Add the oaiq snippet to your site's head using your Pixel ID from Ads Manager, placing it near the top so early views are not lost.
Add the event call: Fire contents_viewed on each mapped page with a contents payload that names the item through id, name, and content_type.
Mirror it server-side: Send the same event through the Conversions API with a shared event_id, so ad-blocked and cookie-limited views still count and duplicates are removed.
Verify and read reports: Use the Event Stream and debug mode to confirm events arrive with the right data, then check contents_viewed in Ads Manager against your own analytics before you trust it.
Contents Viewed (contents_viewed) is a standard ChatGPT Ads event that marks when someone views a specific product or content item on your site.
It is measured through the Measurement Pixel or the Conversions API, both sending the same contents data shape.
Aggregated reporting is the main constraint: OpenAI shares counts and trends, never individual users or chats.
The main risk is overfiring it on routine page loads, which floods reports and weakens optimization.
The leverage is mid-funnel signal: feeding product-view data lets OpenAI's bidding find browsers who later become buyers.
Contents Viewed (contents_viewed) marks a view of one specific item, while page_viewed marks landing on an important page. OpenAI draws the line clearly: use page_viewed for page loads and contents_viewed when a visitor views a specific product or content item, including interactions that happen after the page has finished loading. In practice, a shopper landing on your category page triggers page_viewed; opening an individual product triggers contents_viewed. Both use the same contents data shape, so the payload looks similar, but the event name is what tells OpenAI how much intent the action carries. Choosing the right one matters because the event name feeds optimization and reporting. If you label every product view as page_viewed, you lose the mid-funnel signal; if you label every page as contents_viewed, you inflate it. Map each page type to one event and keep that mapping consistent across your pixel and server-side calls.
Fire Contents Viewed (contents_viewed) once for each distinct item a visitor meaningfully views, and skip repeated firings for the same view. There is no fixed cap, but the useful rule is one event per genuine product or content view. A visitor who opens three different products in one session can reasonably generate three contents_viewed events. The same product viewed repeatedly in quick succession should fire once, because duplicate firing inflates your counts and distorts optimization. If you are migrating from an analytics setup, map it to the moment you already track as a product detail view, such as view_item in GA4, so your firing logic stays consistent. Avoid firing it on list or category pages where no single item is in focus; those are closer to page_viewed. The goal is one clean signal per real act of interest, which keeps your reports readable and your bidding well-fed.
Your Contents Viewed (contents_viewed) counts differ from your analytics because the two systems measure and attribute differently. OpenAI only counts views it can attribute to an ad click or eligible impression within your configured windows, while your analytics counts every product view from every source. Ad blockers, consent choices, and cookie restrictions stop some browser events from reaching OpenAI, which the Conversions API partially offsets by sending events server-side. OpenAI also notes platform totals can include modeled conversions, so they will not reconcile line for line with your raw analytics. Deduplication adds another gap: when the pixel and the Conversions API both fire, matched events collapse into one. None of this means either number is wrong; they answer different questions. Pick one source as your decision-making baseline, document the windows and filters behind it, and expect a steady gap between the two instead of an exact match.
You can influence how Contents Viewed (contents_viewed) is attributed, but only indirectly through your setup; you cannot edit the attribution itself. OpenAI controls the matching logic and the attribution windows available to you, and the click always takes precedence over a view when both are eligible. What you control is the quality of the signal you send: fire the event accurately, include a well-formed contents payload, pass hashed user data for better matching, and reuse a shared event_id across the pixel and the Conversions API. You also choose the click window during campaign setup, and whether to run server-side measurement to recover events the browser misses. You cannot move a view from view-through to click-through, change the fixed one-day view-through window, or force a match OpenAI's system does not make. Focus on clean, consistent implementation; that is the lever that moves how many of your real product views actually get credited.
There is no universal good rate for Contents Viewed (contents_viewed), because it depends on your funnel, your offer, and how you define a qualifying view. A useful benchmark is internal and relative: measure the share of ad clicks that go on to trigger a contents_viewed event, then track whether that share rises as you refine targeting and landing pages. For a considered B2B purchase, a smaller fraction reaching a product view can still be healthy; for ecommerce, you should expect a larger share of clicks to reach an item view. Compare the same metric across campaigns and against the equivalent product-view rate from your other channels to judge whether ChatGPT ad traffic behaves similarly. Watch the trend over several weeks instead of a single day, since early data is noisy. The strongest sign of a good rate is a steady or rising view-to-consideration ratio alongside downstream events like items_added and order_created.