# AI Shopping Results Tracker: Products, Shops & Your Brand Rank (`nerolabs/ai-shopping-results-tracker`) Actor

Asks shopping prompts to OpenAI with web search, ChatGPT-style, and returns products, prices, shops, links, cited sources and your brand's position. Inputs: prompts, datasetId, fileUrl, trackBrands. $0.05 per answer, only when it returns. Agent-ready: x402, MCP.

- **URL**: https://apify.com/nerolabs/ai-shopping-results-tracker.md
- **Developed by:** [Adam Pearce](https://apify.com/nerolabs) (community)
- **Categories:** SEO tools, AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 prompt answereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Shopping Results Tracker: Products, Shops & Your Brand Rank

**When a shopper asks an AI assistant "what's the best cordless vacuum for pet hair?", which products does it recommend, which shops does it send them to, and is your brand in the answer?** Give this Actor a list of shopping prompts and your brand or shop names. For every prompt you get the recommended products in order, their prices, the shops and links, the sources the answer cited, and where your brand, product, shop or website appears.

### How the answers are made (please read)

Every prompt is answered by **OpenAI's official API with OpenAI's own web search tool**, the same kind of live, search-backed answer ChatGPT gives. It is **not a copy of the chatgpt.com page or its product cards**: nothing is scraped from ChatGPT, and ChatGPT's own answer to the same words can differ (it also knows the user, their history and their location). Treat the results as a close, repeatable stand-in for how ChatGPT-style AI shopping answers see your market, not a screenshot of one person's ChatGPT.

AI answers also change from run to run. Use **Answers per prompt** (up to 5) to ask the same question several times and see how often your brand comes up, and **Monitor mode** to watch it over time.

Products, prices and shops are read out of each answer by a second model, then **every value is checked against the answer text in code**: a product name, price, link or shop that is not written in the answer (or its cited links) is dropped, so nothing invented reaches your data.

### What you get for every prompt

- **Products**: each recommended product in order, with `position`, `name`, `brand`, `price`, `currency`, the price as written, the shops it can be bought from (name, link, domain), its product link, and any review sites named for it.
- **Your brands**: for each name in **Brands or shops to look for**: `found`, `position` (the first product that is that brand, sold by that shop, or linked to that site), whether it appears as a **shop**, whether it is only **mentioned** in the text, and whether its site is **cited**.
- **Cited sources**: every page the answer cited (link, domain, title) and how many pages the search read.
- **The full answer text**, the shopper country, and a one-line summary such as `3 product(s) recommended, first: Dyson V15 Detect. Found: Dyson #1.`
- **Run summary**: brand share across all answers (found rate, average position, how often #1 and top 3), the products recommended most, the shops linked most, and the sites cited most.

Your own columns stay next to the results.

### Who uses this

- **Brands and shops** checking whether AI assistants recommend them, or their competitors, for the questions their buyers ask.
- **SEO and GEO agencies** reporting "AI shopping visibility" to clients, across many prompts and countries.
- **Marketplace sellers and affiliates** finding which shops and review sites AI answers send buyers to, so they know where to be listed.

### Input

Give prompts as a plain **list**, an **Apify dataset** (for example a keyword list), a **CSV or Google Sheet link** (shared as "anyone with the link can view"), or inline rows. The prompt column is detected automatically (prompt, query, question, keyword...), or set **Prompt field**.

- **Brands or shops to look for**: brand names (`Dyson`), shop names (`Argos`) or websites (`argos.co.uk`). A **Brand field** column can add names per row.
- **Shopper country**: a two-letter code (US, GB, DE, AU...) so search results, shops and currency fit that country. A row's own `country` column overrides it. Optional city and region.
- **Answer like a shopping assistant** (on by default): asks for several named products with prices and shops, like ChatGPT's shopping answers. Turn it off to send your prompt with no extra instruction.

Example (the default input):

```json
{
  "prompts": ["What are the best running shoes for flat feet?", "Best cordless vacuum for pet hair", "Which espresso machine under $500 should I buy?"],
  "trackBrands": ["Brooks", "Dyson", "Breville", "Amazon"]
}
```

### Output (one row per prompt answer)

```json
{
  "prompt": "Best cordless vacuum for pet hair",
  "country": "GB",
  "checkStatus": "ok",
  "summary": "3 product(s) recommended, first: Dyson V15 Detect Absolute. Found: Dyson #1.",
  "brandFound": true,
  "bestPosition": 1,
  "productNames": ["Dyson V15 Detect Absolute", "Shark PowerDetect Cordless", "Samsung Bespoke Jet"],
  "products": [
    { "position": 1, "name": "Dyson V15 Detect Absolute", "brand": "Dyson", "price": 479.99, "currency": "GBP", "priceText": "£479.99",
      "shops": [{ "name": "Dyson.co.uk", "url": "https://www.dyson.co.uk/vacuum-cleaners/cordless/v15", "domain": "dyson.co.uk" }] }
  ],
  "brandResults": [
    { "name": "Dyson", "found": true, "position": 1, "asShop": true, "mentionedInAnswer": true, "cited": true },
    { "name": "Amazon", "found": false, "position": null, "asShop": false, "mentionedInAnswer": false, "cited": false }
  ],
  "citedDomains": ["dyson.co.uk"],
  "monitorStatus": null
}
```

### Monitor mode: get told when it changes

Switch on **Monitor mode** and schedule the run (daily or weekly). The first run records each prompt's starting point. Later runs report what changed: your brand appearing, dropping out or moving position, and products newly recommended or no longer recommended. Set a **Webhook URL** (Slack, Zapier, Make, n8n) and it is only called when something changed. **Only changed answers** keeps just those rows. Different watchlists use different **Monitor names**.

### Pricing

Pay per event, no subscription:

- **$0.05 per prompt answered** (about $50 per 1,000 answers). Lower on higher Apify plans.
- $0.01 per CSV or Excel export file, only when you ask for one.
- $0.01 per webhook delivered (confirmed 2xx only; in monitor mode only when something changed).

You are **charged only when an answer comes back**. Failed answers, empty prompts, duplicates, and rows skipped because of a time or budget limit are free. The OpenAI and web search costs are included in the price; you need no OpenAI key. Tracking 50 prompts weekly is about $10 a month.

### Honest limits

- Answers come from OpenAI's API with web search, not from the chatgpt.com app, so they will not match one person's ChatGPT exactly, and they vary between runs. This is the nature of AI answers, not a fault: ask each prompt several times for a fair picture.
- An answer takes about 10 to 20 seconds. Three prompts run at once by default.
- Prices are the ones written in the answer, which come from the pages the search read. They can be out of date; always check the shop.
- The Actor sends only your prompt text and shopper location to OpenAI, with storage switched off.

### FAQ

**Is this ChatGPT Shopping data?** It is the same kind of answer from OpenAI's own models and search, made through OpenAI's official API, not taken from ChatGPT. It shows what OpenAI's search-backed answers recommend for your prompts.

**Can an AI agent call it?** Yes. Pay per event works through Apify's MCP server and x402, and the output is plain JSON.

**Something looks wrong for one prompt.** Open an issue on the Actor page with the prompt and I will look the same day.

If this saved you checking AI shopping answers by hand, a review on the Store helps a lot.

# Actor input Schema

## `prompts` (type: `array`):

The questions a shopper would ask an AI assistant, one per line, for example 'best running shoes for flat feet'. Each prompt is answered with OpenAI's web search and charged once when an answer comes back. Or use a dataset or file below.

## `trackBrands` (type: `array`):

Your brand, product, shop or website (and your competitors'), for example 'Dyson' or 'argos.co.uk'. Each row reports whether it appears, at what product position, as a shop, or as a cited source. Optional.

## `datasetId` (type: `string`):

An Apify dataset with one prompt per row, for example a keyword list. Every original column is kept and the AI shopping results are added alongside. Use the picker rather than typing an ID.

## `fileUrl` (type: `string`):

A public link to a CSV, TSV, Excel, JSON or JSON Lines file with one prompt per row. A normal Google Sheets link works: share it as 'Anyone with the link can view'. Used when no dataset is given.

## `fileFormat` (type: `string`):

Leave on 'Detect automatically' unless the link has no file extension and the server reports the wrong content type.

## `sheetName` (type: `string`):

Which sheet to read from an Excel workbook. Defaults to the first sheet.

## `data` (type: `array`):

Rows as inline JSON, an alternative to a dataset or file. Each object needs a field holding the prompt.

## `promptField` (type: `string`):

The column that holds the prompt. Leave empty to detect it (prompt, query, question, keyword and similar names).

## `brandField` (type: `string`):

Optional column holding brands or shops to look for on that row only (comma separated), added to the list above.

## `country` (type: `string`):

Two-letter country code the shopper is in (US, GB, DE, AU and so on), so search results, shops and currency fit that country. A row's own 'country' column overrides it. Default US.

## `city` (type: `string`):

Optional city for local results, for example 'London'.

## `region` (type: `string`):

Optional state or region, for example 'California'.

## `shoppingInstructions` (type: `boolean`):

On: the model is told to recommend named products with prices and shops, like ChatGPT's shopping answers. Off: the prompt is answered with no extra instruction (one web search).

## `answersPerPrompt` (type: `integer`):

AI answers vary. Ask each prompt up to 5 times to see how often your brand appears. Each answer is charged.

## `includeAnswerText` (type: `boolean`):

Keep the full written answer on each row.

## `monitor` (type: `boolean`):

Remember each prompt's result and report what changed since the last run (your brand appearing, dropping out or moving position, new products recommended). Run it on a schedule. The first run just records the starting point. Off by default.

## `monitorName` (type: `string`):

Names the saved memory for monitor mode, so different watchlists do not mix. Use the same name on every scheduled run of one watchlist. Default: 'default'.

## `keep` (type: `string`):

Filtering happens after each prompt is answered and charged. 'Only changed answers' is the monitor-mode alert list.

## `keepOriginalFields` (type: `boolean`):

Keep every column from the input row next to the results, so they line up with your own data.

## `concurrency` (type: `integer`):

How many prompts are answered in parallel.

## `maxItems` (type: `integer`):

A hard ceiling on how many rows are read from the input, as a safety net on a large dataset.

## `exportFormats` (type: `array`):

Also write the results as a downloadable CSV or Excel file, linked from the run's output. $0.01 per file, charged only when the run answered at least one prompt.

## `outputDatasetName` (type: `string`):

Also append every kept row to a named dataset that persists across runs, for example a history of checks. Not charged again.

## `webhookUrl` (type: `string`):

POST the run summary to this URL when the run finishes, for Slack, Zapier, Make, n8n or your own API. In monitor mode it is sent only when something changed. Charged $0.01 only on a confirmed 2xx response.

## Actor input object example

```json
{
  "prompts": [
    "What are the best running shoes for flat feet?",
    "Best cordless vacuum for pet hair",
    "Which espresso machine under $500 should I buy?"
  ],
  "trackBrands": [
    "Brooks",
    "Dyson",
    "Breville",
    "Amazon"
  ],
  "fileFormat": "auto",
  "country": "US",
  "shoppingInstructions": true,
  "answersPerPrompt": 1,
  "includeAnswerText": true,
  "monitor": false,
  "keep": "all",
  "keepOriginalFields": true,
  "concurrency": 3,
  "exportFormats": []
}
```

# Actor output Schema

## `results` (type: `string`):

One row per prompt answer: recommended products with prices and shops, cited sources, and whether each tracked brand or shop appears and at what position. Your original columns are kept.

## `runSummary` (type: `string`):

Prompts answered, brand share of answers, top products, shops and cited domains, monitor-mode changes, export links and warnings.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "prompts": [
        "What are the best running shoes for flat feet?",
        "Best cordless vacuum for pet hair",
        "Which espresso machine under $500 should I buy?"
    ],
    "trackBrands": [
        "Brooks",
        "Dyson",
        "Breville",
        "Amazon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nerolabs/ai-shopping-results-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "prompts": [
        "What are the best running shoes for flat feet?",
        "Best cordless vacuum for pet hair",
        "Which espresso machine under $500 should I buy?",
    ],
    "trackBrands": [
        "Brooks",
        "Dyson",
        "Breville",
        "Amazon",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("nerolabs/ai-shopping-results-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "prompts": [
    "What are the best running shoes for flat feet?",
    "Best cordless vacuum for pet hair",
    "Which espresso machine under $500 should I buy?"
  ],
  "trackBrands": [
    "Brooks",
    "Dyson",
    "Breville",
    "Amazon"
  ]
}' |
apify call nerolabs/ai-shopping-results-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nerolabs/ai-shopping-results-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/plrY1Xdd5Cg3IbqpH/builds/yb7TIbP3kRNf2Bzvu/openapi.json