# Facebook Page Scraper – Profiles & Stats (`chronometrica/facebook-channel-scraper`) Actor

Get clean public Facebook Page and profile rows from URLs, with stable IDs, audience stats, profile links, Page facts, and clear status.

- **URL**: https://apify.com/chronometrica/facebook-channel-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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 Page Scraper – Profiles & Stats

### 📊 What does Facebook Page Scraper do?

Paste public Facebook Page or profile URLs and get clean profile data in bulk.
Use it to enrich creator and brand lists, compare public audiences, find public
links, and refresh Page records.

Every unique input gets one flat, matched row. The row keeps the original
`input`, canonical `channelUrl`, stable Facebook identity, profile facts,
public links, audience counts, quality labels, and a clear `status` and
`statusReason`.

This Actor does not log in, use cookies, collect posts or comments, access
private profiles, return follower lists, or bypass Facebook access controls. It
reads public Page and profile surfaces only.

With Facebook Page Scraper, you can:

- 🆔 Match Pages and profiles with stable profile and delegate Page IDs.
- 📈 Compare followers, following, Page likes, and talking-about counts.
- 🔎 Detect email-like text and web links in the public description.
- 🔗 Keep public websites and profile sections when Facebook exposes them.
- 🧾 Save public name, category, profile type, and description.
- 🛡️ Keep public verification, memorial, and live signals.
- 🚦 Get clear status rows when a Page or profile is missing or unavailable.
- 📦 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What Facebook profile data can I extract?

Each dataset row represents one attempted Facebook Page or profile input.

| Data group      | Example fields                                                            |
| --------------- | ------------------------------------------------------------------------- |
| 🆔 Identity     | `channelId`, `pageId`, `channelUrl`, `handle`                             |
| 🧾 Profile      | `displayName`, `alternateName`, `profileType`, `description`, `category`  |
| 🔎 Detected     | `detectedEmails`, `detectedLinks`                                         |
| 🔗 Public links | `website`, `profileTabs`                                                  |
| 🖼️ Media        | `avatarUrl`, `coverUrl`                                                   |
| 🛡️ Flags        | `isVerified`, `isMemorialized`, `isCurrentlyLive`, `liveVideoId`          |
| 📊 Counts       | `followersCount`, `followingCount`, `pageLikesCount`, `talkingAboutCount` |
| 🚦 Result       | `status`, `statusReason`, `observedAt`                                    |

Missing public values stay `null`. Compact values such as `27M` are labeled
`display_rounded`; they are not presented as exact counts.

### ⚙️ Can I use this Actor through an API?

Yes. Run it in Apify Console or through the Apify API, Python SDK, Node.js SDK,
webhooks, schedules, and Apify integrations.

### 🎯 Why collect Facebook Page and profile data?

| Use case              | How the data helps                                                 |
| --------------------- | ------------------------------------------------------------------ |
| 📋 Creator enrichment | Add stable IDs, public audience facts, descriptions, and links.    |
| 📣 Campaign planning  | Compare public reach and Page type before outreach.                |
| 🏷️ Brand research     | Refresh public company, creator, and community Page records.       |
| 🔗 Identity matching  | Use profile IDs, Page IDs, websites, and public links as evidence. |
| 🧱 Data products      | Feed normalized profile rows into CRMs, dashboards, and databases. |

### 💵 Pricing

Each useful profile row triggers one `profile` event. Prices per 1,000 useful
rows are:

| Plan                    | Price |
| ----------------------- | ----: |
| Free                    | $4.00 |
| Bronze                  | $3.60 |
| Silver                  | $3.20 |
| Gold, Platinum, Diamond | $2.80 |

Apify platform usage is charged separately. There is no paid Actor start event.
One useful row is an `ok` or `partial` profile snapshot written to the default
dataset. Invalid, missing, blocked, and failed inputs are not charged as profile
results. Each dataset row includes `isBillable` so this rule is visible.

### 🚀 How do I use Facebook Page Scraper?

1. Open **Facebook Page Scraper – Profiles & Stats** in Apify Console.
2. Paste one or more public Page or profile URLs.
3. Click **Start**.
4. Open **Output** to inspect the rows and run summary.
5. Download the dataset or connect it to your workflow.

### ⬇️ Input

Add 1 to 1,000 values in `startUrls`:

```json
{
  "startUrls": [
    "https://www.facebook.com/MrBeast/",
    "https://www.facebook.com/HIKAKIN/"
  ]
}
````

Public handles, numeric profile URLs, and `profile.php?id=...` links are
accepted. Reel, Group, Event, Marketplace, Story, search, help, messages, login,
and other site-navigation routes are rejected. Exact duplicate values run once.

### ⬆️ Output sample

```json
{
  "platform": "facebook",
  "input": "https://www.facebook.com/MrBeast/",
  "channelId": "100044548384499",
  "pageId": "1521410468170410",
  "channelUrl": "https://www.facebook.com/mrbeast",
  "handle": "@mrbeast",
  "displayName": "MrBeast",
  "followersCount": 44000000,
  "countPrecision": {
    "followersCount": "display_rounded"
  },
  "status": "ok",
  "statusReason": null,
  "observedAt": "2026-07-16T00:00:00.000Z"
}
```

#### 📌 Run summary

The `OUTPUT` record reports input counts, output rows, billable rows, status
counts, useful rates, and run time. It does not contain raw pages, cookies, or
private request details.

### 🎯 Status and quality fields

- `ok`: Facebook exposed stable target Page or profile identity.
- `partial`: useful public profile facts were found, but some facts are missing.
- `private`, `login_required`, or `not_found`: the public profile could not be
  read as a normal useful row.
- `blocked`, `challenge`, or `rate_limited`: Facebook refused the public request
  at that time.
- `parser_miss`: a response loaded, but the Actor could not safely tie it to
  the requested Page or profile.
- `invalid_input` or `failed`: the input was not a profile or the request failed.

### 🔒 Source boundary and limits

- Public logged-out Page and profile surfaces only.
- `detectedEmails` and `detectedLinks` are unverified clues from the public
  description and public link fields. They can be missing or wrong.
- The Actor does not open or crawl detected links.
- Direct email, phone, and address fields stay `null` unless Facebook exposes
  them.
- Full follower and following lists are not returned.
- Public follower and following tabs can be missing or limited.
- Facebook can hide, delay, round, or change public values.

### ❓ FAQ

#### Does this Actor need login, cookies, or an API key?

No.

#### Why do some Page IDs differ from profile IDs?

Facebook can expose both a current profile ID and a legacy or delegate Page ID.
Keep both. Do not assume they are equal.

#### How are duplicates handled?

Exact duplicate inputs are checked once. Use `channelId` as the strongest
cross-run dedupe key when it is present.

### 🛟 Support

Send the run ID, input URL, expected Page or profile, and observed row. Do not
send passwords, cookies, or account credentials.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

# Actor input Schema

## `startUrls` (type: `array`):

Add 1 to 1,000 public Facebook Page or profile URLs. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/MrBeast/"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "startUrls": [
        "https://www.facebook.com/MrBeast/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/facebook-channel-scraper").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 = { "startUrls": ["https://www.facebook.com/MrBeast/"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/facebook-channel-scraper").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 '{
  "startUrls": [
    "https://www.facebook.com/MrBeast/"
  ]
}' |
apify call chronometrica/facebook-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=chronometrica/facebook-channel-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Page Scraper – Profiles & Stats",
        "description": "Get clean public Facebook Page and profile rows from URLs, with stable IDs, audience stats, profile links, Page facts, and clear status.",
        "version": "0.1",
        "x-build-id": "xS0nmqOklqEfff08b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~facebook-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-facebook-channel-scraper",
                "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/chronometrica~facebook-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-facebook-channel-scraper",
                "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/chronometrica~facebook-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-facebook-channel-scraper",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Facebook Page or profile URLs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add 1 to 1,000 public Facebook Page or profile URLs. Duplicate inputs are checked once. Each unique input creates one result row and adds usage.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.facebook.com/MrBeast/"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
