How to Get Your Product Listed in ChatGPT Shopping (Step-by-Step Guide)

ChatGPT Shopping can recommend a product only when it can find, understand and trust the facts about it. It draws on two channels: pages crawled by OpenAI's OAI-SearchBot, and structured product data that merchants send in a feed. This guide walks through how those channels fit together and the steps a merchant can take to make a catalog eligible: allow the crawler, publish accurate Product and Offer markup, keep the feed and the pages consistent, keep both fresh, and check the result.

OpenAI documents its commerce programme and feed requirements on its own pages, listed in the references. Where this guide gives a pipeline or a scoring formula, it is a reference design for reasoning about the problem, not a statement of OpenAI's internal implementation. Always follow the current OpenAI specification for exact fields and update cadence.

How ChatGPT Shopping Combines Crawling and Merchant Feeds

Rather than ranking pages by keyword density, ChatGPT Shopping works as a dual-channel pipeline. One channel is web crawling: OAI-SearchBot reads product and category pages and extracts their content and structured data. The other is the merchant feed: a structured set of product records with attributes such as identifier, title, description, link, price, availability and brand, which the merchant keeps up to date.

A conversational query is turned into an embedding, a dense numeric representation of the shopper's intent. Candidate products are retrieved from a dense vector index, for example a Hierarchical Navigable Small World (HNSW) graph, alongside a lexical index such as BM25. The two candidate lists are merged with Reciprocal Rank Fusion (RRF), and a final stage weighs factors such as price competitiveness, reviews, stock status and the merchant's authority before products appear in a shopping carousel inside the conversation.

Entity resolution matters throughout. Each product should resolve to a single canonical entity, with variants such as size and colour attached to a parent product. Global Trade Item Numbers (GTINs) from GS1 and Schema.org Product graphs are the identifiers this step relies on.

Four-Phase Ingestion and Retrieval Protocol

1. Phase 1: Discovery and crawl validation. OAI-SearchBot reads robots.txt under RFC 9309 to learn which paths it may fetch. Product and category pages must return a successful response quickly, and rules that disallow cart and admin paths are respected.

2. Phase 2: Feed ingestion and schema binding. The merchant sends product records through the feed, and the same facts appear in the page's JSON-LD Product and Offer markup. The two sources are bound by the product identifier.

3. Phase 3: Dense retrieval and rank fusion. The query is embedded, dense and lexical candidates are retrieved, and RRF merges them. Here $k$ is a smoothing constant traditionally set to 60 and $w_m$ weights each channel:

   $\text{RRF}(d) = \sum_{m \in \{\text{dense}, \text{sparse}\}} \frac{w_m}{k + r_m(d)}$

4. Phase 4: Multi-factor scoring and carousel emission. Top candidates are scored on price, reviews, availability and merchant authority, and the best are shown to the shopper.

The difference in the last column is what makes natural, ambiguous, long-tail shopping questions answerable. The wider architecture of shopping agents is described in Amazon Buy for Me and the Transition to Agentic Commerce.

Preparing Your Store: Crawl Access, Feed Freshness and Origin Response

Getting listed is mostly a matter of removing obstacles. Work through these steps in order.

Step 1: Let OAI-SearchBot reach your product pages

Check robots.txt and your edge configuration. A web application firewall (WAF) from a provider such as Cloudflare or AWS can classify OAI-SearchBot as an untrusted scraper and block it, even when robots.txt allows it. Allow its user-agent token explicitly, and make sure your canonical product and category paths return HTTP 200. If OAI-SearchBot meets repeated 429 or 503 responses, it backs off, which slows how quickly your catalog is crawled.

Step 2: Publish accurate Product and Offer markup

Mark each product page up with Schema.org Product and a linked Offer, joined by explicit @id anchors. Include the properties a shopping system needs to ground an answer: priceCurrency as an ISO 4217 code, price, availability, itemCondition, brand and a global identifier such as a GTIN. Omitting the nested Offer, or leaving out itemCondition or availability, weakens the machine's confidence in the record.

Step 3: Send the merchant feed

Follow OpenAI's Product Feed specification for the required attributes and for how updates are delivered. The feed is how price and stock changes reach ChatGPT between crawls, so treat it as the primary source of truth for volatile facts.

Step 4: Keep the feed and the page in agreement

When the price on a page template changes but the JSON-LD or the feed still carries the old value, a consistency check can flag the product, and the system can suppress a recommendation it cannot trust. Update all three together.

Step 5: Keep origin response times low

A slow origin can make a crawl time out before the structured data is parsed. Use HTTP/2 and efficient caching, and revalidate with entity tags, as RFC 9110 describes.

Step 6: Verify, then monitor

Validate your markup with the Schema.org validator, check your server logs for OAI-SearchBot requests and their status codes, and ask ChatGPT shopping-style questions about your products to see whether they appear. Tracking those answers over time is covered in Tracking Brand in AI Responses.

For completing a purchase inside the conversation, OpenAI publishes separate checkout and payment specifications, listed in the references.

Scoring Products: Relevance, Data Consistency and Freshness

One way to reason about visibility is as a composite score over three kinds of evidence: how well the product matches the query, how reliable its data is, and how fresh that data is. For a product document $d$ and a conversational query $q$, a conceptual score is:

$S(d, q) = w_1 \cdot \text{Sim}(\mathbf{v}_q, \mathbf{v}_d) + w_2 \cdot \text{RRF}(d) + w_3 \cdot G_{\text{factual}}(d) + w_4 \cdot \Phi_{\text{freshness}}(\Delta t)$

with weights $w_i$ that sum to one. The first term is the cosine similarity between the query embedding and the product embedding:

$\text{Sim}(\mathbf{v}_q, \mathbf{v}_d) = \frac{\mathbf{v}_q \cdot \mathbf{v}_d}{\|\mathbf{v}_q\|_2 \|\mathbf{v}_d\|_2}$

The third term, factual grounding, measures how often your structured data and your feed agree over an attribute set $\mathcal{A}$, for example GTIN, price, currency, availability, brand and condition:

$G_{\text{factual}}(d) = \frac{1}{|\mathcal{A}|} \sum_{a \in \mathcal{A}} \mathbb{I}\left(\text{Schema}(a) \equiv \text{Feed}(a)\right)$

This ratio is a useful self-audit metric. A value below one means at least one attribute disagrees, and each disagreement is a reason a system might distrust the record. The fourth term models freshness as an exponential decay in the time $\Delta t$ since the last verified feed update:

$\Phi_{\text{freshness}}(\Delta t) = \exp(-\lambda \Delta t)$

OpenAI has not published weights or decay rates for any such score, so treat $w_i$ and $\lambda$ as symbols. The takeaway is directional: relevance, consistency and freshness each matter, and consistency and freshness are the two a merchant fully controls.

The end-to-end time from request to answer is also bounded, so crawl and fetch delays count against a product. Conceptually, with a latency budget $B$:

$\mathcal{L}_{\text{total}} = \tau_{\text{DNS}} + \tau_{\text{TLS}} + \tau_{\text{TTFB}} + \tau_{\text{HNSW}} + \tau_{\text{RRF}} \le B$

Fixing Missing Products: A Four-Phase Recovery Checklist

When products are absent from shopping answers, four failure modes cover most cases: crawler access denials, attribute mismatches between markup and feed, feed latency, and weak semantic match. Work through the checklist below.

1. Phase 1: Crawl health. Audit robots.txt syntax and your edge access logs. Confirm that OAI-SearchBot receives HTTP 200 responses and that your origin responds quickly.
2. Phase 2: Schema and graph integrity. Run the Schema.org validator over your pages. Confirm every Product links to its Offer, and that identifiers such as GTINs are well formed.
3. Phase 3: Feed telemetry. Check that your feed endpoint accepts and acknowledges updates, and that the age of the last successful update matches how often your prices and stock change.
4. Phase 4: Semantic match. Compare the questions shoppers ask with how your catalog describes the product. If there is a gap, enrich the metadata with GTINs, technical specifications and verified aggregate ratings.

One simple way to track recovery effort is the expected time to fix, weighted by how often each fault occurs:

$\text{MTTR}_{\text{catalog}} = \sum_{s \in \mathcal{S}_{\text{fault}}} P(s) \cdot \left( \tau_{\text{detect}}(s) + \tau_{\text{remediate}}(s) + \tau_{\text{reindex}}(s) \right)$

Product Markup and Identifier Standards for ChatGPT Shopping

Machine-readable catalog data depends on a few standards. JSON-LD 1.1 carries the structured data. RFC 9309 defines the robots directives that OAI-SearchBot follows. ISO 4217 defines currency codes. GS1 GTINs identify trade items globally, so one product resolves to one entity across merchants. RFC 9110 defines the HTTP semantics for caching and revalidation.

The Schema.org Product should link to one or more Offer entities through explicit @id anchors. This separates stable product facts such as brand, GTIN and specifications from transactional terms such as price, currency, stock, shipping and returns. The example uses placeholder values, including a placeholder identifier:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Product",
      "@id": "https://example.com/products/enterprise-edge-server#product",
      "name": "Enterprise Edge Computing Server E-9000",
      "description": "High-throughput edge computing server with dual redundant power supplies and hardware cryptographic acceleration.",
      "image": "https://example.com/images/server-e9000.jpg",
      "sku": "SRV-E9000-X1",
      "gtin14": "00000000000000",
      "brand": {
        "@type": "Brand",
        "name": "Example Brand"
      },
      "aggregateRating": {
        "@type": "AggregateRating",
        "ratingValue": "4.8",
        "reviewCount": "128",
        "bestRating": "5",
        "worstRating": "1"
      },
      "offers": {
        "@type": "Offer",
        "@id": "https://example.com/products/enterprise-edge-server#offer",
        "url": "https://example.com/products/enterprise-edge-server",
        "priceCurrency": "USD",
        "price": "4299.00",
        "priceValidUntil": "2026-12-31",
        "itemCondition": "https://schema.org/NewCondition",
        "availability": "https://schema.org/InStock",
        "seller": {
          "@type": "Organization",
          "name": "Example Seller"
        },
        "hasMerchantReturnPolicy": {
          "@type": "MerchantReturnPolicy",
          "applicableCountry": "US",
          "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
          "merchantReturnDays": 30,
          "returnMethod": "https://schema.org/ReturnByMail",
          "returnFees": "https://schema.org/FreeReturn"
        }
      }
    }
  ]
}

Only mark up ratings and reviews that real customers wrote and that appear on the page. The values above are placeholders for the shape of the data.

Terms that recur in this area: OAI-SearchBot, ChatGPT Shopping, product feed specification, Schema.org JSON-LD, Neural Generative Retrieval, HNSW indexing, vector quantisation, Reciprocal Rank Fusion, entity resolution, GTIN, agentic checkout and conversational query optimisation. For how shopping fits into a wider brand plan, see How D2C and E-commerce Brands Win AI Search, and for advertising in the same surface see What We Know About Ads in ChatGPT.

References

• ChatGPT merchants page — OpenAI. https://chatgpt.com/merchants
• Product Feed Specification — OpenAI. https://developers.openai.com/commerce/specs/feed
• Get Started guide — OpenAI Commerce. https://developers.openai.com/commerce/guides/get-started
• Checkout Specification — OpenAI. https://developers.openai.com/commerce/specs/checkout
• Payment Specification — OpenAI. https://developers.openai.com/commerce/specs/payment
• Product — Schema.org. https://schema.org/Product
• Offer — Schema.org. https://schema.org/Offer
• AggregateRating — Schema.org. https://schema.org/AggregateRating
• Schema Markup Validator — Schema.org. https://validator.schema.org
• Robots Exclusion Protocol (RFC 9309) — IETF, 2022. https://www.rfc-editor.org/rfc/rfc9309.html
• JSON-LD 1.1 Specification — W3C, 2020. https://www.w3.org/TR/json-ld11/
• HTTP Semantics (RFC 9110) — IETF, 2022. https://www.rfc-editor.org/rfc/rfc9110