# AI Visibility Tester (`oseni03/ai-visibility-tester`) Actor

Measure your business visibility across AI search engines. Test whether ChatGPT and Perplexity mention, recommend, rank, and cite your business for real customer questions like "best dentist in Lagos". Generate structured AI visibility insights for AEO, SEO, and competitor research.

- **URL**: https://apify.com/oseni03/ai-visibility-tester.md
- **Developed by:** [Ayomide Oseni](https://apify.com/oseni03) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $99.00 / 1,000 results

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?

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

## AI Visibility Tester

Measure how AI answer engines recommend your business.

Customers are increasingly asking AI assistants questions like:

- "What are the best dental clinics in Lagos?"
- "Where can I get affordable teeth whitening?"
- "Which accounting firm should I hire?"
- "Best restaurants near me?"

**AI Visibility Tester** shows whether your business appears in those answers — and how AI positions you compared to competitors.

Instead of measuring traditional search rankings, this Actor measures:

> When customers ask AI who they should choose, does your business appear?

### What this Actor does

Given:

- A business name
- A website
- A location
- Customer-style questions
- Optional competitors

The Actor queries AI answer engines and extracts structured visibility insights, measuring:

- ✅ Business mentions
- ✅ AI recommendations
- ✅ Ranking position (when explicitly listed)
- ✅ Website citations
- ✅ Competitors mentioned
- ✅ Aggregate visibility metrics

### Example

**Question:** "What is the best dental clinic in Victoria Island for braces and dental implants?"

**Business:** Exclusive Smile Dental Clinic

**AI response:**

> For braces and dental implants in Victoria Island, I'd start with Exclusive Smile Dental Clinic. Other options include Richmond Dental Clinic and The Ridge Dental Practice.

**Output:**

```json
{
  "mentioned": true,
  "recommended": true,
  "position": 1,
  "cited": false,
  "competitors_mentioned": ["Richmond Dental Clinic", "The Ridge Dental Practice"]
}
```

**Interpretation:** AI recognizes and recommends the business, places it first when ranking explicitly, but did not directly cite the business website.

### Supported AI engines

#### ChatGPT

Uses OpenAI's web-enabled models to evaluate how ChatGPT responds to customer-style questions. Measures mentions, recommendations, rankings, competitor visibility, and source usage.

#### Perplexity

Uses Perplexity's search-based AI responses. Measures mentions, recommendations, competitor comparisons, and citations.

**Not currently supported:** Google AI Overviews and Microsoft Copilot — neither exposes a public API that reliably reproduces its consumer AI search experience.

### Understanding AI visibility

AI visibility is not the same as SEO ranking.

Traditional SEO asks: *"Where does my website rank?"*
AI visibility asks: *"When AI recommends businesses, does my business appear?"*

A business can be recommended **without** being cited:

> "Exclusive Smile Dental Clinic is a good option for cosmetic dentistry."

```json
{ "mentioned": true, "recommended": true, "cited": false }
```

The AI knows and recommends the business but doesn't link directly to the website.

Or a business can be **cited**:

> "According to Exclusive Smile Dental Clinic's website..."

```json
{ "cited": true, "citation_url": "https://example.com" }
```

The business has earned a direct AI source reference.

### Output

Each query × AI engine combination produces one visibility result:

```json
{
  "query": "best dental clinics in Lagos",
  "engine": "chatgpt",
  "status": "success",
  "mentioned": true,
  "recommended": true,
  "position": null,
  "cited": false,
  "citation_url": null,
  "competitors_mentioned": ["Richmond Dental Clinic", "Schubbs Dental Clinic"],
  "raw_response_excerpt": "..."
}
```

#### Output fields

| Field | Description |
|---|---|
| `mentioned` | Whether the business appears in the AI response at all. |
| `recommended` | Whether the AI presents the business as a suitable choice (e.g. "worth checking," "top choice," "highly regarded"). |
| `position` | The business's position when the AI gives an explicit ordered ranking (e.g. a numbered list). `null` if the AI recommends businesses without ordering them. |
| `cited` | Whether the AI response cites the business's own website as a source. Verified against the business's actual domain — a directory or aggregator site mentioning the business doesn't count as a citation. |
| `competitors_mentioned` | Which of your declared competitors appeared in the response — useful for share-of-voice and AEO strategy. |

### Summary metrics

| Metric | Meaning | Example |
|---|---|---|
| **Mention rate** | How often the business appears across all tested queries. | `1.0` = mentioned in 100% of tests |
| **Recommendation rate** | How often AI recommends the business (not just mentions it). | `0.83` = recommended in 83% of tests |
| **Citation rate** | How often AI cites the official website as a source. | `0.25` = cited in 25% of tests |
| **Average position** | Average explicit ranking position, across only the queries where AI gave an ordered list. | `1.5` |

### How it works

```
Business + Customer Questions
            │
            ▼
   AI Search Engines
   (ChatGPT / Perplexity)
            │
            ▼
Structured Visibility Analysis
            │
            ▼
     Validation Layer
            │
            ▼
   AI Visibility Report
```

### Validation & accuracy

AI responses can contain inconsistencies, so every result passes through a validation layer before being returned.

**Citation validation** — a citation only counts when the URL's domain matches the business's actual website.

- ✅ Counts: business website is `https://example.com`, citation is `https://example.com/services`
- ❌ Doesn't count: citation is `https://directory.com/example-business`

**Logical validation** — impossible combinations are corrected automatically. For example, a response claiming:

```json
{ "mentioned": false, "recommended": true }
```

is invalid — a business can't be recommended without being mentioned — and is corrected before being returned.

### Use cases

**Local businesses** — dental clinics, restaurants, lawyers, hotels, real estate companies, healthcare providers — understand whether AI recommends you at all.

**AEO agencies** — build AI visibility audits as a repeatable workflow:

```
Run audit → Find visibility gaps → Improve website/content → Monitor AI recommendation growth
```

**Competitor research** — discover which businesses AI recommends most, who shows up for your important queries, and where your business is missing.

**Ongoing monitoring** — run regularly to track AI recommendation changes, competitor movement, and citation growth over time.

### Best practices

**Use customer questions, not brand searches.**

| | Example |
|---|---|
| ❌ Avoid | "Exclusive Smile Dental Clinic" (only tests brand recall) |
| ✅ Good | "best dentist in Lagos" |
| ✅✅ Better | "best dentist in Lagos for dental implants" |

**Test different customer intents:**

- **Discovery** — "best dental clinics in Lagos"
- **Service-specific** — "best clinic for braces in Lagos"
- **Price-focused** — "affordable teeth whitening Lagos"
- **Location-focused** — "best dental clinic in Victoria Island"

### Limitations

| Engine | Status |
|---|---|
| ChatGPT | ✅ Supported |
| Perplexity | ✅ Supported |
| Google AI Overviews | ❌ Not supported — no reliable public API |
| Microsoft Copilot | ❌ Not supported — no reliable public API |

### Roadmap

- AI Visibility Score
- AI share-of-voice metrics
- Competitor intelligence
- AEO recommendations
- Content opportunity detection
- Automated client reports
- Historical dashboards
- Multi-location monitoring

### About

Traditional SEO measures where you rank. AI visibility measures whether AI recommends you.

AI Visibility Tester helps businesses understand and improve their presence in the next generation of search.

# Actor input Schema

## `business` (type: `object`):

The business to test — name, website, and any known aliases.

## `location` (type: `string`):

City, region, or market being tested (e.g. 'Lagos').

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

Natural-language questions to test, e.g. 'best dentist in Lagos'.

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

Known competitor businesses to detect when mentioned in AI responses. Accepts either plain names or {name, website} objects.

## `max_concurrency` (type: `integer`):

Maximum number of concurrent AI engine calls. Keep low (2-5) to avoid rate limits.

## Actor input object example

```json
{
  "business": {
    "name": "ABC Dental",
    "website": "https://example.com",
    "aliases": []
  },
  "location": "Lagos",
  "max_concurrency": 3
}
```

# Actor output Schema

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

No description

## `overview` (type: `string`):

No description

## `queryResults` (type: `string`):

No description

## `downloadCsv` (type: `string`):

No description

## `resultCount` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("oseni03/ai-visibility-tester").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("oseni03/ai-visibility-tester").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 '{}' |
apify call oseni03/ai-visibility-tester --silent --output-dataset

```

## MCP server setup

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

```

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/WtkWPS4MZDwR8giQl/builds/g8tix9H66RQMvvRzt/openapi.json