ChatGPT Shopping Data: Collect Products, Prices & Offers at Scale

TL;DR:

• ChatGPT Shopping data is structured product output, not screenshots. One POST to the scraper.chatgpt actor with shopping enabled returns ranked products, each with a price, rating, review count, and a list of per-merchant offers — as JSON fields.
• Every product carries multi-merchant offers. A single headphone result returns the same model priced at Sony, Best Buy, Walmart, Target, and other merchants in one offers array, each with its own availability and delivery note.
• The shopping flag rides inside input. The call that returns products is {"actor":"scraper.chatgpt","input":{"prompt":"...","country":"US","shopping":true}} against POST /api/v2/scraper/execute — top-level shopping params are rejected.
• The product carousel renders per session, not on every call. A buying-intent prompt populates products when ChatGPT shows shopping cards that session; the same call can return only the answer text with an empty array — so collection runs as a scheduled prompt set and aggregates the populated runs.
• Shopping responses cost more than plain answers. Returning resolved product cards is billed at a higher rate, so scope the prompt set to the products that matter.
• The envelope matches the other LLM actors. Every call returns { status, task_id, task_result }, so a client written here extends to Grok, Gemini, and Perplexity unchanged.
• Free to start. New Scrapeless accounts include free trial credits — sign up at app.scrapeless.com.

Introduction: the buy button moved into the answer

ChatGPT now answers shopping questions with a product carousel. A shopper asks for the best noise-cancelling headphones, and the model returns ranked products with images, prices, star ratings, and a row of merchants to buy from — inside the chat, before any store gets a click. For a brand, a results-page ranking no longer decides the sale; whether your product appears in that carousel, and at what price, does.

That surface is hard to read by eye and harder to track over time. Prices shift, merchants rotate in and out of each product's offer list, and the ranking changes by query and by country. Capturing it by driving the chat interface means login walls, lazy-loaded cards, and product fields that resolve client-side after the answer streams in.

The scraper.chatgpt actor returns that carousel as structured product data: prompt in, a products array out, each product carrying its price, rating, review count, and a list of per-merchant offers. What follows is the request that fills the products array, a field-by-field read of the response, a Python client that collects a prompt set on a schedule, and the companion actors that read the same shape on the other answer engines. For the visibility side of the same shift — which brands and sources the model names in its answers — brand AI visibility covers tracking the answer and its citations.

What You Can Do With It

• Recommendation-share tracking. Run a fixed set of buying prompts on a schedule and record which products ChatGPT ranks for each — the shopping equivalent of share-of-voice.
• Cross-merchant price monitoring. Read every offer on a product and watch the same model's price move across Sony, Best Buy, Walmart, and Target from one response.
• Catalog-visibility checks. Detect when your product enters or drops out of the carousel for a category prompt, and at what rank.
• Competitive assortment analysis. Capture which products the model surfaces for a category across markets, with ratings and review counts as comparison fields.
• Offer and availability monitoring. Track which merchants show in-stock for a product and what delivery window each one quotes.
• Shopping dataset building. Collect prompt–product–offer rows as clean JSON for pricing models or evaluation pipelines.

Why the Scrapeless ChatGPT Shopping Scraper

The Scrapeless ChatGPT Shopping scraper is the scraper.chatgpt actor with its shopping input enabled — part of the Universal Scraping API line. For shopping queries specifically, it brings:

• Server-side rendering of the chat session, so the product cards that normally resolve client-side come back already populated.
• Residential egress in the country you pass, because both the products and their prices are localized.
• The full offer list per product, not just the headline price — every merchant the model shows for that item.
• One envelope ({ status, task_id, task_result }) shared with the other LLM actors, so the same client reads ChatGPT, Grok, Gemini, and Perplexity.
• No browser to drive: one endpoint, an x-api-token header, JSON back.

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

Prerequisites

• Python 3.10 or newer (the client below uses only the standard library plus requests)
• A Scrapeless account and API key — sign up at app.scrapeless.com
• The key exported as SCRAPELESS_API_KEY
• Basic familiarity with the terminal and JSON

How the ChatGPT Shopping scraper works

The shopping response is the standard scraper.chatgpt call with shopping set to true inside input. The actor renders the query, waits for the product carousel to resolve, and returns the cards as a products array alongside the usual answer text and cited sources.

Request parameters

Parameters go inside the input object, not at the top level of the body.

Quick capture with curl

# Requires SCRAPELESS_API_KEY in the environment.
curl -sS -X POST https://api.scrapeless.com/api/v2/scraper/execute \
  -H "Content-Type: application/json" \
  -H "x-api-token: ${SCRAPELESS_API_KEY}" \
  -d '{
    "actor": "scraper.chatgpt",
    "input": {
      "prompt": "best Sony noise cancelling headphones to buy",
      "country": "US",
      "shopping": true,
      "web_search": true
    }
  }'
# Pipe to: | jq '.task_result.products'  for the carousel.

Response envelope

The products live under task_result.products. Each product carries a headline price and a merchants summary, plus an offers array with one entry per merchant. The shape below is a real capture for the headphone prompt above; values are point-in-time and the model identifier was gpt-5-mini.

// Schema is exactly what scraper.chatgpt returns with shopping enabled; field values are an illustrative sample from a live run (offers trimmed).
{
  "status": "success",
  "task_id": "…",
  "task_result": {
    "prompt": "best Sony noise cancelling headphones to buy",
    "model": "gpt-5-mini",
    "result_text": "Here are the best Sony noise-cancelling headphones …",
    "products": [
      {
        "title": "Sony WH-1000XM6",
        "price": "$398.00",
        "merchants": "Sony + others",
        "rating": 4.7,
        "num_reviews": 6021,
        "url": "https://electronics.sony.com/audio/headphones/headband/p/wh1000xm6-b",
        "image_urls": ["https://…"],
        "offers": [
          { "merchant_name": "Sony",     "price": "$398.00", "available": true, "details": "In stock online, Free delivery between Thu - Fri" },
          { "merchant_name": "Best Buy",  "price": "$398.00", "available": true, "details": "In stock online and nearby, Free delivery by Fri" },
          { "merchant_name": "Walmart",   "price": "$398.00", "available": true, "details": "" },
          { "merchant_name": "Target",    "price": "$398.00", "available": true, "details": "In stock online, Free delivery between Jun 19 - 25" }
        ]
      }
    ],
    "search_result": [ { "title": "…", "url": "https://…", "snippet": "…", "attribution": "…" } ]
  }
}

A few honest observations from running it:

• Population is per-session, not per-call. A conversational prompt returns the answer text with an empty array, and even a buying-intent prompt can come back with products empty on a given call — the carousel renders probabilistically. A scheduled prompt set captures the populated runs as they appear; treat an empty array as nullable, not an error.
• title, price, and rating resolve together. When the carousel renders, those fields arrive populated; a call that only half-triggers shopping can return product slots with empty fields, which you treat as nullable and skip.
• offers is the price-monitoring surface. The same product repeats across merchants at one price point per offer; read the array, not just the top-level price.
• Prices and availability are point-in-time. Store the capture timestamp in your own pipeline; the response reflects the moment of the run.

Integrating the API in Python: collect a prompt set at scale

The pattern for scale is a fixed prompt set, one call each, products flattened into rows. The client reads SCRAPELESS_API_KEY from the environment, requests shopping data, and emits one row per offer so a price table falls out directly.

"""Collect ChatGPT Shopping data for a prompt set (scraper.chatgpt).
    export SCRAPELESS_API_KEY=your_api_token_here
    python collect_shopping.py
"""
import os
import requests

ENDPOINT = "https://api.scrapeless.com/api/v2/scraper/execute"
PROMPTS = [
    "best Sony noise cancelling headphones to buy",
    "best budget mechanical keyboard to buy",
    "best robot vacuum under $300",
]


def shop(prompt: str, country: str = "US") -> list[dict]:
    resp = requests.post(
        ENDPOINT,
        headers={
            "Content-Type": "application/json",
            "x-api-token": os.environ["SCRAPELESS_API_KEY"],
        },
        json={
            "actor": "scraper.chatgpt",
            "input": {"prompt": prompt, "country": country, "shopping": True, "web_search": True},
        },
        timeout=220,
    )
    resp.raise_for_status()
    return resp.json().get("task_result", {}).get("products", []) or []


def offer_rows(prompt: str, products: list[dict]) -> list[dict]:
    rows = []
    for rank, product in enumerate(products, start=1):
        title = product.get("title")
        if not title:  # half-resolved card — treat as nullable, skip
            continue
        for offer in product.get("offers") or []:
            rows.append({
                "prompt": prompt,
                "rank": rank,
                "product": title,
                "rating": product.get("rating"),
                "reviews": product.get("num_reviews"),
                "merchant": offer.get("merchant_name"),
                "price": offer.get("price"),
                "available": offer.get("available"),
            })
    return rows


if __name__ == "__main__":
    for prompt in PROMPTS:
        rows = offer_rows(prompt, shop(prompt))
        print(f"{prompt}: {len(rows)} offer rows")
        for row in rows[:5]:
            print(f"  #{row['rank']} {row['product']} — {row['merchant']} {row['price']}")

Each prompt becomes a set of product-merchant-price rows: rank within the carousel, the product, its rating and review count, and one row per merchant offer. Write those rows to a warehouse on a schedule and price movement, rank changes, and merchant churn fall out as time series.

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

Companion actors for the other answer engines

Shopping carousels are appearing across the answer engines, and the same envelope reads all of them. Swap the actor, keep the client:

• scraper.grok — Grok's answers, with its live-search behavior
• scraper.gemini — Gemini responses
• scraper.perplexity — Perplexity answers and sources
• scraper.overview and scraper.aimode — Google's AI Overview and AI Mode surfaces

Each returns { status, task_id, task_result }, so the offer_rows function above works unchanged once a platform exposes products. The ranked best LLM scrapers comparison covers these surfaces side by side.

How to avoid common problems

• Empty products? Two causes. The prompt may not be transactional enough — use explicit buying language ("best … to buy", "… under $300") and keep shopping and web_search both true. Or the carousel simply did not render that session: population is per-session, so a scheduled prompt set aggregates the runs that do return cards, and downstream code treats an empty array as nullable.
• Half-resolved cards. A product slot can arrive with empty title/price; treat those fields as nullable and skip the row rather than storing blanks.
• Localized output. country changes both the products and their prices, so pin it per market and compare like with like — a US run and a JP run are different datasets.
• Cost. The shopping response is billed at a higher rate than a plain answer, so keep the prompt set scoped to the products you actually track.

Conclusion: the carousel as a data feed

ChatGPT Shopping reduces to one dependency: a single HTTP POST with shopping enabled returns ranked products and their per-merchant offers as JSON. Pin the country, phrase the prompt for purchase intent, read the offers array rather than the headline price, and treat half-resolved cards as nullable. Run a fixed prompt set on a schedule with Universal Scraping API credits and the carousel becomes a price-and-assortment time series. The request shape and field names are confirmed against the live LLM Chat Scraper actor.

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 the prompt set above at the product categories and markets your pricing program needs.

FAQ

Q: Is collecting ChatGPT Shopping data legal?
The data returned is the publicly visible shopping answer ChatGPT shows any user. As with any scraping, the legality depends on jurisdiction and use — review the relevant terms and consult counsel before building on it. Collect only public product and offer data, never personal data.

Q: Why is the products array empty?
The carousel only renders for transactional queries. A conversational prompt returns result_text with an empty products array; rephrase with buying intent and keep shopping: true.

Q: Do I need a proxy or a browser?
No. Rendering, session handling, and residential egress run server-side. You send one POST with an x-api-token header and read JSON back; the country field selects the egress market.

Q: How is this different from the ChatGPT scraper API guide?
That guide covers the answer text and its citations for visibility tracking. This one covers the shopping path: the products array and its per-merchant offers, for price and assortment monitoring.

Q: How many merchants come back per product?
Several — the headphone capture returned the same model priced across Sony, Best Buy, Walmart, Target, and more in one offers array, each with its own availability and delivery note.

Q: Can I run this across countries?
Yes. Pass a different country per call; the answer, the products, and the prices all localize, so each market is its own dataset.