# AI Visibility Report — ChatGPT, Perplexity + Local Competitors (`moonlings/local-business-competitor-analysis`) Actor

Why is AI not recommending your business? AI brand visibility audit for local businesses: live ChatGPT & Perplexity appearance counts (AEO/GEO ground truth) plus the competitor, Google-review, and ads evidence behind the answer — from a quick scan to a full night report.

- **URL**: https://apify.com/moonlings/local-business-competitor-analysis.md
- **Developed by:** [moonlings](https://apify.com/moonlings) (community)
- **Categories:** AI, Lead generation, SEO tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,990.00 / 1,000 quick competitor scans

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/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

## AI Visibility Report — ChatGPT, Perplexity & Local Competitors

AI search is already sending customers somewhere — this report tells you where,
and why. It asks ChatGPT and Perplexity live whether they recommend a business,
then digs into the evidence behind the answer: the strongest local competitor,
the review gap, ads presence, and the sites the AI reads. The quick scan is
**$1.99** (~2–4 minutes); the full graded research report is **$9.99**
(typically 10–30 minutes).

Visibility is reported as real appearance counts — "appeared in 2 of 6
answers, ChatGPT 1/3, Perplexity 1/3" — never an invented rating.

### Two depths, one engine

#### Quick scan — $1.99, ~2–4 minutes

Live AI-visibility check (both engines, real counts, who's recommended
instead, cited domains) plus an AI research agent that identifies the
business's strongest local rival and scouts it: review numbers, offers,
recent changes — every finding with a working source URL — and concrete
recommended actions.

#### Deep research report — $9.99, typically 10–30 minutes

A multi-agent research crew sweeps the full picture, and a grader iterates
the report until it passes a quality rubric:

- AI-assistant visibility with per-engine appearance counts
- Competitor landscape with reviews/ratings comparison
- Google Business Profile and local-ads observations
- Local events and demand signals worth acting on
- **Structured findings JSON** (`findings[]` with `key`, `finding`,
  `evidence`, `sourceUrl`) plus every cited source, deduped
- Top recommended actions with effort labels
- The complete report as markdown (`reportMarkdown`)

### Sample output (quick scan, abridged — real run)

```json
{
  "reportType": "scan",
  "businessName": "Graeter's Ice Cream",
  "location": "Cincinnati, OH",
  "aiVisibility": {
    "asked": 6, "sampled": 6, "appeared": 2,
    "engines": [
      { "engine": "ChatGPT", "sampled": 3, "appeared": 1 },
      { "engine": "Perplexity", "sampled": 3, "appeared": 1 }
    ],
    "recommendedInstead": ["Aglamesis Bro's Ice Cream", "Hello Honey"],
    "citedDomains": ["cincinnatirefined.com", "365cincinnati.com"]
  },
  "findings": [
    {
      "label": "Review volume gap",
      "value": "Graeter's (Vine St) 4.6★ / 206 reviews vs Aglamesis Bro's 4.7★ / 1,300 — out-reviewed 6:1",
      "sourceUrl": "https://..."
    }
  ],
  "actions": [
    { "title": "Close the review gap", "body": "...", "tag": "do this" }
  ]
}
```

### Who uses this

- **Agencies**: the deep report is a client-ready deliverable — the same
  research a retainer buys, priced per report.
- **Owners**: one scan answers "does AI recommend us, and if not, who?"
- **AI agents**: callable via the Apify MCP server. The scan fits a normal
  tool-call wait; for the deep report, start the run and poll — results land
  in the dataset.

### Input

| Field | Required | Notes |
|---|---|---|
| `businessName` | yes | Spell it the way Google knows it |
| `location` | yes | City + state/region, e.g. "Cincinnati, OH" |
| `businessType` | recommended | Category anchor — enables the AI questions and competitor ground truth |
| `reportType` | — | `scan` (default) or `deep_report` |
| `website` | — | Deep report: grounds findings in your own site |
| `researchFocus` | — | Deep report: optional question to focus on |

### Pricing

Pay per delivered report: one `scan-report` event ($1.99) or one
`deep-report` event ($9.99), charged only when the result is pushed to the
dataset. **Failed runs are never charged.** Deep-report retries are
idempotent — a resurrected run resumes the same report rather than buying a
second one.

### Not what this does

- No 0–100 ratings, grades, or invented indexes — appearance counts and
  sourced findings only.
- Not a bulk scraper: one business in, one researched report out. For
  scraping thousands of listings, use a Maps scraper.
- Not instant: the deep report is real multi-agent research with a quality
  grader — it takes the minutes it takes.
- Not for businesses without a local market (the analysis is category + city
  anchored).

### Quick single checks

Need one number fast?
[AI Visibility Check](https://apify.com/moonlings/ai-visibility-check)
($0.79) answers "does ChatGPT recommend us?",
[Review Gap Check](https://apify.com/moonlings/review-gap-check) ($0.39)
measures your Google review gap vs rivals, and
[Thumbtack Scraper](https://apify.com/moonlings/thumbtack-scraper) pulls the
local-pro competitive field — ratings, hires, and reviews by service and city. The
[AI Fact-Check](https://apify.com/moonlings/ai-fact-check) checks whether AI
assistants state a business’s hours/address/phone correctly.

### For AI agents (MCP)

Agents can run this report directly: add Apify's MCP server as a connector —
`https://mcp.apify.com/?actors=moonlings/local-business-competitor-analysis` —
and it appears as the `moonlings--local-business-competitor-analysis` tool,
metered through your Apify account like any other run. The `scan` report type
fits inside a long tool call (2–4 minutes); for `deep`, start the run and poll
it with the MCP server's run-status tool rather than blocking.

**Long runs don't strand you.** Call the tool with `waitSecs=0` to get a
`runId` back immediately, then collect the result later with the MCP server's
`get-actor-run` tool. The run lives on Apify's platform independent of your
MCP session — an agent can kick off a deep report, end its session, and a
different session an hour later can still pick up the finished report.

### Deliver the report to your tools (MCP connectors)

This Actor accepts [MCP connectors](https://docs.apify.com/integrations/mcp-connectors):
authorize your Slack, Notion, or any MCP-compatible service once under
**Settings → API & Integrations**, pick it in the **Deliver results to your
tools** input section, and the finished report summary is posted straight into
your workspace — top findings, recommended actions, and a pointer to the full
dataset. Scheduled weekly scan + summary in the client's Slack channel is the
agency workflow this was built for.

Your credentials never enter this Actor: the Apify platform injects them
server-side, and the Actor is limited to output-writing tools
(`send_*` / `post_*` / `create_*` / `write_*` / `add_*`). If the tool needs a
destination (a Slack channel, a Notion parent page), set **Delivery target**.
Delivery is best-effort — the report always lands in the run's dataset, and a
delivery hiccup never fails the run or changes what you're charged.

### FAQ

**Which businesses does it work for?** Any business with a local market —
gyms, salons, restaurants, contractors, med spas, retail.

**Where does the data come from?** Live research at run time: AI assistants
with web search, public listings, review platforms, the business's own
website, and ads surfaces. Findings carry source URLs so you can verify.

### Who this is for

Marketing agencies, local SEO / AEO consultants, and owners who want the full
picture in one run: **AI brand visibility audit** (ChatGPT & Perplexity, live
web search), **local competitor analysis**, Google review benchmarking, and
competitor ad intelligence — the evidence layer behind "why isn't AI
recommending my business?" Suitable as a white-label report input.

### Works with AI agents

Agent-callable via the Apify API or MCP, and **x402-payable** — an autonomous
agent can buy a scan or a full night report with no account. Returns
structured findings JSON alongside the readable report.

# Actor input Schema

## `businessName` (type: `string`):

The local business to analyze, e.g. "Harbor Fitness". The analysis finds its strongest nearby competitor and reports the gaps.

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

City and state/region, e.g. "Cincinnati, OH". Anchors competitor discovery and AI-visibility sampling to the business's real market.

## `businessType` (type: `string`):

Category, e.g. "gym", "salon", "HVAC contractor". Strongly recommended: the AI assistants are asked category questions, and competitor ground truth is category-anchored — without it both are skipped.

## `address` (type: `string`):

For chains / multi-location businesses: the street address of the SPECIFIC location to anchor, e.g. "332 Ludlow Ave". Without it, the best-rated matching listing is used.

## `reportType` (type: `string`):

"scan" (about 2–4 minutes): live AI-visibility check (ChatGPT + Perplexity appearance counts) plus a strongest-competitor scan with sourced findings and recommended actions. "deep\_report" (typically 10–30 minutes): the full multi-agent research report — AI visibility, competitors, reviews, ads, local demand — quality-graded and revised until it passes, with structured findings JSON and the full markdown report.

## `website` (type: `string`):

Optional. Grounds the deep report in the business's own services, pricing, and positioning, and upgrades the ads check to a domain-level lookup.

## `researchFocus` (type: `string`):

Optional focus for the deep report, e.g. "we're losing members to boutique studios — why?". The crew covers the full competitive picture either way.

## `deliveryConnectors` (type: `array`):

Send the finished report summary to your own tools — a Slack channel, Notion page, or any MCP server with an output-writing tool. Authorize a connector once in Settings > API & Integrations, then pick it here. Your credentials never enter this Actor; the Apify platform injects them server-side.

## `deliveryTarget` (type: `string`):

Where inside the connected service to deliver, when the tool needs it — e.g. a Slack channel ("#marketing" or a channel ID), a Notion parent page/database ID. Leave blank for tools that don't require a destination.

## `deliveryTool` (type: `string`):

Advanced: the exact MCP tool to call on the connector (e.g. "send\_message", "create\_page"). Leave blank to auto-pick the first output-writing tool the connector offers.

## Actor input object example

```json
{
  "businessName": "Harbor Fitness",
  "location": "Cincinnati, OH",
  "businessType": "gym",
  "address": "332 Ludlow Ave",
  "reportType": "scan",
  "website": "https://harborfitness.com",
  "deliveryTarget": "#marketing",
  "deliveryTool": "send_message"
}
```

# Actor output Schema

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

The delivered report as structured JSON — findings with evidence and source URLs, recommended actions, and AI-assistant visibility.

## `run` (type: `string`):

Console view of this run, including the charged event and log.

# 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 = {
    "businessName": "Graeter's Ice Cream",
    "location": "Cincinnati, OH",
    "businessType": "ice cream shop",
    "reportType": "scan"
};

// Run the Actor and wait for it to finish
const run = await client.actor("moonlings/local-business-competitor-analysis").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 = {
    "businessName": "Graeter's Ice Cream",
    "location": "Cincinnati, OH",
    "businessType": "ice cream shop",
    "reportType": "scan",
}

# Run the Actor and wait for it to finish
run = client.actor("moonlings/local-business-competitor-analysis").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 '{
  "businessName": "Graeter'\''s Ice Cream",
  "location": "Cincinnati, OH",
  "businessType": "ice cream shop",
  "reportType": "scan"
}' |
apify call moonlings/local-business-competitor-analysis --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=moonlings/local-business-competitor-analysis",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tdOeSDunmQUdfaxGc/builds/bhg2ceJADnwZJVodD/openapi.json