DEV Community

Cover image for What a WooCommerce Product Looks Like to ChatGPT: Feeds, Variations and WebMCP Tools
LovedByAI
LovedByAI

Posted on Originally published at lovedby.ai

What a WooCommerce Product Looks Like to ChatGPT: Feeds, Variations and WebMCP Tools

What a WooCommerce Product Looks Like to ChatGPT: Feeds, Variations and WebMCP Tools

Ask ChatGPT what to buy and it answers with product cards: a picture, a price, stock and a link to the store. If you build or run WooCommerce stores, the interesting question is where those cards come from, because the answer is "product data, in a specific shape", and right now a WooCommerce store has to provide that shape itself.

OpenAI's merchant page lists Shopify and Etsy catalogs as already integrated, with no setup. WooCommerce isn't on that list. So for a WooCommerce store, getting into AI shopping is a data plumbing job.

OpenAI's merchant page, Power product discovery in ChatGPT, asking stores to share a product feed

This post walks through that plumbing from a developer's side: what a feed row looks like, how a variable product maps to feed rows, where the Universal Commerce Protocol (UCP) fits, and what registering a WebMCP tool looks like in the browser. Every code block is an example, not production code.

The three integration surfaces

AI shopping today runs through three protocols, each with a different consumer:

Protocol Who reads it What the store provides
ACP product feed ChatGPT The catalog as a file in OpenAI's product feed format, added in OpenAI's Business Hub
UCP Google AI Mode and Gemini The catalog published through the Universal Commerce Protocol
WebMCP AI agents in the browser Tools registered on the store's own pages

Before you design anything, three constraints:

  • Checkout happens on the store's site. OpenAI moved away from a standalone Instant Checkout in ChatGPT. Shoppers discover and compare in the assistant, then buy through the store's normal WooCommerce checkout. There is no checkout inside ChatGPT or Gemini yet.
  • Shopping in ChatGPT is U.S.-only for now. OpenAI says more regions will follow.
  • OpenAI says there are no fees on purchases that start in ChatGPT.

So everything below is about discovery and accurate representation. Orders, payments and customer data stay in WooCommerce.

Part 1: one row of an OpenAI product feed

The feed is the catalog side of the Agentic Commerce Protocol (ACP), which OpenAI and Stripe published in 2025. It's one row per purchasable item or variant, and OpenAI's schema requires nine fields on every row, plus two about where you sell:

item_id, title, description, url, brand, seller_name, image_url, availability, price, then target_countries and store_country.

Here's a simple (non-variable) product as one row. I'm showing it as JSON because it's easy to read.

// EXAMPLE ONLY. Field names are from OpenAI's product feed schema.
// Value formats (how price and availability are encoded) and the file
// format are placeholders here. Check OpenAI's schema before you ship.
{
  "item_id": "1042",
  "title": "Trailhead 30L Waterproof Daypack",
  "description": "A 30-litre daypack with a waterproof shell, a padded laptop sleeve and two side bottle pockets.",
  "url": "https://example-store.com/product/trailhead-30l-daypack/",
  "brand": "Example Outdoor Co",
  "seller_name": "Example Store",
  "image_url": "https://example-store.com/wp-content/uploads/trailhead-30l.jpg",
  "availability": "in_stock",
  "price": "89.00 USD",
  "target_countries": ["US"],
  "store_country": "US"
}
Enter fullscreen mode Exit fullscreen mode

Most of this already exists in WooCommerce. The mapping:

Feed field WooCommerce source
item_id Product or variation ID, or its SKU
title Product name (up to 150 characters)
description Product description, with HTML and shortcodes removed (up to 5,000 characters)
url Product permalink
brand Brands (built into WooCommerce since 9.6) or a brand attribute
seller_name Site title
image_url Product image
availability Stock status (in stock, out of stock, on backorder)
price Regular price plus store currency
target_countries Selling and shipping locations
store_country Store address

Two of these are easy to get wrong:

  • description is plain text. WooCommerce descriptions are usually HTML, often with shortcodes from page builders. Strip both. A rendered shortcode tag in a product description is not something you want an AI quoting.
  • price is the regular price. If the product is on sale, the sale price goes in its own optional field, sale_price. Collapsing the two is exactly the kind of mix-up that happens when an AI reads a product page instead of a feed.

Optional fields add what shoppers compare on: sale_price, gtin and mpn, extra images, color and size, shipping, return policy, and review_count and star_rating.

Part 2: variable products become grouped rows

This is where WooCommerce's data model and the feed's diverge. In WooCommerce, a variable product is a parent with child variations. In the feed, each variation is its own row, and rows that belong to the same product share a group_id, with the variant's attributes in variant_dict.

So a T-shirt sold in four sizes becomes four rows that ChatGPT knows are one product. Two of them might look like this:

// EXAMPLE ONLY: two of four rows for one variable product.
// variant_dict's inner structure here is illustrative; check the schema.
[
  {
    "item_id": "2201",            // variation ID: stable, never reused
    "group_id": "2200",           // parent product ID: shared by all sizes
    "title": "Example Logo Tee, Size S",
    "variant_dict": { "size": "S" },
    "size": "S",
    "price": "28.00 USD",
    "availability": "in_stock"
    // ...plus the other required fields
  },
  {
    "item_id": "2202",
    "group_id": "2200",
    "title": "Example Logo Tee, Size M",
    "variant_dict": { "size": "M" },
    "size": "M",
    "price": "28.00 USD",
    "sale_price": "22.00 USD",
    "availability": "out_of_stock"
    // ...plus the other required fields
  }
]
Enter fullscreen mode Exit fullscreen mode

Conceptually, the export is a flattening pass over the catalog:

# PSEUDO-CODE, not tied to any WooCommerce function names
for each published product P:
    if P is simple:
        emit one row with item_id = P.id
    if P is variable:
        for each variation V of P:
            emit one row with
                item_id      = V.id (or V.sku)   # stable, never reused
                group_id     = P.id
                price        = V.regular price
                sale_price   = V.sale price, only if on sale
                availability = V.stock status
                variant_dict = V.attributes      # e.g. size, color
                title, description, url, image_url, brand, ...
validate: every row carries all required fields
Enter fullscreen mode Exit fullscreen mode

The rules from OpenAI that shape this pass:

  • Keep item_id stable. Use the product or variation ID, or the SKU, and never reuse it for a different product. A changed ID looks like a brand-new product to ChatGPT.
  • Each delivery is a full snapshot. You send the whole catalog every time, not a list of changes. Treat the feed as a generated view of the catalog, not a change log.
  • The feed has to agree with the page. OpenAI says the live website still checks the current offer when a shopper acts. A feed price that disagrees with the product page is a lost sale, so the feed and the page should read from the same data.

Delivering the feed

OpenAI's submission flow: claim the business in Business Hub, verify identity, choose countries and currencies, prepare the feed, pick one delivery method, then fix any rows OpenAI rejects.

There are three delivery methods: a manual upload, a hosted HTTPS URL, or SFTP.

For a WooCommerce store, the hosted URL is the one to aim for. A manual upload goes stale the moment someone edits a price or a product sells out. A hosted URL points OpenAI at a file on the store's own domain, and however you generate it, what sits at that URL has to reflect the store as it is now.

A feed isn't strictly required, since ChatGPT can also use public web sources. OpenAI's merchant page says a feed gives a store greater control over how its products appear. In practice that's the difference between ChatGPT working from whatever it last read off your pages and working from the catalog you state.

Part 3: where UCP fits

Google's AI shopping, in AI Mode and Gemini, needs the catalog in a form it can read too. The Universal Commerce Protocol is how a store publishes it, so Google's AI can find the products and send shoppers to the store's checkout.

I won't reproduce UCP's spec here. The architectural point is what matters: it's the same catalog going to a second consumer in a second format. If you're building this yourself, don't write "the ChatGPT exporter" and "the UCP exporter" as two independent readers of WooCommerce. Build one internal product model (IDs, prices, sale prices, stock, variants, policies) and render each protocol from it. Otherwise the two outputs drift apart, and an AI assistant ends up quoting two prices for the same jacket.

Part 4: WebMCP, tools for agents already on the page

The feed and UCP get your catalog to AI companies. WebMCP covers a different moment: an AI agent working inside the browser, on the store's page, on someone's behalf.

Without WebMCP, that agent reads the screen and guesses: which element is the size picker, which footer link is the returns policy, whether that crossed-out number is the price. With WebMCP, the page hands the agent a list of tools, each with a name, a plain description and the inputs it accepts, and the agent calls the one it needs. It's the difference between scraping a page and calling a function.

Where it stands, as of November 2026:

  • The WebMCP specification is a draft of the W3C Web Machine Learning Community Group, edited by engineers from Google and Microsoft. Chrome's documentation says it's still under active discussion and subject to change.
  • Chrome shipped an early preview behind a flag in February 2026 and opened an origin trial in Chrome 149 on June 9, 2026, so sites can switch it on for real visitors.
  • Chrome's Lighthouse added an Agentic browsing audit in June 2026 that checks whether a page registers WebMCP tools.
  • On August 25, 2026, OpenAI turned on WebMCP in the built-in browser of the ChatGPT desktop app, where ChatGPT and Codex can call what OpenAI calls site tools.
  • Firefox and Safari have not announced support.

A page can offer tools two ways: imperatively, by calling document.modelContext.registerTool() in JavaScript, or declaratively, by adding WebMCP attributes to an ordinary HTML form so the form becomes a tool.

Here's roughly what the imperative version looks like for a product search tool:

// ILLUSTRATIVE ONLY. WebMCP is a draft and the API may change.
// A tool has four parts: a name, a description, the inputs it accepts
// and the function that runs. The property names below are shorthand
// for those parts; the spec defines the exact ones.
if ("modelContext" in document) {
  document.modelContext.registerTool({
    name: "search_products",
    description:
      "Search this store's products by what the shopper is looking for. " +
      "Returns each match's name, price, stock status and product URL.",
    inputSchema: {
      type: "object",
      properties: {
        query: {
          type: "string",
          description: "What the shopper wants, e.g. 'waterproof daypack'",
        },
        max_price: {
          type: "number",
          description: "Optional price ceiling, in the store's currency",
        },
      },
      required: ["query"],
    },
    // This tool only reads, so it is marked read-only for the agent.
    annotations: { readOnlyHint: true },
    async execute({ query, max_price }) {
      // searchCatalog() is a stand-in for your own product search endpoint.
      return await searchCatalog(query, max_price);
    },
  });
}
Enter fullscreen mode Exit fullscreen mode

Some design rules that hold whatever the final API shape turns out to be:

  • One job per tool, named the way a person would say it. search_products, get_shipping_policy and get_return_policy beat one store_api tool with a mode parameter.
  • Mark read-only tools as read-only. Search, product details and policies change nothing, and readOnlyHint tells the agent so.
  • Leave state changes to the person. If you ever expose a tool that changes something, such as adding to a cart, the final step belongs to the shopper. Agents like ChatGPT ask before purchases.
  • The tools run in the visitor's tab, with the visitor's permissions. An agent can't reach anything through a WebMCP tool that the person couldn't already see. That's also why you need no separate server: unlike a classic MCP server, the tools only exist while the page is open.

For a store, the tool set that answers most shopping questions is small: search the products, read one product with its variants and stock, and answer shipping and returns. Those are the questions that decide a sale, and an agent that can't answer them tends to recommend a store where it can. Run Lighthouse's Agentic browsing audit afterwards to see which tools the page actually registers.

What we built

Disclosure first: I'm a co-founder of LovedByAI, and this is the part where I mention our product.

We launched LovedByAI eCommerce on November 19, 2026. It covers the three surfaces above from inside a WordPress plugin: a ChatGPT product feed in OpenAI's format that stays current, the catalog published through UCP for Google AI Mode and Gemini, and WebMCP tools for product search, variants, shipping and returns. It also adds schema markup, IndexNow pings and an AI crawlability check to the product pages. Every change it makes to a page is listed for the owner to approve, reject or undo, and the only manual step is pasting the feed link into OpenAI's Business Hub once.

The launch write-up is here: AI shopping for WooCommerce.

A checklist if you're building it yourself

  1. One internal product model, with every protocol rendered from it
  2. Stable item_id values: product or variation ID, or SKU, never reused
  3. Variations flattened to rows, grouped by group_id, attributes in variant_dict
  4. Plain-text descriptions, titles under 150 characters
  5. Regular price and sale price in separate fields
  6. Stock status per row that matches the store today
  7. A hosted HTTPS feed URL that always holds a full, current snapshot
  8. Feed values that match the live product page
  9. A few small, read-only WebMCP tools: search, product detail, shipping, returns
  10. Lighthouse's Agentic browsing audit to confirm the tools register

The rule under all ten: the catalog is the product AI sees. Keep one source of truth, and assume every protocol will want it in a slightly different shape.

Disclosure: I'm the co-founder of LovedByAI. Integrations, fees, checkout and U.S. availability: OpenAI's merchant page. Feed fields and delivery methods: OpenAI's product feed schema and submission guide. WebMCP status: the W3C Web Machine Learning Community Group draft and Chrome for Developers.

Top comments (0)