OpenAI deploys ChatGPT Ads account managers: what AI search monetization means for e-commerce and WordPress

On 14 October 2026 Barry Schwartz reported in Search Engine Roundtable that OpenAI now assigns people, not just a dashboard, to advertisers on its ads platform. His summary: “OpenAI has humans who are reaching out to advertisers to help them manage their ChatGPT Ads.” The evidence was an email posted on X by Anthony Higman, titled “Introducing your ChatGPT Ads Account Manager”. It names a contact person, invites questions, proposes an introductory meeting and suggests a biweekly check-in to review performance and look for optimization opportunities.

This is not the launch of ChatGPT advertising. OpenAI published its advertising principles earlier in 2026, and its developer portal already documents a full advertiser stack: campaigns, product feeds, a Measurement Pixel and a server-side Conversions API. The account manager email is the sales layer arriving on top of a platform that already works.

For WooCommerce stores, the useful question is not whether conversational ads will matter in general. It is what the platform actually expects from a store: which product data, in which format, and how a purchase gets reported back. This guide sticks to what OpenAI documents and maps each requirement to WordPress and WooCommerce code.

#what the chatgpt ads account manager email offers advertisers

The email in the Search Engine Roundtable report is account management, not cold outreach to brands that have never advertised. It introduces a named manager, offers a first call and proposes recurring biweekly reviews of campaign results. Schwartz reads it as people who may help agencies run ads for their clients, and he labels that reading a guess.

Two details from OpenAI’s own documentation explain why a human contact matters even on a self-serve platform:

• Some capabilities are gated per account. The product feed guide lists “product feed API access for the account” as a prerequisite and says that if feed access is unavailable, the advertiser should contact the OpenAI account team.
• Several settings are permanent. The conversion tracking guide states that a campaign objective cannot be changed after creation, and that for a conversion-optimized campaign the selected conversion event cannot be changed either. Mistakes at setup cost a rebuilt campaign, so a review call before launch has real value.

The reaction on X was mixed. Higman joked about endless calls with reps from Google, Meta and ChatGPT Ads, and another user remarked that OpenAI uses AI for support but humans for sales. For a store owner the practical takeaway is simpler: if you get this email, the first call is the right moment to ask whether feed access and conversion optimization are enabled for your account.

#how ads appear inside chatgpt according to openai

OpenAI’s post Our approach to advertising and expanding access to ChatGPT sets the rules that every placement follows. Ads appear at the bottom of an answer when there is a relevant sponsored product or service based on the current conversation. They are labeled and visually separated from the organic answer.

The same post lists the commitments that shape what advertisers can and cannot buy:

• Answer independence. Ads do not influence the answers ChatGPT gives. A store cannot pay to be named inside the response text.
• Conversation privacy. Conversations are kept private from advertisers, and OpenAI states that it does not sell user data to them.
• User control. People can turn off ads personalization and clear the data used for ads.
• Excluded audiences and topics. Ads are not shown to accounts of users under 18 and do not appear near sensitive topics such as health, mental health or politics.
• Paid tiers. Higher paid plans stay ad-free; ads are aimed at the free and lower-priced tiers.

This removes a common misconception. Reports that sponsored products are woven into the model’s reasoning contradict what OpenAI describes: two separate systems, an organic answer and a labeled ad unit below it. Organic visibility and paid visibility are separate problems, and neither one buys the other.

#how chatgpt ads targeting works without keywords

The campaign targeting reference lists four levers, and none of them is a keyword list:

Context hints are the closest thing to keyword research, and the docs are explicit that they are not keywords. They describe what an ad group sells and for whom, so they work best when written like a short product brief rather than a list of search phrases.

The difference between including an audience and applying a bid multiplier matters for stores with a customer list. Including an audience restricts delivery to matching users. A bid multiplier raises the bid for matching users while everyone else stays eligible. A store that uploads past customers as an inclusion audience stops reaching new customers entirely; uploading the same list as a multiplier does not.

#chatgpt ads bidding options and campaign objectives

The bidding and budgets guide separates three settings that Google Ads users tend to treat as one: the campaign objective (what to optimize for), the billing event (what you pay for) and the bid strategy (who sets the bid).

Conversion campaigns optimize for a purchase or lead but still bill for valid clicks. The two “maximize” strategies require a daily budget and no maximum bid. Audience bid multipliers only work with fixed bids.

Money is expressed in three different units across the platform, and mixing them up is the most likely integration bug:

• Budgets and bids use micros: one million micros equals one unit of the account currency. A bid of 2.50 is sent as 2500000.
• Impression bids are per impression, so a CPM figure is divided by 1,000 before conversion to micros.
• Conversion event amounts and Delta API prices use integer minor units: 8900 means 89.00 in a currency with cents.
• CSV feed prices use major units with a currency code, such as 79.99 EUR.

Conversion optimization needs exactly one active standard conversion event, such as order_created. Custom events can be measured but cannot be an optimization goal. Because the objective and the selected event are fixed at creation, the conversion tracking work described below has to be finished before the first conversion campaign is created.

#how to build a chatgpt ads product feed from woocommerce

Shopping ads in ChatGPT are built from a product feed. The product feeds guide describes the flow: create a feed through the Advertiser API, configure SFTP access with a password or SSH key, then upload a UTF-8 CSV with one row per product or variant. Files go directly into the SFTP root, without subfolders, and each product should appear once across all files.

The field definitions live in OpenAI’s product file schema, which is shared with organic product discovery in ChatGPT. Nine base fields are required, and each maps cleanly to WooCommerce data:

Variable products need three extra fields on every variation row: a shared group_id (the parent product ID works), listing_has_variations set to true, and a variant_dict such as {"color":"Black","size":"10"} built from the variation attributes. The group ID must differ from each item ID.

Identifiers deserve attention. Since WooCommerce 9.1, products expose get_global_unique_id(), the field shown in the admin as GTIN, UPC, EAN or ISBN. The schema accepts one GTIN of exactly 8, 12, 13 or 14 digits with a valid check digit, and tells merchants to omit the field rather than invent a value. A manufacturer part number (mpn) with a brand is the fallback.

Two flags decide where a product can appear. is_ads_eligible must be true for products the ads system should process; when omitted, ads processing is off unless a feed-level default exists. is_eligible_search controls organic discovery and is independent of ads eligibility.

A common assumption in the WordPress world is that an existing Google Shopping XML feed from a plugin can be reused. The schema’s Google-compatible path accepts tab- or comma-delimited text files with Google column names, and only after OpenAI confirms that format for the registered feed. JSON, spreadsheets, XML, RSS and Atom are not supported on that path. Most stores will need a dedicated CSV export.

/**
 * Writes a ChatGPT Ads product CSV for simple products and variations.
 * Field names follow developers.openai.com/commerce/specs/file-upload/products.
 */
function wppoland_write_chatgpt_feed( string $path ): void {
    $fh = fopen( $path, 'w' );
    fputcsv( $fh, [ 'item_id', 'group_id', 'listing_has_variations', 'variant_dict',
        'title', 'description', 'url', 'brand', 'seller_name', 'image_url',
        'price', 'availability', 'gtin', 'is_ads_eligible' ] );

    $map = [ 'instock' => 'in_stock', 'outofstock' => 'out_of_stock', 'onbackorder' => 'backorder' ];
    $ids = wc_get_products( [ 'status' => 'publish', 'limit' => -1, 'return' => 'ids',
        'type' => [ 'simple', 'variation' ] ] );

    foreach ( $ids as $id ) {
        $p      = wc_get_product( $id );
        $parent = $p->get_parent_id() ? wc_get_product( $p->get_parent_id() ) : null;
        $image  = wp_get_attachment_image_url( $p->get_image_id() ?: ( $parent ? $parent->get_image_id() : 0 ), 'full' );
        if ( ! $image || '' === $p->get_regular_price() ) {
            continue; // Required fields missing: skip instead of sending placeholders.
        }
        $variant = $parent ? wp_json_encode( array_map( 'strval', $p->get_attributes() ) ) : '';

        fputcsv( $fh, [
            $p->get_sku() ?: (string) $id,
            $parent ? 'group-' . $parent->get_id() : '',
            $parent ? 'true' : '',
            $variant,
            $p->get_name(),
            wp_strip_all_tags( $p->get_description() ?: ( $parent ? $parent->get_description() : '' ) ),
            $p->get_permalink(),
            get_bloginfo( 'name' ), // Replace with a real brand attribute where products have one.
            get_bloginfo( 'name' ),
            $image,
            wc_format_decimal( $p->get_regular_price(), 2 ) . ' ' . get_woocommerce_currency(),
            $map[ $p->get_stock_status() ] ?? 'unknown',
            $p->get_global_unique_id(),
            'true',
        ] );
    }
    fclose( $fh );
}

The upload itself runs over SFTP, so a cron job or a WP-CLI command that writes the file and pushes it with the server’s SFTP client is enough. After each upload, the upload history endpoint reports a status (completed, completed_with_errors, failed and others) plus accepted and rejected row counts with diagnostic codes such as missing_required_column or invalid_value. OpenAI notes that a completed upload does not mean every product can serve.

#keeping prices and stock current with the delta api

The feed guide splits updates by type. Changes to the title, price or availability of an existing item go through the Delta API, a PATCH request that sends only the changed fields. New products and changes to other fields, such as images or descriptions, require a fresh catalog upload over SFTP.

The stock rule is direct: an item marked out_of_stock stops qualifying for delivery once the change propagates, and becomes eligible again after it is set back to in_stock. The docs also warn that sale and availability dates in the feed do not schedule anything, so a price change has to be sent when it happens.

In WooCommerce, the natural trigger points are the stock hooks for products and variations. The request needs the Advertiser API key, which must stay on the server, next to the other secrets reviewed in a WordPress security audit. For stores where an ERP owns stock and prices, the same call belongs in the WooCommerce ERP integration layer, not in a theme.

/**
 * Pushes a stock change to the ChatGPT Ads Delta API.
 * Endpoint and payload shape: developers.openai.com/ads/product-feeds
 */
function wppoland_push_chatgpt_stock( WC_Product $product ): void {
    if ( ! defined( 'OPENAI_ADS_API_KEY' ) || ! defined( 'OPENAI_ADS_FEED_ID' ) ) {
        return;
    }
    $item_id  = $product->get_sku() ?: (string) $product->get_id();
    $group_id = $product->get_parent_id() ? 'group-' . $product->get_parent_id() : $item_id;

    wp_remote_request( 'https://api.ads.openai.com/v1/feeds/' . OPENAI_ADS_FEED_ID . '/products', [
        'method'  => 'PATCH',
        'timeout' => 10,
        'headers' => [
            'Authorization' => 'Bearer ' . OPENAI_ADS_API_KEY,
            'Content-Type'  => 'application/json',
        ],
        'body'    => wp_json_encode( [ 'products' => [ [
            'id'       => $group_id,
            'variants' => [ [
                'id'           => $item_id,
                'availability' => [ 'status' => $product->is_in_stock() ? 'in_stock' : 'out_of_stock' ],
            ] ],
        ] ] ] ),
    ] );
}
add_action( 'woocommerce_product_set_stock', 'wppoland_push_chatgpt_stock' );
add_action( 'woocommerce_variation_set_stock', 'wppoland_push_chatgpt_stock' );

The product ID in the Delta request is the catalog’s group_id when variants are grouped, otherwise the item_id. A price update uses the same structure with price as an object of integer minor units and currency, for example {"amount": 7999, "currency": "EUR"}. An accepted: true response confirms submission only; the change applies asynchronously. Keep the CSV export consistent with Delta changes, or the next full upload will overwrite them with stale values.

#installing the chatgpt ads measurement pixel in wordpress

The Measurement Pixel guide asks for a small loader script near the top of the <head> on every page that should record conversions, initialized with a Pixel ID created in the conversions tab of Ads Manager. No API key goes into the browser. In WordPress that means a wp_head action with an early priority, or the head slot of an existing tag manager setup.

Three parts of the guide need decisions before deployment:

• Consent. The pixel defaults to consent granted unless it is told otherwise. For EU traffic, call oaiq("consent", false) before initialization and switch it to true when the visitor accepts measurement in the consent banner. Blocked events are not replayed later, and setting consent to false removes the pixel’s cookies.
• Content Security Policy. Sites with a CSP must allow https://bzrcdn.openai.com in script-src and connect-src, and https://bzr.openai.com in connect-src and img-src. The guide says not to add 'unsafe-inline' just for the pixel; use the site’s existing nonce or hash mechanism.
• Cookies. With consent, the pixel sets __oppref, which holds the click identifier for 30 days, and __obref, a random browser reference that lasts 365 days. Both belong in the cookie policy.

For a store, the event that matters most is order_created on the order-received page, with the order total in minor units and the order number as event_id.

add_action( 'woocommerce_thankyou', function ( $order_id ) {
    $order = wc_get_order( $order_id );
    if ( ! $order || $order->get_meta( '_oaiq_sent' ) ) {
        return; // Avoid a second event when the page is reloaded.
    }
    $order->update_meta_data( '_oaiq_sent', 1 );
    $order->save();
    $payload = [
        'type'     => 'contents',
        'amount'   => (int) round( $order->get_total() * 100 ), // Minor units for two-decimal currencies.
        'currency' => $order->get_currency(),
    ];
    printf(
        '<script>window.oaiq && oaiq("measure","order_created",%s,{event_id:%s});</script>',
        wp_json_encode( $payload ),
        wp_json_encode( 'order_' . $order->get_order_number() )
    );
} );

The multiplication by 100 fits currencies with two decimals such as EUR, PLN or NOK. The docs give JPY as an example where 8900 means 8,900, so stores selling in zero-decimal currencies must skip it.

#sending woocommerce orders through the conversions api

The pixel depends on the browser: ad blockers, consent refusals or a closed tab after payment can all lose the event. The Conversions API covers that gap by sending confirmed orders from the server to https://bzr.openai.com/v1/events, authenticated with a separate Conversions API key.

The documented rules translate into a short checklist for a WooCommerce integration:

• Deduplication. Use the same Pixel ID, the same event name and the same event ID as the pixel. OpenAI keeps the first event it receives for a matching key and ignores later duplicates.
• The click identifier. Unlike the pixel, the API does not capture oppref. Read it from the __oppref cookie during checkout, store it on the order and send the original string unchanged.
• Timestamps. timestamp_ms is the time of the purchase in Unix milliseconds, and it must fall within the last 7 days and no more than 10 minutes in the future. A queue that retries failed orders days later will lose them.
• Batches. Up to 1,000 events per request, and one invalid event fails the whole batch. validate_only: true checks a payload without saving it.
• Customer data. Optional hashed identifiers improve matching. Emails are trimmed and lowercased before SHA-256 hashing; phone numbers keep the country code and drop symbols and leading zeros.
• All orders, not only tagged ones. OpenAI recommends sending every conversion, not just those with an oppref, so that view-through conversions can be counted.

// Store the click identifier on the order while the cookie is still available.
add_action( 'woocommerce_checkout_create_order', function ( $order ) {
    if ( ! empty( $_COOKIE['__oppref'] ) ) {
        $order->update_meta_data( '_oppref', sanitize_text_field( wp_unslash( $_COOKIE['__oppref'] ) ) );
    }
} );

add_action( 'woocommerce_payment_complete', function ( $order_id ) {
    $order = wc_get_order( $order_id );
    if ( ! $order || ! defined( 'OPENAI_CONVERSIONS_API_KEY' ) || ! defined( 'OPENAI_PIXEL_ID' ) ) {
        return;
    }
    $event = [
        'id'            => 'order_' . $order->get_order_number(), // Same value as the pixel event_id.
        'type'          => 'order_created',
        'timestamp_ms'  => $order->get_date_paid()->getTimestamp() * 1000,
        'action_source' => 'web',
        'source_url'    => $order->get_checkout_order_received_url(),
        'user'          => [ 'emails_sha256' => [ hash( 'sha256', strtolower( trim( $order->get_billing_email() ) ) ) ] ],
        'data'          => [
            'type'     => 'contents',
            'amount'   => (int) round( $order->get_total() * 100 ),
            'currency' => $order->get_currency(),
        ],
    ];
    if ( $order->get_meta( '_oppref' ) ) {
        $event['oppref'] = $order->get_meta( '_oppref' );
    }
    wp_remote_post( 'https://bzr.openai.com/v1/events?pid=' . rawurlencode( OPENAI_PIXEL_ID ), [
        'timeout' => 10,
        'headers' => [
            'Authorization' => 'Bearer ' . OPENAI_CONVERSIONS_API_KEY,
            'Content-Type'  => 'application/json',
        ],
        'body'    => wp_json_encode( [ 'events' => [ $event ] ] ),
    ] );
} );

Hashing the email belongs only in stores whose privacy notice and consent setup cover sharing hashed identifiers with an ad platform. Without that legal basis, drop the user block; the event still counts, with weaker matching.

Before you paste the pixel, check what it sends on your side too. Buchodi’s analysis of 20 September 2026 describes the __obi cookie that ChatGPT sets on .openai.com for a year and that travels back to OpenAI from advertiser sites alongside the oaiq.min.js events. The SDK can collect data from form fields and the tag manager data layer by itself, and automatic matching was enabled on 638 of 881 pixels with a known setting. Every decoded token carried consent_decision: analytics_allowed, so OpenAI treats the cookie as analytics. In a WooCommerce store, load the pixel only after marketing consent in your own banner, and switch off automatic matching if you do not want the script reading checkout fields.

#how chatgpt ads attribution differs from utm tracking

Analytics tools that rely on UTM parameters will see ChatGPT ad clicks only as well as the landing URLs are tagged. ChatGPT Ads attribution does not depend on UTMs. It uses its own click reference, oppref, passed on the landing page URL and kept in the first-party cookie described above.

The documented attribution model has three parts:

• Click-through conversions are credited within the click window configured in the conversion event setting. The setup guide uses a 30-day window.
• View-through conversions, where available for an account, use a fixed one-day window after an eligible impression. Ads Manager reports them as a separate campaign metric; they are not part of the Conversions total, and CPA, bidding and billing remain click-based.
• When both apply, the click takes precedence.

For testing, the monitoring endpoint returns a sample of events from roughly the last 15 minutes and shows whether each arrived through pixel_sdk or server_to_server. A test purchase should show up in both channels with the same event ID, and only once in reported conversions.

The practical consequence for reporting is that ChatGPT Ads numbers and GA4 numbers will not match by design. GA4 sees sessions and whatever UTMs you add; Ads Manager sees oppref matches and view-through credit that GA4 has no way to observe. Compare trends, not totals.

#product schema on woocommerce pages alongside the ads feed

OpenAI’s feed documentation does not mention structured data on the product page, so there is no documented rule that schema markup affects ChatGPT ad delivery. It still matters for the organic side: Google uses Product structured data for merchant listings, and a single source of truth for price, availability and GTIN keeps the feed, the page and the markup from disagreeing.

WooCommerce already outputs Product markup. The filter below adds the GTIN from the built-in field and makes availability explicit, without replacing the offer data WooCommerce generates:

add_filter( 'woocommerce_structured_data_product', function ( $markup, $product ) {
    $gtin = $product->get_global_unique_id();
    if ( $gtin && preg_match( '/^\d{8}$|^\d{12,14}$/', $gtin ) ) {
        $markup[ 'gtin' . strlen( $gtin ) ] = $gtin;
    }
    if ( isset( $markup['offers'][0] ) ) {
        $markup['offers'][0]['availability'] = $product->is_in_stock()
            ? 'https://schema.org/InStock'
            : 'https://schema.org/OutOfStock';
    }
    return $markup;
}, 10, 2 );

The same GTIN validation rule applies in both places: 8, 12, 13 or 14 digits, never a made-up value.

#combining organic chatgpt visibility with chatgpt ads

Because OpenAI keeps ads separate from answers, organic presence and paid placement need separate work, and each covers a gap the other cannot.

1. Organic answers. Being cited in the answer depends on content and product data that ChatGPT can find and trust: clear guides, comparisons, accurate product pages and, for products, is_eligible_search in the feed. Paying for ads does not change this.
2. Paid placement. The ad below the answer is where a store can appear for commercial conversations even without an organic mention. It runs on the feed, the bids and the conversion data described above.

A store that only buys ads depends on spend for every visit. A store that only works on organic visibility has no way to appear when a conversation is close to purchase and the answer cites someone else. Running both, with one product data pipeline feeding search eligibility and ads eligibility, avoids maintaining two catalogs.

#implementation checklist for wordpress and woocommerce

1. Clean identifiers. Give every product and variation a stable SKU, fill the GTIN field where one exists, and never fill it with placeholders.
2. Build the CSV export. Map the nine required fields, add group_id, listing_has_variations and variant_dict for variations, and set is_ads_eligible per product.
3. Automate the upload. Write the file on a schedule, push it to the SFTP root and check the upload history for rejected rows.
4. Wire the Delta API. Send stock and price changes from WooCommerce or the ERP as they happen, in minor units.
5. Install the pixel with consent. Load it early in the head, gate it on the consent banner, update the CSP and the cookie policy.
6. Add the Conversions API. Capture oppref at checkout, send confirmed orders with the same event ID as the pixel, and keep both API keys on the server.
7. Create conversion settings before campaigns. Choose the standard event, check events in the monitoring endpoint, and only then create a conversion-optimized campaign, since the objective cannot be changed later.