# Multi-AI Answer Snapshot (`nerolabs/multi-ai-answer-snapshot`) Actor

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

## Pricing

from $25.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

## Multi-AI Answer Snapshot: OpenAI, Perplexity, Gemini & Claude

**Ask the same question to several AI assistants at once and see their answers side by side: what each one says, which websites it cites, and whether it mentions your brand or your competitors.** Give this Actor a list of prompts (the questions your buyers ask AI) and your brand names. For every prompt you get one row with each assistant's answer, its cited sources, and a per-brand view of who mentioned you, in what order, and who cited your site.

### Which assistants, and how (please read)

Every assistant is asked through its **official API, with its own live web search**:

| Assistant | Model | Search | Model cost |
|---|---|---|---|
| OpenAI (the models behind ChatGPT) | gpt-5.4-nano | OpenAI web search tool | **included** in the price |
| Perplexity | Sonar | Perplexity's own search | billed to your Apify account, about $0.005 an answer |
| Google Gemini | Gemini 3.1 Flash Lite | Google Search grounding | billed to your Apify account, about $0.03 to $0.04 an answer |
| Anthropic Claude | Claude Haiku 5.5 | Anthropic's web search | billed to your Apify account, about $0.013 to $0.025 an answer |
| xAI Grok | Grok 4.3 | xAI's web search | billed to your Apify account, about $0.04 to $0.05 an answer |

Perplexity, Gemini, Claude and Grok run through **Apify's own OpenRouter proxy** (`apify/openrouter`), so you need no API keys: Apify bills their model cost to your account at OpenRouter's rate. On Apify's **free plan that cost is 10 times higher** (Apify's rule for the proxy), so free-plan users should start with Perplexity and OpenAI. The run summary shows the model cost of every assistant.

These are the same models and live searches the consumer apps use, **not copies of the apps**: nothing is scraped from chatgpt.com, perplexity.ai or gemini.google.com, and an app's own answer to the same words can differ (it knows the user and their history). Answers also change between runs, which is why **Monitor mode** exists.

**Not included:** Microsoft Copilot and Meta AI have no public API for their assistant answers, so they cannot be asked legally and reliably. They are left out on purpose.

### What you get for every prompt

- **Each assistant's answer** (`openaiAnswer`, `perplexityAnswer`, `geminiAnswer`, `claudeAnswer`, `grokAnswer`) and its status.
- **Cited sources** per assistant: link, site and title, plus `allCitedDomains` across all of them. Gemini's Google redirect links are resolved to the real site name.
- **Your brands**: for every name in **Brands or websites to look for**, per assistant: `mentioned`, `rank` (order of first mention among your names, so "Asana before Trello"), number of mentions, and `cited` (its website is one of the sources). `mentionedBy` counts how many assistants mention each name; `brandVisibility` lists which ones.
- **Run summary**: mention rate per brand per assistant, average rank, how often each brand's site is cited, the most cited websites overall (where to get listed or reviewed), and model cost per assistant.

Mentions are found in code by exact whole-word matching ("Shark" does not match "Sharks"), never by asking a model to judge.

### Who uses this

- **Brands and marketing teams** checking whether AI assistants recommend them, or their competitors, for the questions their buyers ask.
- **SEO and GEO agencies** reporting AI visibility across assistants to clients, with a monitor that flags changes.
- **PR and content teams** finding which websites AI assistants cite most, to know where coverage counts.

### Input

Give prompts as a plain **list**, an **Apify dataset**, 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**.

- **AI assistants**: any of `openai`, `perplexity`, `gemini`, `claude`, `grok`. Default: OpenAI, Perplexity and Claude.
- **Brands or websites to look for**: brand names (`Asana`) or websites (`monday.com`). A **Brand field** column can add names per row.
- **User country**: optional two-letter code so answers and sources fit that country.

Example (the default input):

```json
{
  "prompts": ["What is the best project management software for a small team?", "Best cordless vacuum for pet hair"],
  "engines": ["openai", "perplexity", "claude"],
  "trackBrands": ["Asana", "Trello", "monday.com", "Dyson", "Shark"]
}
```

### Output (one row per prompt, shortened)

```json
{
  "prompt": "What is the best project management software for a small team?",
  "checkStatus": "ok",
  "summary": "3 of 3 assistant(s) answered. Mentioned: Asana by OpenAI, Perplexity, Claude; Trello by OpenAI, Perplexity, Claude; monday.com by OpenAI, Perplexity.",
  "enginesAnswered": ["openai", "perplexity", "claude"],
  "mentionedBy": { "Asana": 3, "Trello": 3, "monday.com": 2 },
  "openaiCitedDomains": ["zapier.com", "asana.com"],
  "perplexityBrandsMentioned": ["Asana", "Trello", "monday.com"],
  "answers": [
    { "engine": "perplexity", "model": "perplexity/sonar", "status": "ok", "citedDomains": ["pcmag.com", "asana.com", "zapier.com"],
      "brands": [{ "name": "Asana", "mentioned": true, "rank": 2, "mentions": 3, "cited": true }], "modelCostUsd": 0.00537, "modelCostPaidBy": "caller" }
  ]
}
```

### 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, per assistant, what changed: your brand newly mentioned or dropped, moved in order, your site newly cited or no longer cited, and newly cited websites. Set a **Webhook URL** (Slack, Zapier, Make, n8n) and it is only called when something changed. If one assistant fails on a run, its last result is kept, so an outage is not reported as a change.

### Pricing

Pay per event, no subscription:

- **$0.03 per prompt answered** (by any number of the chosen assistants). Lower on higher Apify plans. OpenAI's answer is included.
- $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).
- Plus the model cost of Perplexity, Gemini, Claude and Grok, billed by Apify's OpenRouter proxy (see the table above).

You are **charged only when at least one assistant answers**. Empty prompts, duplicates, prompts no assistant answered, and rows skipped because of a time or budget limit are free. Example: 100 prompts with the default three assistants on a paid plan is $3 here plus about $3 of Perplexity and Claude model cost.

### Honest limits

- Answers come from each company's API with web search, not from their consumer apps, so they will not match one person's app exactly, and they vary between runs.
- Grok is the slowest (about 25 to 30 seconds an answer); the others take 4 to 12 seconds. Two prompts run at once by default.
- `rank` is the order your tracked names first appear in the text, not a position in a product list.
- Only your prompt text and country are sent to each provider.

### FAQ

**Is this the same as asking ChatGPT, Perplexity or Gemini in their apps?** It uses the same companies' models and live searches through their official APIs, so it shows how those AI systems answer your prompts. It is not a screenshot of an app.

**Why no Copilot or Meta AI?** Neither offers a public API for its assistant answers. Getting them would mean scraping, which this Actor does not do.

**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 asking each AI assistant by hand, a review on the Store helps a lot.

# Actor input Schema

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

The questions people ask AI assistants, one per line, for example 'best project management software for a small team'. Each prompt is sent to every chosen assistant and charged once when at least one answers. Or use a dataset or file below.

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

Which assistants to ask, each with its own live web search. OpenAI's cost is included in the price. Perplexity, Gemini, Claude and Grok run through Apify's official OpenRouter proxy, and their model cost is billed to your Apify account at OpenRouter's rate (about $0.005 Perplexity, $0.013 Claude, $0.04 Gemini, $0.04 Grok per answer; 10x on Apify's free plan). Copilot and Meta AI have no public API.

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

Your brand, product or website and your competitors', for example 'Asana' or 'monday.com'. Each answer reports whether each name is mentioned, in what order, and whether its site is cited. 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 websites to look for on that row only (comma separated), added to the list above.

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

Optional two-letter country code (US, GB, DE...) so answers and sources fit that country. A row's own 'country' column overrides it.

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

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

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

Optional state or region, for example 'California'.

## `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, per assistant (your brand newly mentioned or dropped, moved in order, newly cited or no longer cited, new cited sites). Run it on a schedule. The first run 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.

## `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 asked in parallel (each goes to every chosen assistant at once).

## `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 is the best project management software for a small team?",
    "Best cordless vacuum for pet hair"
  ],
  "engines": [
    "openai",
    "perplexity",
    "claude"
  ],
  "trackBrands": [
    "Asana",
    "Trello",
    "monday.com",
    "Dyson",
    "Shark"
  ],
  "fileFormat": "auto",
  "includeAnswerText": true,
  "monitor": false,
  "keep": "all",
  "keepOriginalFields": true,
  "concurrency": 2,
  "exportFormats": []
}
```

# Actor output Schema

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

One row per prompt: each assistant's answer, cited sources and cited sites, and which assistants mention or cite each tracked brand. Your original columns are kept.

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

Prompts answered, per-assistant answer counts and model cost, brand mention rate per assistant, most cited sites, 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 is the best project management software for a small team?",
        "Best cordless vacuum for pet hair"
    ],
    "engines": [
        "openai",
        "perplexity",
        "claude"
    ],
    "trackBrands": [
        "Asana",
        "Trello",
        "monday.com",
        "Dyson",
        "Shark"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nerolabs/multi-ai-answer-snapshot").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 software for a small team?",
        "Best cordless vacuum for pet hair",
    ],
    "engines": [
        "openai",
        "perplexity",
        "claude",
    ],
    "trackBrands": [
        "Asana",
        "Trello",
        "monday.com",
        "Dyson",
        "Shark",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("nerolabs/multi-ai-answer-snapshot").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 software for a small team?",
    "Best cordless vacuum for pet hair"
  ],
  "engines": [
    "openai",
    "perplexity",
    "claude"
  ],
  "trackBrands": [
    "Asana",
    "Trello",
    "monday.com",
    "Dyson",
    "Shark"
  ]
}' |
apify call nerolabs/multi-ai-answer-snapshot --silent --output-dataset

```

## MCP server setup

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

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/5Nh4v77brtpcJ9Byi/builds/ZP2TggEfKqOlq09gJ/openapi.json