# AI Visibility Tracker: Brand Mentions in Perplexity & Gemini (`quietsignals/ai-search-visibility-tracker`) Actor

Ask Perplexity and Google Gemini models the questions your buyers ask, with live web search on. See if your brand is named, before or after which competitors, and which websites each answer cites.

- **URL**: https://apify.com/quietsignals/ai-search-visibility-tracker.md
- **Developed by:** [Quiet Signals](https://apify.com/quietsignals) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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 Visibility Tracker: Brand Mentions in Perplexity & Gemini

People now ask AI assistants which company to hire or which product to buy. This tool asks those questions for you and tells you whether your brand is in the answers.

You give it a brand, a list of questions and, if you like, a list of competitors. It sends each question to Perplexity's and Google's AI models with live web search switched on, and returns one row per answer:

- whether the answer names your brand, and how many times
- whether your brand is named before or after each competitor
- which competitors the answer names
- which websites the answer cites as sources, and whether yours is one of them
- the full text of the answer, so you can check every figure yourself

A summary gives the share of answers that name your brand, cite your website and name each competitor, overall and per engine.

### How the answers are obtained

The questions go to each company's own model through its official programming interface, with that company's own web search: Perplexity Sonar, and Google Gemini with Google Search. Nothing is scraped and no website is automated.

This matters for how you read the results. **These are the answers the models give through their interfaces, not screenshots of the Perplexity or Gemini apps.** The apps add their own settings, your location and your history, so an answer you get by typing the same question into an app can differ.

Each question is sent exactly as you write it, with no instructions added, so the model answers it the way it would answer anyone.

### How the counting works

No AI is used to score the answers. A brand counts as named when its name appears in the answer as a whole word, in any letter case, with spaces and hyphens treated alike ("Roto-Rooter" also finds "Roto Rooter" and "RotoRooter"). Add other spellings in the input if your brand has them.

That makes every number checkable against the answer text. It also means the tool does not judge tone: an answer that warns people away from a brand still counts as naming it. Read the answers that matter.

### Input

| Field | What to enter |
| --- | --- |
| Brand name | The brand to look for |
| Questions | One per line, worded the way a buyer would ask |
| Competitors | Optional. Other brands to look for in the same answers |
| Other spellings of the brand | Optional. Short forms or former names that should count |
| Brand website | Optional, for example `example.com`. Used to tell whether an answer cites your site |
| Engines | Perplexity and Google Gemini by default |
| Answers per question | 1 to 5. See "Answers change" below |

### Output

One row per answer:

| Field | Meaning |
| --- | --- |
| `prompt` | The question |
| `engine`, `model` | Who answered: `perplexity` or `google`, and the exact model |
| `sample` | Which asking of the question this is, when you ask more than once |
| `brandMentioned` | True if the answer names the brand |
| `brandMentions` | How many times |
| `brandPosition` | Place among the brands you track, in order of first mention. 1 means your brand was named before every competitor. Empty if it was not named |
| `competitorsMentioned` | Competitors named, in order of first mention |
| `brandCited` | True if the answer cites a page on your website |
| `citedUrls`, `citedDomains` | The sources the answer cites |
| `answer` | The full answer |
| `checkedAt` | When the run started, UTC |

The run's key-value store holds a `SUMMARY` record with the shares per engine.

Example row, shortened:

```json
{
  "prompt": "Who are the best companies for emergency drain cleaning in the US?",
  "engine": "perplexity",
  "model": "perplexity/sonar",
  "brandMentioned": true,
  "brandMentions": 3,
  "brandPosition": 1,
  "competitorsMentioned": ["Mr. Rooter"],
  "brandCited": true,
  "citedDomains": ["dirjournal.com", "rooterhero.com", "modernize.com", "rotorooter.com"],
  "answer": "The best companies for emergency drain cleaning in the US are typically the national brands..."
}
```

### What it costs

There are two charges, and both appear on your Apify invoice.

1. **This tool's price per answer**, shown on this page. Answers that fail are not charged.
2. **Model usage**, billed by Apify's built-in model service at the model maker's price. In our test runs on November 16, 2026, a Perplexity answer cost about $0.006 and a Gemini answer $0.04 to $0.05 (Gemini runs several web searches per answer, and Google charges per search). Six answers, three from each, cost $0.16 in model usage. Your figures will vary with the question.

**On Apify's free plan, model usage is billed at ten times that rate.** That is Apify's rule for its model service, not ours: those six answers used $1.60 of free credit in our test. On the free plan, start with Perplexity only and one or two questions.

You need no account or key with Perplexity or Google.

### Answers change

Ask an AI model the same question twice and you can get two different answers, with different brands in them. One answer tells you what the model said once. To learn how often your brand is named, set "Answers per question" to 3 or 5 and read the share in the summary. Each extra answer is charged like any other.

To follow a brand over time, run the tool on an Apify Schedule with the same questions and compare the summaries.

### Limits

- **OpenAI is not available today.** The engine is in the list, but as of November 16, 2026 OpenAI refuses requests that come through Apify's model service. If you select it while that lasts, it is skipped, nothing is charged for it, and the other engines still run.
- Two engines by default, not the consumer apps, as explained above.
- Gemini's sources come as Google redirect links. `citedDomains` shows the real websites; `citedUrls` for Gemini holds the redirect links, which lead to the real pages.
- A model sometimes answers without searching the web. That row then has no sources. It happened in one of six answers in our test.
- Name matching is literal. A brand whose name is a common word ("Apple", "Target") will be counted when the word is used in its ordinary sense.
- No tone or sentiment scoring, no country setting, and no comparison with earlier runs yet.
- Answers are limited to about 1,500 tokens (roughly 1,000 words). A longer answer is cut off at that point.

### FAQ

**Is this the same as what I see in the Perplexity or Gemini app?**
Not exactly. It is the same company's model with the same company's web search, asked through its interface. The apps can answer differently.

**Why does my brand show up in one run and not the next?**
Because the models do not give the same answer every time. Use several answers per question and look at the share.

**Can I check a result by hand?**
Yes. Every row carries the full answer. Switch on "Save raw responses" to keep each model's complete response in the run's key-value store as well.

**Something is wrong or missing.**
Open an issue on this page's Issues tab.

# Actor input Schema

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

The brand to look for in the answers. Matched as a whole word, in any letter case; spaces and hyphens are treated alike.

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

One question per line, worded the way a buyer would ask an AI assistant. Each question is sent as it is, with no extra instructions. You get one answer per question, per engine.

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

Optional. Other brand names to look for in the same answers, one per line. They are reported in the order each answer first names them.

## `brandAliases` (type: `array`):

Optional. Other names that should count as the brand, such as a short form or a former name.

## `brandDomain` (type: `string`):

Optional, for example example.com. Used to tell whether an answer cites your own website as a source.

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

Which model makers to ask. Each one adds one answer per question. Model usage is billed by Apify on top of this Actor's price: a Perplexity answer costs well under a cent, a Gemini answer a few cents, and ten times that on the Apify free plan.

## `answersPerPrompt` (type: `integer`):

AI answers differ from one asking to the next. Ask each question more than once per engine to see how often the brand is named, not just whether it was named once. Each extra answer is charged like any other.

## `openaiModel` (type: `string`):

The OpenAI model to ask. It must support OpenAI's own web search.

## `perplexityModel` (type: `string`):

The Perplexity model to ask.

## `googleModel` (type: `string`):

The Gemini model to ask. It must support Google's own search grounding.

## `saveRawResponses` (type: `boolean`):

Also save each model's full response in the run's key-value store, for checking a result by hand.

## Actor input object example

```json
{
  "brand": "Roto-Rooter",
  "prompts": [
    "Who are the best companies for emergency drain cleaning in the US?"
  ],
  "competitors": [
    "Mr. Rooter",
    "Rooter-Man"
  ],
  "brandAliases": [],
  "brandDomain": "rotorooter.com",
  "engines": [
    "perplexity",
    "google"
  ],
  "answersPerPrompt": 1,
  "openaiModel": "openai/gpt-5.6-luna",
  "perplexityModel": "perplexity/sonar",
  "googleModel": "google/gemini-3.1-flash-lite",
  "saveRawResponses": false
}
```

# Actor output Schema

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

No description

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

No description

# 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": "Roto-Rooter",
    "prompts": [
        "Who are the best companies for emergency drain cleaning in the US?"
    ],
    "competitors": [
        "Mr. Rooter",
        "Rooter-Man"
    ],
    "brandDomain": "rotorooter.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietsignals/ai-search-visibility-tracker").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": "Roto-Rooter",
    "prompts": ["Who are the best companies for emergency drain cleaning in the US?"],
    "competitors": [
        "Mr. Rooter",
        "Rooter-Man",
    ],
    "brandDomain": "rotorooter.com",
}

# Run the Actor and wait for it to finish
run = client.actor("quietsignals/ai-search-visibility-tracker").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": "Roto-Rooter",
  "prompts": [
    "Who are the best companies for emergency drain cleaning in the US?"
  ],
  "competitors": [
    "Mr. Rooter",
    "Rooter-Man"
  ],
  "brandDomain": "rotorooter.com"
}' |
apify call quietsignals/ai-search-visibility-tracker --silent --output-dataset

```

## MCP server setup

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

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/2BJhqbPvL4wj4KcPH/builds/fgBDymEVd47WPpc9I/openapi.json
