# AI Brand Mention Checker: ChatGPT & Gemini, Otterly Alternative (`nebulacolors/ai-visibility`) Actor

Returns, for each question you give, the full answers of ChatGPT and Gemini (live web search), whether each names your brand, its position against your competitors, the links cited, and a share-of-voice summary per engine. $0.05 per answer. No API keys needed.

- **URL**: https://apify.com/nebulacolors/ai-visibility.md
- **Developed by:** [Nebula Colors LLC](https://apify.com/nebulacolors) (community)
- **Categories:** AI, SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 answer checkeds

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 Brand Mention Checker: ChatGPT & Gemini, Otterly Alternative

Find out if ChatGPT and Gemini recommend your brand. Otterly.AI and Peec AI track this for a monthly fee; here you pay per answer: $0.05 per answer, no API keys.

### AI visibility use cases

- See if ChatGPT and Gemini name you or a competitor when a buyer asks "what's the best ..." in your category.
- Find the pages the AI cites, so you know which review sites and lists to get onto.
- Ask the same questions every week and watch your share of voice move.
- Show a client where they stand in AI search before and after your GEO work.

### How the AI brand mention check works

Check if ChatGPT and Gemini mention or cite your brand. You get the full live answer, your brand's position, the competitors named, the links cited and your share of voice, for $0.05 per engine answer. It's ready for AI agents through Apify's MCP server.

You give it your brand and the questions your buyers ask. It asks each question to each AI assistant with live web search turned on, the same way a buyer would, and then reads every answer for you:

- Did the answer name your brand?
- Where did your brand come in the list of brands you track (1st, 2nd, ...)?
- Which of your competitors were named?
- Which links did the answer cite, and was one of them on your website?

At the end you get one summary row per engine with your mention rate, average position and share of voice.

Through the API, leaving out `engines` asks both; the form starts with Gemini ticked, so tick ChatGPT too for both. Perplexity and Claude are coming. Every answer is kept in full as the engine returns it. One run returns everything in one dataset. The engines are asked side by side, up to 5 answers each at once. In our tests one answer took 5 to 6 seconds on Gemini and 10 to 19 seconds on ChatGPT.

### Input

| Field | What to put |
|---|---|
| Brand | Your brand name, like `Notion`. Required. |
| Your website | Optional, like `notion.com`. Each answer says whether a cited link is on it. |
| Other names for the brand | Optional. Other spellings or product names that count as your brand, like `Notion AI`. |
| Competitors | Optional. The brands you compare against. They set your position and share of voice. Other names only work for your own brand, so list a competitor's other product name as its own competitor. |
| Questions | The questions your buyers ask, one per line. Required unless you fill in Category. |
| Category | Optional. If you leave Questions empty, give a category like `note-taking apps` and the Actor uses 5 standard buyer questions for it, like "What are the best note-taking apps?" |
| Engines | `chatgpt`, `gemini` or both. Both when left out (the form starts with Gemini). |

Example:

```json
{
  "brand": "Notion",
  "domain": "notion.com",
  "competitors": ["Obsidian", "Evernote", "Coda", "ClickUp"],
  "questions": [
    "What is the best note-taking app for a small team?",
    "Which app should a startup use for its internal wiki?"
  ],
  "engines": ["chatgpt", "gemini"]
}
```

### Output

One row per question and engine (this one is from a real test run, trimmed):

```json
{
  "type": "answer",
  "engine": "chatgpt",
  "model": "gpt-6-luna",
  "question": "What is the best note-taking app for a small team?",
  "answer": "**My pick: Notion** for a small team that wants a shared home for meeting notes, decisions ...",
  "brandMentioned": true,
  "brandPosition": 1,
  "brandsNamedInOrder": ["Notion"],
  "competitorsMentioned": [],
  "domainCited": true,
  "citedUrls": ["https://www.notion.com/help/intro-to-teamspaces", "https://workspace.google.com/intl/en_us/products/docs/"],
  "sourceUrls": ["..."],
  "searches": 2,
  "checkedAt": "2026-10-14T17:12:41.615Z"
}
```

- `citedUrls` are the links the answer itself cites. `sourceUrls` are all the pages the engine read, which is often more.
- If an engine fails after several retries, its row has an `error` field instead of an answer, and you are not charged for it.

Then one summary row (also saved as `SUMMARY` in the run's key-value store). This one is from the same test, 3 questions on ChatGPT and Gemini:

```json
{
  "type": "summary",
  "brand": "Notion",
  "overall": { "answersChecked": 6, "answersFailed": 0, "answersNamingBrand": 6, "mentionRate": 1, "averagePosition": 1, "answersCitingDomain": 3, "shareOfVoice": 0.75 },
  "byEngine": { "chatgpt": { "...": "same fields" }, "gemini": { "...": "same fields" } }
}
```

Each summary block also has `mentionsByBrand` and `shareOfVoiceByBrand` for you and every competitor.

### How the brand check works

- A brand counts when its name or one of its other names appears as a whole word, in any capitals, and not right after a hyphen. "Notion" matches "notion" but not "Notional", and "Slip-On" is not the brand On.
- Names of 4 letters or fewer, like "On" or "Kit", are also everyday words. They match only as you typed them or in all capitals ("Hoka" or "HOKA").
- A brand that only appears inside a link's address doesn't count. The link text does.
- Position is your place among the brands you listed (yours and your competitors), in the order the answer first names them. Brands you didn't list aren't counted.
- Share of voice: each answer gives one point to every tracked brand it names. Your share is your points divided by all the points.

### Price

$0.05 per answer checked, which is one question on one engine. Failed answers are free.

- 5 questions on all 4 engines = 20 answers = $1.00.
- 1 question on 1 engine = $0.05.

You don't need any API keys. The Actor uses its own.

### Engines

| Engine | Model | Search |
|---|---|---|
| ChatGPT | OpenAI `gpt-6-luna` | OpenAI web search |
| Gemini | Google `gemini-3.5-flash-lite` | Grounding with Google Search |

Each answer row names the model that answered and the time.

### Good to know

- These are live answers from each company's API with web search on, using the models in the table and up to 2 searches per answer on ChatGPT. The consumer apps can use other models, search more, remember the user or know where they are, so treat this as a consistent benchmark rather than an exact copy of what one person sees.
- You can set a maximum charge for a run. The Actor stops asking when it's reached and keeps the answers it already has.
- AI answers change from run to run. Use several questions and run on a schedule to see a trend, rather than reading much into one answer.
- Questions are asked as written, with no country or language setting. The engines see the request coming from Apify's servers.

### Use it from an AI agent

The Actor works through Apify's MCP server like any Store Actor. An agent can search for it, read its input and call it. The MCP call waits up to 45 seconds. A small run is often done by then. If it isn't, the call returns the run's status and dataset ID, and the agent reads the rows with `get-dataset-items`.

### FAQ

**Does ChatGPT mention my brand?** Put in your brand and the questions your buyers ask. You get each answer in full, whether your brand is named, its position and the competitors named.

**How is this different from Otterly or Peec AI?** No monthly plan. You pay $0.05 per answer, so a 20-question check on both engines costs $2.

**Why do the answers change between runs?** ChatGPT and Gemini search the web live, so answers vary. Ask the same questions every week and watch the trend, not one run.

**Do I need an OpenAI or Google API key?** No. The price per answer covers it.

### More tools from us

- [Google Ads Transparency Scraper](https://apify.com/nebulacolors/google-ads-transparency): every Google, YouTube and Display ad a competitor runs.
- [Website to Markdown Crawler](https://apify.com/nebulacolors/website-content-markdown): a whole site as clean Markdown for LLMs and RAG.
- [Website Screenshot](https://apify.com/nebulacolors/website-screenshot): full page or mobile screenshots of any URL, PNG or JPEG.
- [News & Blog Article Extractor](https://apify.com/nebulacolors/article-extractor): the newest articles from a site or RSS feed, as Markdown.
- [Image Downloader](https://apify.com/nebulacolors/image-downloader): every image on a page, full size, in one ZIP.

### Questions or problems

Open an issue on this Actor's Issues tab. I read them.

Also known as: AI brand monitor, AI search visibility, GEO / AEO tracking, ChatGPT brand mentions, LLM citation tracking.

# Actor input Schema

## `brand` (type: `string`):

The brand name to look for in the answers, as people write it.

## `domain` (type: `string`):

Optional. Your website, like example.com. Each answer then says whether a cited link is on it.

## `aliases` (type: `array`):

Optional. Other names that count as your brand, like a product name or another spelling.

## `competitors` (type: `array`):

Optional. Competitor brand names. They set your position (1st, 2nd...) and share of voice. Names of 4 letters or fewer match only as written or in capitals.

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

The questions buyers ask, one per item. Each is asked once on each engine, and each answer costs one event. Give these or a category.

## `category` (type: `string`):

Used only when Questions is empty: a product category, like "note-taking apps", to write 5 buyer questions from.

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

Which assistants to ask: chatgpt, gemini or both. The form starts with Gemini; leave it empty (or call the API without it) to ask both. Each answer is one charged event.

## Actor input object example

```json
{
  "brand": "Notion",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda"
  ],
  "questions": [
    "What is the best note-taking app for a small team?"
  ],
  "engines": [
    "gemini"
  ]
}
```

# Actor output Schema

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

All rows as JSON. Rows with type 'answer' hold each engine's full answer, whether the brand was named, its position, the competitors named and the cited links. The last row has type 'summary'.

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

The summary alone: per engine and overall, the share of answers naming the brand, its average position and its share of voice against the competitors.

# 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 = {
    "brand": "Notion",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda"
    ],
    "questions": [
        "What is the best note-taking app for a small team?"
    ],
    "engines": [
        "gemini"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nebulacolors/ai-visibility").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 = {
    "brand": "Notion",
    "competitors": [
        "Obsidian",
        "Evernote",
        "Coda",
    ],
    "questions": ["What is the best note-taking app for a small team?"],
    "engines": ["gemini"],
}

# Run the Actor and wait for it to finish
run = client.actor("nebulacolors/ai-visibility").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 '{
  "brand": "Notion",
  "competitors": [
    "Obsidian",
    "Evernote",
    "Coda"
  ],
  "questions": [
    "What is the best note-taking app for a small team?"
  ],
  "engines": [
    "gemini"
  ]
}' |
apify call nebulacolors/ai-visibility --silent --output-dataset

```

## MCP server setup

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

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/u7Lipk7L1bLD8dDKT/builds/lOZDJzaaeAsD4Sbja/openapi.json