AI Shopping Data Sources Compared: Where Product Data Lives

TL;DR:

• AI shopping data comes from four distinct surfaces, not one feed. ChatGPT Shopping, Google AI Mode, Google AI Overview, and Google Shopping each return a different unit of data for the same query, so the surface you pick decides what you can monitor.
• ChatGPT Shopping is the only surface that returns a per-merchant offer list. The scraper.chatgpt actor with shopping: true returns products carrying an offers[] array — the same model priced across Sony, Best Buy, Walmart, and Target in one response.
• Google AI Mode returns a synthesized answer, cited sources, and rich product detail in one call. A single scraper.aimode request returned 7 citations and 7 products, each product carrying brand, price range, rating, stores, and reviews.
• Google AI Overview only populates products when its shopping intent triggers. The scraper.overview actor returns is_shopping and is_overview_shopping flags; both were false for "best running shoes 2026", so products came back null — the flags themselves are the commercial-intent signal.
• Google Shopping is the catalog baseline, reached over a different endpoint. The scraper.google.search actor with tbm: "shop" posts to /api/v1/scraper/request, not the v2 execute endpoint the LLM actors share, and returns a shopping-SERP shape: metadata, query refinements, and search_information.
• Free to start. New Scrapeless accounts include free trial credits — sign up at app.scrapeless.com.

Introduction: product data now lives on four surfaces

A shopper asking "best running shoes 2026" no longer lands on one results page. The same query fans out across ChatGPT's shopping carousel, Google's AI Mode answer page, the inline AI Overview block, and the Google Shopping SERP — and each surface answers with a different shape of data. One returns priced offers per merchant; one returns a synthesized answer with cited sources; one returns a commercial-intent flag; one returns a catalog index. Treating "AI shopping data" as a single feed misses where each fact actually lives.

This post is the sourcing map, not a collector tutorial. It compares the four surfaces side by side: which actor reads each one, what triggers it, the unit of data it yields, and the monitoring job it is built for. All four are Universal Scraping API actors, so the decision is not which vendor to use — it is which surface answers the question you are actually asking. For the inline-block surface specifically, scrape Google AI Overviews covers the scraper.overview actor on its own.

The four surfaces at a glance

Each surface is a different point in the buying journey, and the actor that reads it returns a correspondingly different payload:

• ChatGPT Shopping — the product carousel ChatGPT shows for a buying-intent prompt, read by scraper.chatgpt with shopping: true.
• Google AI Mode — Google's full-page conversational answer engine, read by scraper.aimode.
• Google AI Overview — the inline AI block above the organic results, read by scraper.overview.
• Google Shopping — the dedicated shopping SERP, read by scraper.google.search with tbm: "shop".

The sourcing matrix: four surfaces side by side

The matrix below is the centerpiece — read down a column to see what one surface yields, read across a row to see why no single actor covers every shopping question.

One transport detail decides client design up front: the three LLM actors (scraper.chatgpt, scraper.aimode, scraper.overview) all POST to /api/v2/scraper/execute and return the { status, task_id, task_result } envelope, while scraper.google.search posts to /api/v1/scraper/request with input: { q, tbm: "shop", hl, gl }. Three surfaces share one client; the fourth needs its own request shape.

ChatGPT Shopping: the cross-merchant price surface

ChatGPT Shopping is the only one of the four surfaces that returns an actual price per merchant. With shopping: true inside input, scraper.chatgpt returns a products[] array where each product carries a headline price, a rating, a num_reviews count, and an offers[] list — one entry per merchant, each with its own merchant_name, price, available flag, and a details string for stock and delivery. A single headphone result returned the same model priced at Sony, Best Buy, Walmart, and Target in one response. When the question is "what does this item cost across stores right now", this is the surface that answers it. The carousel renders per session, so a populated products array on one call and an empty one on the next are both normal — treat the array as nullable and aggregate scheduled runs.

Google AI Mode: the answer-plus-product-detail surface

Google AI Mode returns the most layered payload of the four. A single scraper.aimode request returned the synthesized answer in three formats (result_text, result_md, result_html), a citations[] array of 7 sources, and a products[] array of 7 entries — and each product object is rich, carrying brand, price_range, rating, stores, reviews, and variants rather than a single price. AI Mode is where Google routes research and comparison questions, so it doubles as a citation-share surface (which domains the answer drew on) and a product-research surface (the detail behind each recommendation). The trade-off is that it does not return a clean per-merchant offer the way ChatGPT Shopping does; the price detail is a range, not a row per store.

Google AI Overview: the commercial-intent flag surface

Google AI Overview is the surface that tells you whether a query is commercial at all. The scraper.overview actor returns the inline-block answer as content and rawtext, the attributed sources split across source[] and web_source[] (each entry carrying website_name, title, url, and snippet), and two booleans — is_shopping and is_overview_shopping. For "best running shoes 2026" both flags came back false, and products was null. That is the honest behavior to design around: the AI Overview block only populates a product array when its shopping intent fires, so the flags are the signal, not a bug. Read them to classify which of your tracked queries Google treats as transactional, and read source[] plus web_source[] for the same citation-share metric AI Mode supports.

// Schema is what scraper.overview returns; field values are an illustrative sample from a live run.
{
  "status": "success",
  "task_id": "…",
  "task_result": {
    "is_shopping": false,
    "is_overview_shopping": false,
    "content": "The best running shoes of 2026 feature a heavy focus on max-cushion super trainers …",
    "source": [
      { "website_name": "YouTube", "title": "Best Running Shoes of 2026 (So Far) …", "url": "https://…", "snippet": "…", "stores": null }
    ],
    "web_source": [
      { "website_name": "The Run Testers", "title": "The Best Running Shoes 2026", "url": "https://…", "snippet": "…" }
    ],
    "products": null,
    "ads": null
  }
}

When a tracked query flips is_shopping to true, the same response begins carrying a populated products array — so the flag is also the trigger that tells a pipeline when to start reading product data from this surface.

Get your API key on the free plan: app.scrapeless.com

Google Shopping: the catalog baseline

Google Shopping is the catalog index the other three surfaces summarize from. The scraper.google.search actor with tbm: "shop" reads the dedicated shopping vertical and returns a SERP shape — metadata (engine and raw URL), a search_information block (query_displayed, organic_results_state, total_results), a refine_this_search[] array of facet queries Google suggests for the term, and pagination. It is the part of Deep SerpApi that maps the shopping landscape rather than any model's opinion of it. Row depth varies by query: "best running shoes 2026" returned a thin result set with total_results at 0 and the value sitting in the refinement facets instead, so treat this surface as the structural baseline of what Google indexes for a term, and confirm row counts per query rather than assuming a full grid.

How the four localize, and what stays nullable

Every surface localizes, but not through the same field. The three LLM actors take a two-letter country inside input; scraper.google.search takes gl (country) plus hl (language). Pin the region per call and compare like with like — a US capture and a JP capture are different datasets on all four surfaces.

Every field on every surface is nullable and per-session. ChatGPT's products[] can be empty even with shopping: true; AI Mode's citations[] and products[] shift in count run to run; AI Overview's products is null whenever is_shopping is false; Google Shopping's row count moves with the query. A persistently empty array means there was no answer for that query and region — record it and move on, rather than reading it as failure. Store task_id and a capture timestamp on every call so the time series, not any single response, is the signal.

Decision guide: which surface for which job

Pin the surface to the question:

Because three of the four ride the same v2 endpoint and envelope, capturing ChatGPT Shopping, AI Mode, and AI Overview for one query and country is the same client with a different actor string. Google Shopping joins the picture as a second request shape against the v1 endpoint, keyed to the same query and region so the catalog baseline lines up with the AI surfaces above it.

Conclusion: pick the surface, not the feed

AI shopping data is four surfaces, and each answers a different question: ChatGPT Shopping for cross-merchant price, Google AI Mode for citations plus product detail, Google AI Overview for the commercial-intent flag and its sources, and Google Shopping for the catalog baseline. Map the job to the surface, pin the region per call, treat every field as nullable, and store task_id plus a timestamp so the series is the signal. Run a fixed query set on a schedule with Universal Scraping API credits and the four surfaces become one coordinated view of where product data lives. The actor names and response fields here are confirmed against live runs in the LLM Chat Scraper reference.

Ready to Build Your AI-Shopping Data Pipeline?

Join our community to claim a free plan and connect with developers building AI-answer data pipelines: Discord · Telegram.

Sign up at app.scrapeless.com for free trial credits and point one client at the four surfaces above to map where the product data your program tracks actually lives.

FAQ

Q: Which of the four surfaces returns an actual price per merchant?
Only ChatGPT Shopping. The scraper.chatgpt actor with shopping: true returns a products[] array whose offers[] list carries one priced entry per merchant. AI Mode returns a price_range per product, AI Overview returns prices only when its shopping intent fires, and Google Shopping returns a SERP index rather than a resolved offer row.

Q: Do all four surfaces use the same endpoint?
No. The three LLM actors — scraper.chatgpt, scraper.aimode, and scraper.overview — POST to /api/v2/scraper/execute and share the { status, task_id, task_result } envelope. scraper.google.search posts to /api/v1/scraper/request with input: { q, tbm: "shop", hl, gl }, so it needs its own request shape.

Q: Why was the AI Overview products field null?
Google AI Overview only populates products when is_shopping (or is_overview_shopping) is true. For "best running shoes 2026" both flags were false, so products came back null. The flags are the commercial-intent signal; read them to know when product data will appear on that surface.

Q: Which surfaces give me citation sources for share-of-citation tracking?
Two of them. Google AI Mode returns a citations[] array, and Google AI Overview returns source[] plus web_source[], each entry naming the source by website_name, title, and url. Parse the host from each URL and tally across captures to build a citation-share table.

Q: Can one client read all four surfaces?
Three of them, yes — ChatGPT Shopping, AI Mode, and AI Overview share the v2 endpoint, header, and envelope, so swapping the actor name is a one-line change. Google Shopping needs a separate request against the v1 endpoint with gl/hl localization, so a complete pipeline runs the shared v2 client plus one dedicated scraper.google.search call.