# LLM Brand Visibility Tracker (`zinin/llm-brand-visibility`) Actor

For each query that matters, check whether AI assistants recommend YOUR brand — and which competitors they cite instead. Grounded answers from Perplexity Sonar, GPT and Gemini with your own OpenRouter key. This is GEO: the SEO of the AI era.

- **URL**: https://apify.com/zinin/llm-brand-visibility.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $42.50 / 1,000 brand probes

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LLM Brand Visibility Tracker — Are You Cited by ChatGPT, Perplexity & Gemini?

When a buyer asks an AI assistant *"what's the best CRM software?"*, does it name **your**
brand — or your competitors instead? This Actor runs your exact question against real AI
models with live web search and reports whether your brand was mentioned, how high it
ranked among the names given, and who got recommended in your place. Billing is per
**query × model** row, not per query — see Pricing below before you set a budget.

### What you get

- For every **query × model** pair: **mentioned** (yes/no), **position** (how early among
  the brands the model named), and **competitorsCited** (who it recommended instead).
- A readable **snippet** of the model's actual answer, plus `promptTokens` /
  `completionTokens` so you can reconcile against your own LLM bill.
- **Billed per query × model row, not per query.** 10 queries checked against 2 models is
  **20 billed rows**, not 10 — see Pricing for the exact math.
- **Works out of the box — no API key needed.** LLM access is built in and covered by
  the per-row price. Grounded (real web-search) engines: `perplexity/sonar`,
  `openai/gpt-4o-mini:online`, `google/gemini-2.5-flash:online`. Prefer your own
  OpenRouter key? Pass it and the tokens bill to your account instead.
- Any language — set `lang`, the model answers natively.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export
  to JSON, CSV or Excel, or push results straight into your own pipeline.

### How to run it

1. Click **Try for free** — no card needed on the free plan.
2. Paste your brand into **Brand** and your questions into **Queries**. That's it — no
   API key needed. (Optionally pick other model IDs in **Models**, or add your own
   [OpenRouter key](https://openrouter.ai/keys) to pay for tokens directly.)
3. Press **Start**. Results appear in the dataset, one row per query × model pair — read
   them in the UI, pull them from the API, or push them onward with a webhook.

### Pricing

Pay-per-event: **$0.005 per run start + $0.05 per result row**. No monthly seat.

Each result row is one **query × model** pair, not one query — every model you add
multiplies the bill. 10 queries checked against 2 models is **20 billed rows**, not 10:
20 × $0.05 + $0.005 start = **$1.005** (about **$1.01**). 100 rows cost about **$5.01**;
1,000 rows about **$50.01**.

The per-row price **includes the LLM call** — by default the Actor runs on built-in
model access and you pay nothing beyond the row price. If you pass your own
`openrouterApiKey`, the LLM tokens bill to your OpenRouter account instead (at
OpenRouter's own price, nothing marked up), and the Actor's row price stays the same.

A row that fails — a bad response from the model, a timeout, an empty answer — is still
written to the dataset with the reason, and it is **not** charged.

### Input

| Field | Required | What it does |
|---|---|---|
| `brand` | yes | The brand, product or company to track. |
| `queries` | yes | The questions a real buyer would ask (e.g. "best CRM software"). Up to 20. |
| `models` | no | OpenRouter model IDs, grounded (web-search) ones: `perplexity/sonar`, `openai/gpt-4o-mini:online`, `google/gemini-2.5-flash:online`. Up to 5. Default `perplexity/sonar`. |
| `lang` | no | Answer language (e.g. `en`, `ru`, `tr`). Default `en`. |
| `openrouterApiKey` | no | Optional. Leave empty to use the built-in LLM access (included in the row price). Pass your own [OpenRouter key](https://openrouter.ai/keys) to have tokens billed to your account instead. |
| `maxConcurrency` | no | Parallel LLM calls, 1–10 (default 3). |

Every query is checked against every model. With the limits above, the most a single run
can produce is 20 queries × 5 models = **100 billed rows**.

```json
{
    "brand": "Notion",
    "queries": [
        "best note-taking app",
        "best project management tool for startups"
    ],
    "models": [
        "perplexity/sonar"
    ]
}
```

### Output

One row per query × model pair. This is a real row from a real run:

```json
{
    "brand": "Zzqfake Nonexistent Xyz Corp",
    "query": "best CRM software",
    "model": "perplexity/sonar",
    "lang": "en",
    "found": true,
    "mentioned": false,
    "position": null,
    "competitorsCited": [
        "Salesforce",
        "HubSpot CRM",
        "Zoho CRM",
        "Pipedrive",
        "Microsoft Dynamics 365"
    ],
    "snippet": "The **best CRM software** depends on your business size and needs, but the most broadly recommended options are **Salesforce**, **HubSpot CRM**, **Zoho CRM**, **Pipedrive**, and **Microsoft Dynamics 365**. If you want the safest default choice for most teams, **HubSpot CRM** is o",
    "promptTokens": 96,
    "completionTokens": 234,
    "summary": "perplexity/sonar on \"best CRM software\": Zzqfake Nonexistent Xyz Corp NOT mentioned; competitors: Salesforce, HubSpot CRM, Zoho CRM, Pipedrive, Microsoft Dynamics 365.",
    "checkedAt": "2026-07-26T13:27:30.617Z"
}
```

| Field | What it means |
|---|---|
| `mentioned` | Did the model name the brand in its answer |
| `position` | How early among the named brands (1 = first); `null` if not mentioned |
| `competitorsCited` | Other brands/products the model named instead |
| `snippet` | The first ~280 characters of the model's actual answer |
| `promptTokens` / `completionTokens` | Token usage for this call, straight from OpenRouter's own response — reconcile against your OpenRouter invoice |
| `found` | `false` means the call itself failed (bad response, timeout, empty answer); the row explains why and is not billed |

#### Related tools

Related tools for adjacent workflows in AI and search visibility.

| Actor | What it does |
|---|---|
| [AI Overview Citation Tracker](https://apify.com/zinin/ai-overview-tracker) | Pair it in the AI and search visibility workflow: For each query that matters, see which sources and domains AI assistants cite in their answer — grounded... |
| [AI Answer Change Alert](https://apify.com/zinin/ai-answer-change-alert) | Pair it in the AI and search visibility workflow: Track whether an AI assistant's answer to a query you care about changed since last time — new sources... |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Pair it in the AI and search visibility workflow: Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [Domain Health Checker](https://apify.com/zinin/domain-health-checker) | Pair it in the AI and search visibility workflow: Bulk-audit domains: DNS records, SSL certificate expiry, SPF & DMARC email authentication |
| [Social Preview Checker](https://apify.com/zinin/social-preview-checker) | Pair it in the AI and search visibility workflow: See exactly how your links look when shared on Telegram, WhatsApp, X, LinkedIn, Slack, Facebook & Discord |

### FAQ

**Do I need an API key?** No — it works out of the box, LLM access is built in and
covered by the row price. Passing your own OpenRouter key is optional: do it if you want
the tokens billed to your account at OpenRouter's own price, with your own rate limits.

**Which languages?** Any — set `lang` (e.g. `ru`, `tr`). Grounded models answer natively
in that language.

**Can an agent call it?** Yes — standard Apify Actor, callable from the Apify API, the
SDK, or the Apify MCP server.

**What this is NOT.** It does not audit your SEO, crawl your site, or guarantee future
rankings in AI answers. It answers one question per query × model pair — did the model
name your brand right now, in a live grounded answer — and shows its work.

Found a wrong result, or need a check we don't run? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

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

The brand, product or company you want to track in AI answers.

## `queries` (type: `array`):

The prompts a real user would ask (e.g. `best note-taking app`, `Notion alternatives`). Each query is run against EVERY model in `models` below, and you are charged per query × model pair, not per query — e.g. 10 queries × 2 models = 20 billed rows. With the limits on both fields, the maximum possible is 20 queries × 5 models = 100 rows.

## `models` (type: `array`):

OpenRouter model IDs to test. Grounded options: `perplexity/sonar`, `openai/gpt-4o-mini:online`, `google/gemini-2.0-flash-001:online`. Every model you add here multiplies the number of billed rows: rows = number of queries × number of models (see `queries`).

## `lang` (type: `string`):

Answer language (e.g. en, ru, tr).

## `openrouterApiKey` (type: `string`):

Your OpenRouter API key (https://openrouter.ai/keys). LLM token cost is billed to YOUR account; this Actor only orchestrates and scores. Optional to start the Actor: without it the run finishes cleanly and explains setup, and nothing is charged beyond the Actor start.

## `maxConcurrency` (type: `integer`):

Parallel LLM calls (kept low to respect rate limits).

## Actor input object example

```json
{
  "brand": "Notion",
  "queries": [
    "best note-taking app",
    "best project management tool for startups"
  ],
  "models": [
    "perplexity/sonar"
  ],
  "lang": "en",
  "maxConcurrency": 3
}
```

# Actor output Schema

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

API URL for the default dataset items produced by this run.

# 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",
    "queries": [
        "best note-taking app",
        "best project management tool for startups"
    ],
    "models": [
        "perplexity/sonar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/llm-brand-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",
    "queries": [
        "best note-taking app",
        "best project management tool for startups",
    ],
    "models": ["perplexity/sonar"],
}

# Run the Actor and wait for it to finish
run = client.actor("zinin/llm-brand-visibility").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
  "queries": [
    "best note-taking app",
    "best project management tool for startups"
  ],
  "models": [
    "perplexity/sonar"
  ]
}' |
apify call zinin/llm-brand-visibility --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/llm-brand-visibility",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/FI3U4xqfuYpfghP9c/builds/9cQ3KeDc0oYmg6z54/openapi.json
