# AI Shopping Tracker: Products ChatGPT & AI Recommend (`zaiq/ai-shopping-tracker`) Actor

Which products, brands and shops ChatGPT, Perplexity, Gemini, Claude, Grok and Google's AI Overview recommend when shoppers ask what to buy, in order, with prices and reasons, and whether yours are among them.

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

## Pricing

from $96.00 / 1,000 shopping answers

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 Tracker: which products ChatGPT, Perplexity, Gemini and Google's AI recommend

Shoppers now ask AI assistants what to buy. This Actor asks **ChatGPT (OpenAI GPT with web search), Perplexity, Google Gemini, Claude, Grok and Google's AI Overview** your **shopping questions** ("best robot vacuum for pet hair", "running shoes under $120 for beginners") and reads each answer into a **ranked product list**: **product, brand, price, shop and the reason given**, in the order the assistant recommends them. It shows **whether your brands are recommended, and at what rank**, which **competitors** win, and which **shops and review sites** the assistants cite.

Built for **e-commerce brands**, **Amazon and DTC sellers**, **retail and category managers**, **agencies doing AI search (GEO) work** and **affiliate sites** who need to know if AI shopping answers send buyers to them or to someone else, question by question and engine by engine.

### What you get

| Field | What it holds |
|---|---|
| Answer rows | `question`, `engine`, `model`, `country`, `status`, `answer`, `products` (rank, product, brand, price, currency, store, reason), `productsCount`, `citations`, `shopsCited`, `aiCostUsd` |
| Your brands | `yourBrands`: recommended or not, best rank, which of your products, named in the text, your site cited |
| Competitors | `otherBrands`: every other brand recommended, its best rank and products |
| SUMMARY | your brands' share of answers and average rank; the top brands and products across all answers; top brands per engine; total AI usage |

### What people use it for

- **AI shelf share:** how often each brand is recommended across the questions shoppers ask, and how high
- **Competitor tracking:** which rivals ChatGPT and Gemini put first for your category, week by week
- **Product launches:** whether a new product shows up in AI answers after launch
- **Retail and affiliate:** which shops and review sites the assistants cite for each category
- **Pricing intelligence:** the prices AI assistants quote for the products they recommend
- **GEO reporting:** before-and-after evidence for AI search optimisation work

### How to use it

1. Enter **shopping questions** as shoppers ask them, and your **brands** (optional).
2. Pick the **AI engines** and the **shopper's country**.
3. Click **Start**. Schedule it weekly to track your AI shelf share.

### Input

| Field | Example | Notes |
|---|---|---|
| Shopping questions | `What is the best robot vacuum for pet hair?` | One per line |
| Your brands | `Brand \| brand.com` | Optional; matched in the products and the text |
| AI engines | ChatGPT, Perplexity, Gemini | Also Claude, Grok, Google AI Overview |
| Shopper's country | `US` | Answers and prices follow it where the engine allows |
| Language | `en` | For Google's AI Overview |
| Answer length cap / Answers at once | `2000` / `4` | Advanced |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "kind": "shopping-answer",
  "question": "What is the best robot vacuum for pet hair?",
  "engine": "openai",
  "model": "openai/gpt-6.1-sol",
  "country": "US",
  "status": "ok",
  "products": [
    {
      "rank": 1,
      "product": "Acme RoboClean S9",
      "brand": "Acme",
      "price": 499,
      "currency": "USD",
      "store": "Example Mart",
      "reason": "strongest suction and a tangle-free brush"
    },
    {
      "rank": 2,
      "product": "Sample Vac X2",
      "brand": "Sample",
      "price": 329,
      "currency": "USD",
      "store": null,
      "reason": "best value for shedding pets"
    }
  ],
  "productsCount": 6,
  "yourBrands": [
    {
      "brand": "Sample",
      "recommended": true,
      "bestRank": 2,
      "products": [
        "Sample Vac X2"
      ],
      "mentioned": true,
      "cited": false
    }
  ],
  "otherBrands": [
    {
      "brand": "Acme",
      "bestRank": 1,
      "products": [
        "Acme RoboClean S9"
      ]
    }
  ],
  "shopsCited": [
    "amazon.com"
  ],
  "aiCostUsd": 0.087
}
```

A record named `SUMMARY` in the run's key-value store says what each input returned, with any notes (for example an account that does not exist), what was charged and how much traffic the run used.

### Pricing

- **$0.12 per shopping answer**: one engine's answer to one question, read into products and matched to your brands
- **AI usage** for the assistants (and the product reading, with the newest Gemini Flash) is billed to your Apify account by Apify's own OpenRouter gateway at OpenRouter's rates; on 12 October 2026 an answer cost about $0.007 with Gemini, $0.03 with Perplexity, $0.05 with Claude and $0.09 with ChatGPT's model
- Failed calls are free, and so are questions Google answers without an AI Overview

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 10 questions on ChatGPT, Perplexity and Gemini | $3.60 + AI usage (about $1.25) |
| 25 category questions, 3 engines, every week for a month | $36 + AI usage |
| 1 question on all six engines | $0.72 + AI usage |

On Apify's Scale and Business plans the per-event prices are lower (Store discounts). Set **Maximum cost per run** and the Actor stops cleanly when it is reached: you never pay more than that.

### Tips

- Write questions the way shoppers ask them, with the budget and the use: "best running shoes under $120 for flat feet".
- AI answers vary from run to run: track the same questions every week and read the trend.
- Add your main competitors as brands too: their rows then show side by side with yours.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/ai-shopping-tracker").call(run_input={"questions": ["What is the best robot vacuum for pet hair?"], "engines": ["openai", "perplexity", "gemini"], "country": "US"})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/ai-shopping-tracker').call({"questions": ["What is the best robot vacuum for pet hair?"], "engines": ["openai", "perplexity", "gemini"], "country": "US"});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~ai-shopping-tracker/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"questions": ["What is the best robot vacuum for pet hair?"], "engines": ["openai", "perplexity", "gemini"], "country": "US"}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server (`https://mcp.apify.com`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "which robot vacuums ChatGPT, Perplexity and Gemini recommend for pet hair, and whether my brand is one of them". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- Answers are what each engine's API returns with web search at run time; the consumer apps can differ (personalisation, history, location).
- Products are read from the answer text by an AI model; check unusual rows against the answer, which is kept in every row.
- Google AI Mode is not included yet.

### Optional: weekly monitoring, competitor gaps and a report

Off by default and at no extra charge (no new events):

- **Project name** (`projectName`): keeps every run's results under that name and compares each run with the last one: mentions gained and lost per question and engine, citation-rate moves, cited sites gained and lost, and competitors that appeared (record `CHANGES`). Schedule the Actor weekly to follow the movement.
- **Report** (`includeReport`): a one-page `REPORT.html` with the visibility score and its formula, per-engine tables, competitor gaps (the questions where a competitor is named or cited and you are not, with the sites cited there) and a fix list drawn from the pages the engines cite.
- **Cited pages to read** (`maxCitedPages`, default 8): how many of the cited pages are read for the fix list.

### FAQ

**Do I need my own OpenAI or Perplexity key?**

No. The engines run through Apify's own OpenRouter gateway and the AI usage is billed to your Apify account.

**Which models are used?**

Each engine's newest model at run time (the run log and every row name it).

**Can I check another country?**

Yes: set the shopper's country; engines that accept a location use it.

**How are my brands matched?**

In the products' brand and name, in the answer text, and in the cited sites when you give a domain.

**Is the full answer kept?**

Yes: every row has the full answer next to the products read from it.

### Related Actors from Zaiq

- [ai-answer-tracker](https://apify.com/zaiq/ai-answer-tracker): your brand's visibility in AI answers for any question
- [amazon-product-scraper](https://apify.com/zaiq/amazon-product-scraper): the recommended products' prices and ratings on Amazon
- [walmart-scraper](https://apify.com/zaiq/walmart-scraper): the same products on Walmart

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: ai shopping tracker, chatgpt shopping, ai product recommendations, chatgpt product visibility, generative engine optimization ecommerce, ai shelf share, perplexity shopping, ai search visibility for brands.

# Actor input Schema

## `questions` (type: `array`):

What shoppers ask AI assistants, one per line: 'best robot vacuum for pet hair', 'running shoes under $120 for beginners'.

## `brands` (type: `array`):

Brands to look for in the recommendations, one per line: 'Brand' or 'Brand | brand.example'.

## `engines` (type: `array`):

Each engine's newest model is used.

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

Two-letter country code: answers and prices follow it where the engine allows.

## `language` (type: `string`):

Optional, e.g. en, de.

## `maxAnswerTokens` (type: `integer`):

Tokens per answer.

## `maxConcurrency` (type: `integer`):

Answers asked in parallel.

## `includeReport` (type: `boolean`):

Opt in to REPORT.html, competitor gaps and evidence-based recommendations. No extra event or model call. The first tracked brand is the subject; remaining brands are competitors. Public cited pages may be read directly.

## `projectName` (type: `string`):

Opt in to reports and persistent run history in a named key-value store. Reuse exactly the same project name for comparisons; schedule runs sequentially. Failed or incomparable answers do not become losses.

## `maxCitedPages` (type: `integer`):

Maximum public cited pages read for recommendations when reporting is enabled. Zero uses citation URLs only and labels coverage unknown. No proxy or AI calls are used.

## Actor input object example

```json
{
  "questions": [
    "What is the best robot vacuum for pet hair?"
  ],
  "engines": [
    "openai",
    "perplexity",
    "gemini"
  ],
  "country": "US",
  "maxAnswerTokens": 2000,
  "maxConcurrency": 4,
  "includeReport": false,
  "maxCitedPages": 8
}
```

# Actor output Schema

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

Dataset: one row per question x engine.

## `summary` (type: `string`):

Share of answers and average rank per brand and product.

## `report` (type: `string`):

Opt-in HTML report. Available only when Create visibility report or a monitoring project is set.

## `reportData` (type: `string`):

Opt-in report data: score, coverage, gaps, recommendations and evidence.

## `changes` (type: `string`):

Opt-in project comparison. First run establishes a baseline.

# 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 = {
    "questions": [
        "What is the best robot vacuum for pet hair?"
    ],
    "engines": [
        "openai",
        "perplexity",
        "gemini"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/ai-shopping-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 = {
    "questions": ["What is the best robot vacuum for pet hair?"],
    "engines": [
        "openai",
        "perplexity",
        "gemini",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("zaiq/ai-shopping-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 '{
  "questions": [
    "What is the best robot vacuum for pet hair?"
  ],
  "engines": [
    "openai",
    "perplexity",
    "gemini"
  ]
}' |
apify call zaiq/ai-shopping-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zaiq/ai-shopping-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/fv6A1lIgJa4kGtUzu/builds/mEJsYx24tvPw0oYov/openapi.json