# ChatGPT Search & Gemini Scraper: AI Answers, Sources, Brands (`quarra/chatgpt-gemini-scraper`) Actor

Ask ChatGPT and Gemini your questions and get the answers a user sees: full Markdown answer, cited sources, web results, brands mentioned with their rank, per country and language. Track your brand and competitors in AI answers (GEO / AI search visibility).

- **URL**: https://apify.com/quarra/chatgpt-gemini-scraper.md
- **Developed by:** [Quarra Labs](https://apify.com/quarra) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $104.00 / 1,000 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

## ChatGPT Search & Gemini Scraper: AI Answers, Sources & Brand Mentions (GEO)

Ask ChatGPT and Gemini your questions and get what a user sees: the full answer in Markdown, the sources it cites, the
web results behind it, and the brands it names, in order. Choose the country and the language. Give it your brand and
your competitors and each answer says whether they are mentioned, at which rank, and whether their site is cited. Built
for GEO / AI search visibility, SEO and marketing teams that track how AI engines talk about them.

**$130 per 1,000 answers** (one answer = one question on one engine), plus a small start fee per run. An answer that
cannot be delivered is never charged.

### Quick start

1. Type your **questions**, as a user would ask them.
2. Pick the **engines** (ChatGPT, Gemini or both), the **country** and the **language**.
3. Optionally add the **brands to track**, then click **Start** and read the answers in the **Output** tab.

It also runs from the Apify API, on a schedule, and connects to webhooks, Make, Zapier, n8n or Apify's MCP server.
Run the same questions every week to see how your visibility moves.

### What it is used for

- **Brand visibility in AI answers**: is your brand mentioned, at which rank, next to which competitors.
- **Source tracking**: which sites ChatGPT and Gemini cite for your topics, and whether yours is among them.
- **Content gaps**: the questions where you are absent and who is cited instead.
- **Market research**: how each engine answers in each country and language.

### What you get

| | |
|---|---|
| Full answer as Markdown | yes |
| Sources: title, link, domain | yes |
| Web results the engine looked at | ChatGPT |
| Related searches | when the engine gives them |
| Brands named in the answer, with rank | yes |
| Your tracked brands: mentioned, rank, position in the list, cited in sources, in web results | when you give brands |
| Model that answered, country, language, time | yes |

### Inputs

- **Questions**: up to 5,000 per run, repeats are asked once. Each question is asked once per engine.
- **Engines**: `chatgpt`, `gemini` or both (default).
- **Country**: a two-letter code (`US`, `GB`, `FR`...) or the name (`United Kingdom`, `UK`, `USA`...). Language: a
  code (`en`, `fr`, `de`, `pt-BR`, `zh-CN`, `zh-TW`...) or the name.
- **ChatGPT web search**: on by default, so answers carry sources like most users see.
- **Brands to track**: names, or objects with `name`, `aliases` and `domains`. Up to 100.
- **Speed**: Auto answers up to 40 answers one by one (about 20 seconds each, in parallel) and sends bigger lists as a batch.
  A batch needs about 9 minutes of run time left; with a shorter run timeout the questions are asked one by one instead.
  The default timeout (1 hour) fits big lists; a run that reaches its timeout stops cleanly and says how many were not asked.
- **Maximum answers** and Apify's **Maximum cost per run**: the run stops before going over either.

### Output

One record per question and engine. Main fields: `prompt`, `engine`, `country`, `language`, `answerMarkdown`,
`sources` (`title`, `url`, `domain`), `webResults`, `brandsMentioned` (`name`, `rank`, `category`),
`brandTracking` (`brand`, `mentioned`, `rank`, `listPosition`, `citedInSources`, `citedSourceUrls`), `scrapedAt`.
Questions that cannot be answered come as free `error` records with the reason and whether asking again may work. The
run summary (OUTPUT) gives counts per engine and, when you track brands, mention rate, average rank and citations per
brand and engine.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Answer delivered | $130 per 1,000 |
| Run start | $0.015 per run |

Higher Apify plans pay less per answer. Never charged: questions that fail, error records, repeats, notices.

### Limits

- **An answer is what the engine gives at that moment.** The same question can get a different answer an hour later;
  that is how these engines work.
- **Countries and languages**: ChatGPT is served in more than 190 countries and 128 languages, Gemini in 213 countries and 95
  languages. A combination an engine does not serve returns a free error record.
- **Gemini** gives sources but no web results or related searches.
- **Brands named by the engine** are the ones ChatGPT recognises and that appear in the text. Gemini does not give this
  list, so for Gemini `brandsMentioned` holds only your tracked brands: add the brands you care about.
- **Tracked brands** are found by name and aliases in the text. `mentions` counts them in the text you read: links,
  citation chips and images are not counted (a cited site shows in `citedInSources`).
- Questions are limited to 2,000 characters.

### FAQ

**Do I need a ChatGPT or Gemini account?** No.

**Is anything different on Apify's free plan?** Live answers need a paid Apify plan. On the free plan, the prefilled
example (the two questions, ChatGPT and Gemini, US, English, no other option) returns a stored sample, marked
`sample: true` with its date. Any other input asks nothing and says so in the run. Only the run start is charged.

**What if a run is restarted by the platform?** It resumes where it was: answers already delivered are not asked or charged again.

**Does the Actor send anything to Quarra?** Only when a run fails or runs out of time: the Actor, its build, the error type, the line of our code where it happened, and the memory and time the run was given, so we can fix it fast. Never your questions, your results, your account or the run ID.

# Actor input Schema

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

The questions to ask, exactly as a user would type them. Each question is asked once per engine.

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

Which engines answer: "chatgpt", "gemini" or both.

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

Two-letter country code (US, GB, FR, DE, CA, AU, IN...) or the country name. The answers are those a user in that country gets.

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

Language code of the answers (en, fr, de, es, pt-BR, zh-CN, zh-TW, ja...) or the language name.

## `webSearch` (type: `boolean`):

Force ChatGPT to search the web, so answers carry sources (what most users see). Gemini always uses its own search.

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

Optional. Brand names (or objects with name, aliases and domains). Each answer then says whether each brand is mentioned, its rank among all brands named, and whether its site is cited in the sources.

## `mode` (type: `string`):

auto: instant for up to 40 answers, a bigger batch otherwise (a few minutes). instant: always answer by answer. batch: always as one batch. A batch needs about 9 minutes of run time left; with less, questions are asked one by one.

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

Stop after this many delivered answers. Leave empty for no limit.

## Actor input object example

```json
{
  "prompts": [
    "best project management software for small teams",
    "what is the best CRM for startups?"
  ],
  "engines": [
    "chatgpt",
    "gemini"
  ],
  "country": "US",
  "language": "en",
  "webSearch": true,
  "brands": [],
  "mode": "auto"
}
```

# Actor output Schema

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

Every answer with its sources and brands, and free rows with the reason when a question could not be answered.

## `overview` (type: `string`):

One line per answer: engine, question, sources, brands.

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

Counts, brand visibility per engine, why the run stopped.

# 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": [
        "best project management software for small teams",
        "what is the best CRM for startups?"
    ],
    "engines": [
        "chatgpt",
        "gemini"
    ],
    "country": "US",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("quarra/chatgpt-gemini-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 = {
    "prompts": [
        "best project management software for small teams",
        "what is the best CRM for startups?",
    ],
    "engines": [
        "chatgpt",
        "gemini",
    ],
    "country": "US",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("quarra/chatgpt-gemini-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 '{
  "prompts": [
    "best project management software for small teams",
    "what is the best CRM for startups?"
  ],
  "engines": [
    "chatgpt",
    "gemini"
  ],
  "country": "US",
  "language": "en"
}' |
apify call quarra/chatgpt-gemini-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quarra/chatgpt-gemini-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/TaBaccQvnyHU1OibW/builds/yD5ZbpnjEzZVS4beW/openapi.json