# AI Answers Tracker: ChatGPT, Perplexity, Gemini & AI Mode (`ensorcelling_melilot/ai-answers`) Actor

- **URL**: https://apify.com/ensorcelling_melilot/ai-answers.md
- **Developed by:** [ensorcelling \_melilot](https://apify.com/ensorcelling_melilot) (community)
- **Categories:** AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 ai answers

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

## AI Answers Tracker: ChatGPT, Perplexity, Gemini & AI Mode

Ask four AI assistants the same questions in one run and see what each one tells your customers:

- **The full answer** from ChatGPT, Perplexity, Gemini and Google AI Mode, as Markdown
- **The sources it cited**: title, URL and domain of every link in the answer
- **Brand tracking**: which of your brands and competitors were mentioned, how often, and which came first
- **Website tracking**: whether your own domains were among the cited sources
- **Fan-out queries**: the web searches ChatGPT ran to build its answer, when it shows them

Use it to track your brand's visibility in AI search (GEO / AEO), compare how each assistant ranks you against competitors, or collect AI answers for research. No API keys or ChatGPT accounts needed, and you pay only for answers returned.

### Input

| Field | What to put |
|---|---|
| **Prompts** | Questions the way a customer would ask them, one per line. Each goes to every engine you pick |
| **AI engines** | Any of ChatGPT, Perplexity, Gemini, Google AI Mode (all four by default) |
| **Brands to track** | Optional. Your brand and competitors, one per line |
| **Websites to track** | Optional. Your domains, e.g. `yourcompany.com` (subdomains count) |
| **Location / Language** | Country and language the answers are asked from. Used by ChatGPT, Gemini and Google AI Mode |

### Output

One row per prompt and engine:

| prompt | engine | brandsMentioned | firstBrandMentioned | domainsCited | sourceCount | answer |
|---|---|---|---|---|---|---|
| best project management tool for a small software team? | ChatGPT | Linear, Jira, Asana | Linear | linear.app | 7 | For a small software team, I'd start with **Linear**… |

Each row also has `sources` (title, URL, domain), `sourceDomains`, `brandMentionCounts`, `fanOutQueries`, `brandEntities` (brands ChatGPT itself highlighted), `model` and `checkUrl`. Download as CSV, Excel or JSON, or send it to Google Sheets with the *Google Sheets Import & Export (Reliable)* Actor as an integration.

### Pricing

Pay per answer. If an engine shows no answer for a prompt, or doesn't respond, the row is still in the output with a note and **is not charged**. The run stops cleanly at your *Maximum cost per run*.

### Where the answers come from

- **ChatGPT** and **Gemini**: the answer the public chat app gives, with web search, from the location you choose.
- **Google AI Mode**: the AI Mode answer on Google Search for your location and language.
- **Perplexity**: Perplexity's Sonar model with web search. Location and language don't apply to it.

Answers are collected through [DataForSEO](https://dataforseo.com/)'s AI Optimization and SERP APIs. AI answers change from run to run, so for tracking it's best to schedule the same prompts weekly and compare trends rather than single answers.

### FAQ

**How is a brand mention counted?** Whole words, case-insensitive, in the answer text. Links and image captions are ignored, so `linear.app` in a URL doesn't count as a mention of "Linear".

**Can I schedule it?** Yes. Use an Apify schedule to run the same prompts every week.

# Actor input Schema

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

One question per line, written the way a customer would ask an AI assistant. Each prompt is sent to every engine you pick.

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

Which assistants to ask. Leave all four for a full comparison; each engine's answer is one result.

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

Your brand and competitors, one per line. Each answer gets which of them were mentioned, how often, and which came first.

## `domains` (type: `array`):

Domains to look for among each answer's cited sources, e.g. yourcompany.com. Subdomains count.

## `locationName` (type: `string`):

Country in English, e.g. United States, United Kingdom, Germany. Used by ChatGPT, Gemini and Google AI Mode.

## `languageCode` (type: `string`):

Two-letter language code, e.g. en, de, fr, es. Used by ChatGPT, Gemini and Google AI Mode.

## Actor input object example

```json
{
  "prompts": [
    "What is the best project management tool for a small software team?"
  ],
  "engines": [
    "chatgpt",
    "perplexity",
    "gemini",
    "google_ai_mode"
  ],
  "brands": [
    "Linear",
    "Jira",
    "Asana"
  ],
  "locationName": "United States",
  "languageCode": "en"
}
```

# Actor output Schema

## `answers` (type: `string`):

One row per prompt and engine: the full answer, cited sources, and brand and website mentions.

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

How many answers were saved, how many prompts got no answer or failed, and whether the run stopped at your cost limit.

# 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 is the best project management tool for a small software team?"
    ],
    "brands": [
        "Linear",
        "Jira",
        "Asana"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ensorcelling_melilot/ai-answers").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 is the best project management tool for a small software team?"],
    "brands": [
        "Linear",
        "Jira",
        "Asana",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("ensorcelling_melilot/ai-answers").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 is the best project management tool for a small software team?"
  ],
  "brands": [
    "Linear",
    "Jira",
    "Asana"
  ]
}' |
apify call ensorcelling_melilot/ai-answers --silent --output-dataset

```

## MCP server setup

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

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/5tMZrPY4eCquQplfK/builds/v0QultbSFdFfFRiMY/openapi.json