AI Visibility & Competitor Source Gaps

Find the pages that make AI recommend your competitors, and check whether those pages mention your brand.

The Actor asks AI engines the questions your customers ask: Perplexity by default, with ChatGPT (web search) and Gemini available for a full scan. It collects the sources the answers cite, then fetches each of those pages. The goal is to confirm, from the real page content, which pages mention your competitors but not you.

What it does

1. Builds up to 10 questions from your category and location, using fixed templates (no AI is used to write them). You can also supply your own questions.
2. Sends the questions to the AI engines you select (Perplexity by default).
3. Measures how often your brand and your competitors are mentioned in the answers.
4. Collects every source URL the answers cite and classifies each one: owned, forum, review site, listicle, publication, directory or other.
5. Fetches the most promising cited pages and checks their text for your brand and your competitors.
6. Returns a prioritized list of source gaps, plus a CSV of verified opportunities you can use for outreach.

Who it is for

• Local businesses and agencies checking how AI assistants recommend businesses in a city.
• SaaS and e-commerce marketers doing GEO / AEO (generative/answer engine optimization).
• PR and outreach teams looking for articles, lists and directories to get included in.

Input

Field	Required	Description
Brand	yes	Your business name
Website	yes	Your website, e.g. https://example.com
Category	yes	What you are, e.g. restaurant, CRM software
Country	yes	Your market
City	no	For local businesses
Competitors	no	Up to 5. Accepted formats: Name, Name | domain.com, Name (domain.com) or domain.com. If you leave this empty, competitors are discovered automatically.
Custom questions	no	Up to 25. These replace the standard questions.
AI engines	no	Default: Perplexity only (quick scan, 10 searches). Select ChatGPT and Gemini too for the full analysis (30 searches). See Cost.
Samples per question	no	1–10 (default 1)
Pages to check	no	0–100 (default 25)

Default quick scan (Perplexity only):

{
  "brand": "Example Restaurant",
  "website": "https://example.com",
  "category": "Restaurant",
  "country": "Saudi Arabia",
  "city": "Riyadh"
}

Optional full scan: add "engines": ["perplexity", "chatgpt", "gemini"]. That runs 30 searches instead of 10 (see Cost).

Output

Where	What
Dataset (table)	One row per source gap (page × competitor), sorted high → medium → unverified. If a run finds no gaps, it holds a single row with recordType: "run_summary" that explains why (not an opportunity)
Key-value store OUTPUT	The full JSON report: run, brandVisibility, topCompetitors, responses, citations, pages, sourceGaps, uncheckedSources, summary, errors, notes
Key-value store OPPORTUNITIES.csv	Verified opportunities only (high + medium). Columns: url, domain, sourceType, competitor, brand, prompt, engine, verification, priority
Key-value store RAW_RESPONSES	The full raw answers exactly as the engines returned them, for debugging

Example source gap (default quick scan):

{
  "url": "https://www.timeout.com/riyadh/restaurants/best-restaurants-in-riyadh",
  "domain": "timeout.com",
  "title": "The 15 best restaurants in Riyadh",
  "sourceType": "listicle_comparison",
  "competitor": "Najd Heritage Kitchen",
  "brand": "Example Restaurant",
  "verification": "verified_competitor_only",
  "priority": "high",
  "reason": "Page fetched: \"Najd Heritage Kitchen\" found 2× in main content; \"Example Restaurant\" not found anywhere on the page",
  "competitorMentionsOnPage": 2,
  "timesCited": 10,
  "prompt": "What are the best restaurant choices for customers in Saudi Arabia?",
  "engine": "perplexity",
  "engines": ["perplexity"]
}

Example visibility and top competitors (default quick scan):

"brandVisibility": { "mentions": 3, "responses": 8, "rate": 0.375, "percentage": 37.5, "basis": "discovery_prompts",
  "byEngine": { "perplexity": { "mentions": 3, "responses": 8, "rate": 0.375, "percentage": 37.5 } } },
"topCompetitors": [
  { "rank": 1, "name": "Najd Heritage Kitchen", "mentionRate": 1, "mentions": 8, "totalResponses": 8, "origin": "discovered", "confidence": "medium" }
]

In a full scan, engines lists every engine that cited the page, and byEngine has one entry per engine.

(These examples come from the Actor's built-in test fixtures. The business names in them are fictional.)

What "verified competitor-only" means

A page is marked verified_competitor_only only when all of the following are true:

• the page was actually downloaded (HTTP 200, HTML, readable text of at least 150 words);
• a competitor was found in the page's main content (navigation, header, footer and sidebars are ignored);
• your brand was not found anywhere on the page. That check covers the main text, navigation, footer, title, meta tags and image alt text, plus any link to your domain.

The check is deliberately lopsided: competitors must be in the main content, while your brand is searched everywhere. As a result, "competitor-only" is only claimed when your brand is absent from everything the Actor could read. Being cited by an AI answer is never enough on its own to mark a page as verified.

All verification states:

State	Meaning	Priority
verified_competitor_only	Fetched; competitor found; brand not found	high
competitor_found	Fetched and competitor found, but the page was too short, truncated or looked paywalled, so your brand's absence can't be trusted	medium
brand_found	Fetched and your brand is on the page	not a gap
no_mentions	Fetched; neither your brand nor a competitor was found	not a gap
not_verified	The Actor tried to fetch the page but could not check it. The reason is stored (see below).	unverified, if the AI answer that cited it named a competitor and not you

What "not verified" means

The Actor could not reliably read the page, so it makes no claim about the page's content. Each such page records a reason:

• http_401 / http_403: login required or access denied
• cloudflare_challenge: bot protection
• robots_disallowed: the site's robots.txt asks crawlers not to fetch that path (the Actor respects this)
• timeout / network_error
• not_found: 404 or 410
• rate_limited: 429
• server_error: 5xx
• js_required: the page is rendered by JavaScript and its HTML contains no readable text
• paywall
• empty_content
• unsupported_content_type: e.g. PDF
• invalid_url
• blocked_host
• extraction_failed
• verification_cap_reached: the page was not checked because the "Pages to check" limit was reached

Rows marked "unverified" are leads for a manual check, not findings.

Pages skipped because of the "Pages to check" limit were never fetched, so they are not rows in the dataset. If the AI answer that cited one named a competitor and not you, it is listed once in OUTPUT.uncheckedSources (with the competitors that answer named). Raise "Pages to check" to verify them.

How competitor discovery works

If you list competitors, the Actor uses exactly those. If you don't, it discovers candidates from the AI answers without any extra AI call:

1. It takes names that appear in structured positions of the answers: bold text, numbered or bulleted list items, headings and link text.
2. It removes generic headings ("Key Features", "Budget"), cuisine, nationality and language labels ("Japanese", "Bilingual Arabic"), feature and service labels ("UI", "Web Design"), locations, your category words, known source platforms (TripAdvisor, Yelp, Reddit…), publications ("Michelin Guide") and your own brand. Names the answers use as places, such as "restaurants in Diriyah" or "the Al Olaya district", are treated as locations and removed as well.
3. It counts how many answers mention each remaining name, and across how many engines. A cited URL that looks like the candidate's own website counts as extra evidence.
4. It returns up to 5 candidates, each with a confidence level and a plain-language reason:
   • high: named in 2 or more answers, and either named by 2 or more engines or its own website was cited;
   • medium: named in 2 or more answers;
   • low: named in only 1 answer.

These are businesses the AI named. They are not guaranteed to be your direct competitors, so review the list.

How visibility is calculated

There is no secret score. The calculation is:

brand visibility      = answers that mention your brand      / successful answers
competitor visibility = answers that mention the competitor / successful answers

• Only discovery questions are counted: questions that don't name your brand. Two of the standard questions do name it ("alternatives to
• Failed answers are excluded from the denominator.
• A mention means the name or domain was matched as whole words. For example, "Nobu" does not match "Nobuko".
• Short or common-word brand names (e.g. "On", "Target") need correct capitalization and a nearby category word. This stops the ordinary word "on" from counting as a mention.
• The results also include a breakdown per engine.
• topCompetitors ranks competitors by how often they were observed in AI answers. It is not a quality ranking.

Cost

A run has two separate costs, both billed to your Apify account:

1. This Actor: $0.20 per completed analysis. One analysis-completed event is charged per run, after the report is saved, and only if at least one AI engine answered. A run where every engine failed is not charged.
2. The AI searches: each question on each engine is a run of an official Apify Store Actor, started under your account and billed by that Actor at your Apify plan's price. This is on top of the $0.20:

Engine	Actor	Free plan	Starter	Scale	Business
Perplexity	apify/perplexity-search-scraper	$0.20	$0.013	$0.010	$0.009
ChatGPT	apify/chatgpt-search-scraper	$0.20	$0.005	$0.004	$0.003
Gemini	apify/gemini-search-scraper	$0.20	$0.005	$0.004	$0.003

(Price per question, as listed by those Actors in September 2026. The engine Actors set these prices and can change them.)

Estimated total per run (AI searches + $0.20 analysis):

Scan	Searches	Free plan	Starter	Scale	Business
Quick (default: Perplexity, 10 questions)	10	$2.00 + $0.20	$0.13 + $0.20	$0.10 + $0.20	$0.09 + $0.20
Full (optional: all three engines, 10 questions)	30	$6.00 + $0.20	$0.23 + $0.20	$0.18 + $0.20	$0.15 + $0.20

A small amount of Apify platform usage (Actor start) may also apply.

On the Free plan, a full analysis costs more than the $5 of monthly free credit. The quick scan is the default for that reason. In the live test, Perplexity also returned most of the cited sources. The Actor cannot see your exact plan or remaining credit. Before the first search it shows an estimate as the run's status message: exact on the Free plan, a range on paid plans. No OpenAI, Google or Perplexity API key is needed.

Your maximum cost per run covers both: the price of one analysis-completed event is reserved first, and the rest is split evenly between the AI engine runs as their own maximum cost. If the limit is too low for even one analysis, the run stops before any AI engine is asked, and nothing is charged. Gemini's Actor requires a maximum cost of at least $0.50 per run: if Gemini's share is lower, Gemini is skipped (the reason is in OUTPUT.errors) and the other engines still run.

To prevent runaway costs, a run is capped at 150 AI questions in total (questions × engines × samples). Inputs over any limit fail immediately with a clear message.

Limitations

• AI answers vary. The same question can get a different answer on the next run. Use 2–3 samples for steadier numbers.
• Answers are scraped from consumer AI products by the engine Actors listed above. If one of those Actors is down, its engine's answers are marked as failed, and the rest of the run continues.
• No location parameter. The engines take no location setting, so the location is written into the question text. Results reflect whatever location context the engines apply on their side.
• No headless browser. Pages are fetched with plain HTTP. Pages that need JavaScript, login or bot-protection bypass are reported as not_verified; they are never guessed.
• robots.txt is respected, and requests to the same site are spaced out. Some sites (for example Reddit and Yelp) often block automated requests, so expect some not_verified results.
• Name matching is deterministic. Heavily abbreviated names, misspellings or names written in a different script than the one you entered may be missed.
• Source classification uses domain lists and URL/title patterns. Sites it doesn't recognize are classified as other.
• The Actor finds opportunities. It does not contact anyone.

Example use case

A restaurant in Riyadh runs the Actor with its name, website and "Restaurant / Saudi Arabia / Riyadh". With the default quick scan (Perplexity, 10 questions), the results show the restaurant appears in 37.5% of AI answers, while its top competitor appears in all of them. They also show two pages that were fetched and verified to mention competitors but not the restaurant: a "best restaurants in Riyadh" listicle and a lifestyle news article. Both are cited repeatedly by Perplexity. Those two pages go to the top of the restaurant's PR outreach list. The Reddit thread the AI cited couldn't be fetched (HTTP 403), so it is listed as "unverified" for a manual check. To see whether ChatGPT and Gemini cite the same pages, the restaurant can run the optional full scan.