# ChatGPT Ads Scraper (`gytelio1/chatgpt-ads-scraper`) Actor

ChatGPT Ads Scraper collects the sponsored ads ChatGPT shows under answers to shopping questions: advertiser, product, price, rating, image and landing page. Use it to see which brands advertise on your topics, check your own ads appear, or track ChatGPT ads over time.

- **URL**: https://apify.com/gytelio1/chatgpt-ads-scraper.md
- **Developed by:** [Gytis Ščipokas](https://apify.com/gytelio1) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $25.00 / 1,000 ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does ChatGPT Ads Scraper do?

ChatGPT Ads Scraper collects the sponsored ads ChatGPT shows under its answers. Use it as your own ChatGPT ad library and ChatGPT ads tracker: spy on ChatGPT ads from any brand or topic, and pay per run instead of a monthly subscription.

![A sponsored Nike ad under a ChatGPT answer](https://api.apify.com/v2/key-value-stores/VBmEWJyHowK8Wz8i8/records/chatgpt-ad-example-nike.png)

### Use cases

- **Competitor monitoring.** See which brands advertise for your keywords, which products they push, and at what price.
- **Market research before buying ads.** Find out how crowded a category is before you spend on ChatGPT ads.
- **Ad verification.** Check that your own ads show up, for which questions, and with the right details.
- **Trend tracking.** Schedule daily runs over the same questions and build a history of the ChatGPT ad market.
- **Ad creative research.** Collect the headlines, ad copy, images, and prices competitors use, to inspire your own ChatGPT ads.
- **Agency reporting.** Show clients who advertises in their category on ChatGPT, and pitch ChatGPT ads with real examples.

### How to use it

1. Open the **Input** tab.
2. Add shopping questions to **Questions**.
3. Click **Start**.
4. Open the **Output** tab when the run finishes.

### Input

| Field | Description |
|---|---|
| `queries` | Questions to ask ChatGPT. Every ad shown in the chat is saved. Name a brand or model ("best Nike running shoes", "Nike Pegasus 42") to steer the chat toward it. |
| `chatsPerItem` | How many chats each question gets. Default 24. More chats, more ads. A run costs about $0.045 × questions × chats, plus ads. |
| `followUpQueries` | Questions sent in order after every question, so keep them general, like "Which one should I buy?". Stay on the same topic and ask about buying: a new topic brings ads that get counted under your question. ChatGPT doesn't show ads on the first message, so these keep the chat going. Up to 8. Defaults to four buying questions, also used when left empty. |
| `country` | Two-letter country code, like US, GB, or DE. Chats run from this country, so you see the ads shown there. Default US, where ChatGPT shows the most ads. Write your questions in English: follow-ups are in English too, whatever the country. |
| `saveScreenshots` | Saves proof of each ad: a screenshot with the end of ChatGPT's answer above it, and the ad's HTML with all the data ChatGPT sent. Linked from `screenshotUrl` and `htmlUrl`. Default off. Adds a few seconds per ad, no extra charge. |

#### See which brands advertise for a topic

```json
{
    "queries": ["best running shoes", "best trail running shoes"]
}
```

#### Find ads from one brand or model

Name the brand or model in your questions. ChatGPT answers about it, and the follow-ups ask about buying it. Ads from all advertisers are saved, so filter the results by `advertiser`.

```json
{
    "queries": ["best Nike running shoes", "Nike Men's Pegasus 42"]
}
```

#### Experimental: generated follow-ups

Turn on **Generate follow-ups** (`generateFollowUps`) and AI writes each follow-up from ChatGPT's last answer instead of using **Follow-up questions**. We're still testing whether it finds more ads. Every chat then sends different messages, so leave it off to compare brands across runs. The AI calls go through [OpenRouter](https://apify.com/apify/openrouter), a fraction of a cent per chat, billed to your Apify account separately.

### Output example

You get one dataset item per ad:

```json
{
    "query": "best running shoes",
    "turn": 3,
    "message": "Where can I buy it at the best price?",
    "country": "US",
    "advertiser": "Nike Inc.",
    "brand": "Nike Inc.",
    "title": "Nike Men's Run Swift 3 Road Running Shoes in Grey, Size: 8",
    "body": "No matter the run, the Swift 3 helps you get out the door...",
    "price": 85,
    "currency": "USD",
    "priceText": "$85",
    "rating": 4.7,
    "imageUrl": "https://files.openai.com/content?id=file_...",
    "url": "https://www.nike.com/t/run-swift-3-mens-road-running-shoes-SBE3UoK3/IB3972-021?...",
    "format": "product_card_v2",
    "displayType": "single_advertiser_ad_unit",
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/.../records/ad-...-3-0.png",
    "htmlUrl": "https://api.apify.com/v2/key-value-stores/.../records/ad-...-3-0.html",
    "scrapedAt": "2026-10-02T17:39:41.221Z"
}
```

`turn` and `message` tell you which follow-up triggered the ad. `screenshotUrl` and `htmlUrl` are `null` unless **Save ad proof** is on.

You can download the dataset as JSON, CSV, Excel, or HTML, or get it through the Apify API.

#### Summary and chats

Chats without ads aren't in the dataset, so two more records in the **Output** tab show what happened:

- **Summary:** for each question, the chats run, `adRate` (share of chats that showed at least one ad), ads found, and advertisers by ad count. Use `adRate` to compare questions.
- **Chats:** one line per chat attempt, with how it ended:

| Status | Meaning |
|---|---|
| `done` | Ran all its follow-ups. |
| `no-ads` | No ad by turn 3, so it was stopped. The first time, it runs again in a new browser, charged once. |
| `blocked` | ChatGPT didn't load. Retried, not charged. |
| `failed` | Broke mid-chat. Retried, not charged. |
| `cut` | Stopped because the run timeout was near. |
| `skipped` | Its question had no ads in 8 chats, so it didn't run. Not charged. |

So "10 chats, 0 ads" and "blocked 10 times" no longer look the same.

### Tips

- **Pick topics advertisers pay for.** The topic matters more than the wording. Products like video games, toys, books, shoes, and electronics get the most ads. ChatGPT shows no ads on health, mental health, or politics, and few on relationships or news.
- **Ask shopping questions.** "Best X" and "X under $100" work well.
- **Expect empty results.** Many chats show no ad, and the same question can return different ads on each run. For reliable data, run the same questions repeatedly, e.g. on a daily schedule.
- **Give it memory.** More memory runs more chats at once. With the default 16 GB, a single question with the default 24 chats finishes in under 10 minutes. Add memory for more questions, but leave at least 1 GB of your account's memory limit free, or the run may find fewer ads.

### Limitations

- **Most ads are in the US.** ChatGPT ads launched in the US. Other countries can be picked with Country, but may return few or no ads.
- **Logged-out view.** You see the ads ChatGPT shows to anonymous visitors. Logged-in users may see different ads.
- **Speed.** Each chat takes about 2 minutes.

### Pricing

Pay per run, no monthly subscription. Two things are charged:

| Event | Price |
|---|---|
| Chat | $0.045 for each chat with ChatGPT, with or without ads |
| Ad | $0.025 for each ad saved to the dataset |

Platform usage and residential proxies are included. You don't pay extra for:

- **Retries.** A chat that gets blocked or shows no ads is run again in a new browser, charged once.
- **Topics with no ads.** A question with no ads in 8 chats stops early, and its other chats aren't charged.

Example: one question with the default 24 chats costs $1.08 for the chats, plus $0.025 per ad. Shopping topics often get 2 to 3 ads per chat, so about $2.30 to $2.90 in total. Set **Maximum cost per run** to cap it. The run stops there and keeps everything found.

# Actor input Schema

## `queries` (type: `array`):

See which brands advertise for these questions. Name a brand or model, like "best Nike running shoes" or "Nike Pegasus 42", to steer the chat toward it. Product topics like gaming, toys, shoes, and electronics get the most ads. Health and politics get none.

## `chatsPerItem` (type: `integer`):

How many chats each question gets. More chats, more ads. Each chat costs $0.045, so a run costs about $0.045 × questions × chats, plus ads. About 2 minutes each, and more memory runs more chats at once.

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

Two-letter country code, like US, GB, or DE. Chats run from this country, so you see the ads shown there. ChatGPT shows the most ads in the US. Write your questions in English: follow-ups are in English too, whatever the country.

## `saveScreenshots` (type: `boolean`):

Save a screenshot of each ad with the end of ChatGPT's answer above it, and the ad's HTML with all the data ChatGPT sent. Proof the ad was shown and what it was shown under. Linked from screenshotUrl and htmlUrl in the results. Adds a few seconds per ad, no extra charge.

## `followUpQueries` (type: `array`):

Sent in order after every question, so keep them general, like "Which one should I buy?". Stay on the same topic and ask about buying: a new topic brings ads that get counted under your question. ChatGPT doesn't show ads on the first message, so follow-ups about buying keep the chat going until one shows. Up to 8. Ignored when Generate follow-ups is on.

## `generateFollowUps` (type: `boolean`):

AI writes each follow-up from ChatGPT's last answer, naming the products it just brought up and staying on your question. Leave off to compare brands: every chat sends the same Follow-up questions, so counts are comparable. Replaces Follow-up questions.

## Actor input object example

```json
{
  "queries": [
    "best running shoes"
  ],
  "chatsPerItem": 24,
  "country": "US",
  "saveScreenshots": false,
  "followUpQueries": [
    "Which one would you recommend buying?",
    "Where can I buy it at the best price?",
    "Are there any deals or discounts right now?",
    "What are some cheaper alternatives?"
  ],
  "generateFollowUps": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped ads

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

Chats run, ad rate, ads found, and advertisers for each question. Explains a run with no ads.

## `chats` (type: `string`):

One line per chat: question, how it ended (done, no ads, blocked, failed, skipped), turns, and ads found.

# 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 = {
    "queries": [
        "best running shoes"
    ],
    "followUpQueries": [
        "Which one would you recommend buying?",
        "Where can I buy it at the best price?",
        "Are there any deals or discounts right now?",
        "What are some cheaper alternatives?"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gytelio1/chatgpt-ads-scraper").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 = {
    "queries": ["best running shoes"],
    "followUpQueries": [
        "Which one would you recommend buying?",
        "Where can I buy it at the best price?",
        "Are there any deals or discounts right now?",
        "What are some cheaper alternatives?",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("gytelio1/chatgpt-ads-scraper").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 '{
  "queries": [
    "best running shoes"
  ],
  "followUpQueries": [
    "Which one would you recommend buying?",
    "Where can I buy it at the best price?",
    "Are there any deals or discounts right now?",
    "What are some cheaper alternatives?"
  ]
}' |
apify call gytelio1/chatgpt-ads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gytelio1/chatgpt-ads-scraper"
        }
    }
}
```

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/l4pByVXR1SalO1TMG/builds/BnunoIthYbDdp1dDa/openapi.json