# AI Fact-Check — What ChatGPT & Perplexity Get Wrong (`moonlings/ai-fact-check`) Actor

Asks ChatGPT and Perplexity live (with web search) about a local business's hours, address, phone, and category, then verifies each stated fact against Google Business data. Returns a severity-ranked list of what AI gets wrong — conservative by design, so it never cries wolf.

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

## Pricing

$1,490.00 / 1,000 ai fact-checks

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 Fact-Check — what do ChatGPT & Perplexity get wrong about your business?

AI assistants now answer "what are their hours?", "what's the address?", "are they open?" for millions of local businesses every day — and they get it wrong more often than you'd think. A wrong phone number costs you calls. "Permanently closed" costs you customers who never walk in.

**AI Fact-Check** asks ChatGPT and Perplexity live (with web search) about a specific business, extracts the facts they state — hours, address, phone, category — and verifies each one against Google Business data. You get a severity-ranked list of what the AI got **wrong**, with the AI's value next to the trusted value and its source.

It is **conservative by design** (see below) — the one thing worse than missing an error is inventing one.

### What you get

One record per run:

| Field | Meaning |
|---|---|
| `matchedName` | the business as Google lists it |
| `errorCount` | **confirmed** errors — conflicts that reproduced across both AI engines |
| `findings[]` | each: `field`, `provider` (ChatGPT / Perplexity), `statedValue` (what the AI said), `truthValue` + `truthSource` (what Google says), `verdict`, `severity`, `reproduced` |
| `trustedFacts[]` | the ground-truth fields the check ran against |
| `providers[]` | per-engine detail + the domains each AI answer cited |
| `conflationProviders[]` | engines that answered about a *different* same-named business |

Verdicts: **conflict** (AI disagrees with a high-confidence Google fact), **discrepancy** (a difference worth checking — e.g. the AI cited the business's own site, which may be fresher than Google). Fields with no trusted source are reported as **unverifiable**, never as errors.

### How it stays honest (why it won't cry wolf)

A false accusation — flagging a *correct* AI answer as wrong — is the worst outcome, so five guards sit in front of every error:

- A claim is only extracted if it actually appears in the AI's answer (no invented claims).
- A conflict is only **counted** as an error if it **reproduces across both engines** — a one-off is shown but flagged "seen once, may vary".
- If the AI cites the business's own website for a value, a mismatch with Google is treated as *possibly-stale Google*, not an AI error.
- Address and hours comparisons that are merely ambiguous (reworded, reformatted) resolve to a discrepancy, never a hard error.
- An answer about a different or same-named business elsewhere is flagged, and its facts are not graded as this business's errors.

### How to use it

1. Enter the **business name** and **city, state** (optionally a category and the website).
2. Run. Results land in the dataset (JSON / CSV / Excel / API) in ~15–30 seconds.

### Honest limits

- It checks the facts with a trusted Google source: **hours, address, phone, category, rating**. Services and prices aren't independently verifiable yet, so they're out of scope.
- AI answers vary between runs — this is a snapshot, and `reproduced` tells you which findings held across engines.
- For chains without an exact address, it checks the best-matched Google listing for that city.

### For AI agents (MCP)

Agents can run this directly: add Apify's MCP server as a connector — `https://mcp.apify.com/?actors=moonlings/ai-fact-check` — and it appears as the `moonlings--ai-fact-check` tool, metered through your Apify account like any other run. It is also **x402-payable** — an autonomous agent can discover, pay for, and run a fact-check with no Apify account.

### Who this is for

Local business owners, marketing agencies, and **AEO / GEO** (answer engine
optimization) practitioners who need to catch AI misinformation before customers
do — wrong hours, stale addresses, dead phone numbers, or "permanently closed"
flags that ChatGPT and Perplexity repeat from outdated sources. It's the accuracy
layer on top of AI-search visibility: being recommended by an answer engine only
helps if what it says about you is actually *right*. Pairs with the
[AI Visibility Check](https://apify.com/moonlings/ai-visibility-check) (does AI
mention you) — this one tells you whether what it says is true.

### Other Actors by Moonlings

- [AI Visibility Check](https://apify.com/moonlings/ai-visibility-check) — does ChatGPT recommend this business? Appearance rate, rivals, cited domains.
- [Review Gap Check](https://apify.com/moonlings/review-gap-check) — Google rating vs. nearby rivals, with the gap math done.
- [Local Business Competitor Analysis](https://apify.com/moonlings/local-business-competitor-analysis) — full AI competitor scan and deep research reports.

# Actor input Schema

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

The local business to fact-check, e.g. "Skyline Chili".

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

City and state/region, e.g. "Cincinnati, OH". AI assistants are asked as a local searcher there.

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

Category, e.g. "restaurant", "gym" — helps resolve the right listing. Not required.

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

If an AI answer cites your domain for a value that differs from Google, it's reported as a possibly-stale discrepancy rather than an error — so passing your site makes the check less likely to false-flag.

## Actor input object example

```json
{
  "businessName": "Harbor Fitness",
  "location": "Cincinnati, OH",
  "businessType": "restaurant",
  "website": "https://harborfitness.com"
}
```

# Actor output Schema

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

matchedName, errorCount, findings\[{field, provider, statedValue, truthValue, verdict, severity, reproduced}], trustedFacts, and per-provider samples.

## `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": "Skyline Chili",
    "location": "Cincinnati, OH"
};

// Run the Actor and wait for it to finish
const run = await client.actor("moonlings/ai-fact-check").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": "Skyline Chili",
    "location": "Cincinnati, OH",
}

# Run the Actor and wait for it to finish
run = client.actor("moonlings/ai-fact-check").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": "Skyline Chili",
  "location": "Cincinnati, OH"
}' |
apify call moonlings/ai-fact-check --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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