# Facebook Fake Engagement Check — are these comments real? (`mentat-logic/mentat-authenticity-check`) Actor

Paste a Facebook post URL and get an evidence-backed answer on whether its comments came from real people: coordinated timing, machine-regular cadence, duplicate phrasing, account clusters. First 1,500 comments analyzed free. Never calls anyone a bot.

- **URL**: https://apify.com/mentat-logic/mentat-authenticity-check.md
- **Developed by:** [Mentat Logic](https://apify.com/mentat-logic) (community)
- **Categories:** Social media, Automation, AI
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.66 / 1,000 unique comment analyzeds

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Facebook Fake Engagement Check

Someone flooded your post with comments and you want to know whether they came from real people.

Paste the post URL. You get an evidence-backed answer in about three minutes: which accounts show coordination, which look organic, and which the data cannot judge either way. The first 1,500 comments of every run are analyzed free.

This tool never calls anyone a bot. It shows you the pattern, attaches the evidence, and states plainly what it cannot detect.

### How do I know if Facebook comments are fake?

You usually cannot tell by reading them. Coordinated comment campaigns are built to look ordinary one comment at a time. The pattern only appears when you line up when each account posted, how often, and how similar the wording is across supposedly unrelated people.

This tool looks for four things across the whole comment section:

- Timing bursts - clusters of comments arriving in a window far tighter than organic conversation produces.

- Machine-regular cadence - an account posting at intervals so even that the variation is near zero. People are irregular; schedulers are not.

- Duplicate phrasing across accounts - the same distinctive phrases appearing from accounts with no other connection to each other.

- Reply chains - accounts that consistently amplify one another.

Every finding carries its evidence: the timestamps, the intervals, the shared phrases.

### What does the answer look like?

Each account in the comment section gets one verdict:

- MULTIPLE SIGNALS - more than one independent pattern points the same way.

- STRONG / WEAK PATTERNS - one pattern, graded by how far it sits from normal.

- NO SIGNALS OBSERVED - nothing anomalous in this data.

- INSUFFICIENT SIGNAL - not enough activity to judge. This is a real answer, not a failure. An account with two comments cannot be assessed, and this tool will not pretend otherwise.

Plus a summary: accounts seen, what share of the comments came from flagged accounts, and the coverage - how much of the data could actually be read.

### What this cannot detect

Stated plainly, because the limits matter as much as the findings:

- Professionally run personas. Someone paid to post from a real, aged account with genuine history is indistinguishable from a real customer in engagement data. Any tool claiming otherwise is not being honest with you.

- Motive. Coordination is a pattern, not a confession. Employees, fans and volunteers coordinate too.

- Anything outside the comments. Views, shares and reach are aggregate numbers with no per-event data attached; nobody can audit them from the outside.

Signals describe behaviour in a dataset. They do not describe people.

### What you paste in

One or more Facebook post URLs - permalinks, /posts/ links, story.php links, reel and video permalinks. Page links, /watch links and share wrappers are rejected individually with the reason stated, never silently dropped. Duplicate post URLs are deduplicated before anything runs, so you never pay to scrape the same post twice.

Leave the input empty to run the free demo: a synthetic comment section with a planted coordination burst, one account the tool must refuse to judge, and one row it cannot read at all. No scraper is invoked, nothing is charged, and it finishes in about seven seconds.

### What it costs

Two lines, on every run:

- scrape: N comments via apify/facebook-comments-scraper - billed to you by that scraper (roughly $2.00-2.50 per 1,000 comments at its published rates).

- analysis: M unique comments, first 1,500 free - the rest at $0.66 per 1,000 unique comments, platform compute included.

This tool conducts the scraper; it does not resell it. Its fee goes to it, ours goes to us, and the receipt shows both. If the scraper fails on some posts, those posts are named in the summary as its failures. If it fails entirely, the run refuses cleanly and we charge nothing.

### Permissions, stated plainly

This actor runs with full permissions because it must start the comments scraper in your own account and read the resulting dataset. It reads nothing else. The data stays in your account; we retain nothing after the run.

### For AI agents

One call replaces a multi-step pipeline: URL validation, scraper orchestration, field mapping, analysis, report. Inputs and outputs are schema-defined. Failures are explicit - a refusal returns status: refused with a reason string and exits cleanly rather than returning an empty success. Coverage is always reported, so a thin answer is distinguishable from a confident one. There is no LLM anywhere in the analysis: identical input produces identical output, every time.

### Measured performance

Live, platform-confirmed (24 July 2026): a real 888-comment job - scrape and analysis end to end - completed in 3m11s at the default 256 MB. The free demo completes in about 7 seconds. Engine ceiling (sandbox-measured): 50,000 comments is roughly 34 s of analysis at a peak of about 131 MB, comfortably inside the default memory.

# Actor input Schema

## `postUrls` (type: `array`):

1-25 Facebook POST URLs (permalink, /posts/, story.php, reel or video permalink). Page links, /watch links and share wrappers are rejected individually with the reason stated. Duplicate posts are deduplicated before anything runs. Leave empty to run the free synthetic demo: no scraper is invoked and nothing is charged.
## `maxCommentsPerPost` (type: `integer`):

How many comments to request per post from the comments scraper. Total pipeline cap is 50,000. The scraper bills your account directly for what it returns (about $2-2.50 per 1,000 comments); our analysis is free for the first 1,500 unique comments of every run.

## Actor input object example

```json
{
  "postUrls": [],
  "maxCommentsPerPost": 2000
}
````

# Actor output Schema

## `results` (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 = {
    "postUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("mentat-logic/mentat-authenticity-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 = { "postUrls": [] }

# Run the Actor and wait for it to finish
run = client.actor("mentat-logic/mentat-authenticity-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 '{
  "postUrls": []
}' |
apify call mentat-logic/mentat-authenticity-check --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Fake Engagement Check — are these comments real?",
        "description": "Paste a Facebook post URL and get an evidence-backed answer on whether its comments came from real people: coordinated timing, machine-regular cadence, duplicate phrasing, account clusters. First 1,500 comments analyzed free. Never calls anyone a bot.",
        "version": "0.0",
        "x-build-id": "bqz3t4DAidj1z8WpP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mentat-logic~mentat-authenticity-check/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mentat-logic-mentat-authenticity-check",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mentat-logic~mentat-authenticity-check/runs": {
            "post": {
                "operationId": "runs-sync-mentat-logic-mentat-authenticity-check",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mentat-logic~mentat-authenticity-check/run-sync": {
            "post": {
                "operationId": "run-sync-mentat-logic-mentat-authenticity-check",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "postUrls": {
                        "title": "Facebook post URLs to check",
                        "type": "array",
                        "description": "1-25 Facebook POST URLs (permalink, /posts/, story.php, reel or video permalink). Page links, /watch links and share wrappers are rejected individually with the reason stated. Duplicate posts are deduplicated before anything runs. Leave empty to run the free synthetic demo: no scraper is invoked and nothing is charged.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments to check per post",
                        "minimum": 10,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many comments to request per post from the comments scraper. Total pipeline cap is 50,000. The scraper bills your account directly for what it returns (about $2-2.50 per 1,000 comments); our analysis is free for the first 1,500 unique comments of every run.",
                        "default": 2000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```