# Facebook Pages Scraper - Business Info & Contacts (`benthepythondev/facebook-pages-scraper`) Actor

Export public Facebook Page names, categories, descriptions, follower text and published contact details with source URLs. No Facebook login or external API key.

- **URL**: https://apify.com/benthepythondev/facebook-pages-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.40 / 1,000 pages

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/actors/running/actors-in-store.md#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

## Facebook Pages Scraper: business information and public contacts

Turn public Facebook Page URLs into structured records with the page name, category, description, follower text, source links and published contact fields. The Actor reads page-owned metadata and the Page Intro section. Each contact includes its source URL and source section so you can trace where it was published.

No Facebook login, session cookie or separate data-provider API key is required. The default engine uses direct HTTP to retrieve public page data. It does not run a browser or call another paid scraping Actor. You can export the dataset as JSON, CSV or Excel and connect its API to your existing workflow.

**Page information only:** this Actor enriches known organization Page URLs; it does not collect Page posts, comments, group content or personal-profile data. Free-plan result events cost **$8 per 1,000 Pages**, plus the start event. A contact field is returned only when the Page exposes it.

### Quick start

Start with a tested example for public Page contacts:

- [Public Facebook Page contacts: NASA, BBC News and Microsoft](https://apify.com/benthepythondev/facebook-pages-scraper/examples/public-facebook-page-contacts)

Open the example and choose **Try for free** to copy its input into your account. Check the input and set a maximum run charge before starting; Actor fees still follow the pricing below. When the run finishes, open the run's dataset and select the **Overview** view and download JSON for nested fields or CSV/Excel for a table.

| Your goal | Input to use |
|---|---|
| Research known organizations | Supply their main public Facebook Page URLs |
| Refresh a company directory | Repeat the same URL list and upsert by `page_id` |

The [real output example](#example-output) shows the record shape. The [Python workflow](#python-api-workflow) saves your own export to a local JSON file with a $0.05 maximum Actor charge.

### Page URL input

```json
{
  "pageUrls": [
    "https://www.facebook.com/NASA/",
    "https://www.facebook.com/BBCNews/",
    "https://www.facebook.com/Microsoft/"
  ],
  "maxResults": 3
}
```

Start with a few known Page URLs, inspect the output, and then increase the cap. The overview table contains the page name, category, follower text, emails, phones, websites and Facebook URL. JSON also contains the description, identity fields, contact provenance and the full collected Intro text.

These are examples of public organizational pages. Their fields can change, and source access can differ by region or route. A successful sample is evidence for that sample; it does not establish that every Facebook URL can be collected without restriction.

### What is supported?

Provide main Page URLs such as `https://www.facebook.com/NASA/`. Mobile and web subdomain variants are normalized to `www.facebook.com`. Numeric Page/profile URLs using `profile.php?id=...` are also accepted when they resolve to a public Page. Tracking parameters on named Page URLs are removed before fetching.

The Actor identifies Facebook's public Page representation, including the newer representation that uses a profile ID linked to a delegated Page ID. It keeps those two IDs in separate fields. This avoids treating an arbitrary visitor or commenter as the business that owns the page.

Inputs for posts, groups, searches, Marketplace and login screens are outside this Actor's scope. Personal profiles are not a supported substitute for Page metadata. A missing or ambiguous Page record causes a failed run rather than a fabricated business record. Use the main Page URL when a copied share link contains several path segments.

### Output fields

| Field | Description |
|---|---|
| `page_id` | Facebook's delegated Page ID, returned as a string |
| `profile_id` | Public profile representation associated with that Page |
| `name`, `url` | Page name and canonical source URL |
| `requested_url` | Normalized URL supplied to the fetch |
| `category` | Page category supplied by Facebook |
| `description` | Public Page description, when present |
| `followers_text`, `following_text` | Display text such as “28M followers” |
| `verified_badge` | Whether the page response exposes the visible verification badge |
| `picture_url` | Public profile image URL where available |
| `emails`, `phones`, `websites` | Contact values published in this Page's Intro records |
| `address` | Intro address text when explicitly identified by the source |
| `contacts` | Contact values with type, source URL and source section |
| `intro_texts` | Other public text collected from the Page Intro |
| `scraped_at` | UTC timestamp of extraction |

Absent contact lists are empty arrays. Other unavailable fields are null. The Actor does not turn an absent website into a guessed domain, expand a rounded follower count into a supposedly exact number, or manufacture a phone number from a business name.

### Example output

One complete record from a verified September 9, 2026 cloud run. Values and public media URLs can change or expire; this is a dated sample.

```json
{
  "page_id": "54971236771",
  "profile_id": "100044561550831",
  "name": "NASA - National Aeronautics and Space Administration",
  "url": "https://www.facebook.com/NASA",
  "requested_url": "https://www.facebook.com/NASA/",
  "category": "Government organization",
  "description": "Explore the universe and discover our home planet. \nThere's space for everybody. ✨",
  "followers_text": "28M followers",
  "following_text": "52 following",
  "verified_badge": true,
  "picture_url": "https://scontent-iad3-2.xx.fbcdn.net/v/t39.30808-1/243095782_416661036495945_3843362260429099279_n.png?stp=dst-png&cstp=mx800x800&ctp=s480x480&_nc_cat=1&ccb=1-7&_nc_sid=2d3e12&_nc_ohc=EW2je1zCzQ4Q7kNvwEvXg6J&_nc_oc=Adr0V-HkuEvMqa6R6YJmdauiucOXwqMP8F0tMsDXd7PYDaWtG7emeJupB-rDDEOw_2c&_nc_zt=24&_nc_ht=scontent-iad3-2.xx&_nc_gid=JCyj3475jdgXawyXTzusYA&_nc_ss=7b289&oh=00_AQLZ4Yx5XbpF1DA39HNiaMlzrQaoH_d_wJAEtbGQFTYa_w&oe=6AA78455",
  "emails": [
    "public-inquiries@hq.nasa.gov"
  ],
  "phones": [],
  "websites": [
    "https://www.nasa.gov/",
    "https://www.nasa.gov/nasa-app/"
  ],
  "address": null,
  "contacts": [
    {
      "type": "email",
      "value": "public-inquiries@hq.nasa.gov",
      "source_url": "https://www.facebook.com/NASA",
      "source_section": "Page Intro"
    },
    {
      "type": "website",
      "value": "https://www.nasa.gov/",
      "source_url": "https://www.facebook.com/NASA",
      "source_section": "Page Intro"
    },
    {
      "type": "website",
      "value": "https://www.nasa.gov/nasa-app/",
      "source_url": "https://www.facebook.com/NASA",
      "source_section": "Page Intro"
    }
  ],
  "intro_texts": [
    "NATIONAL AERONAUTICS AND SPACE ADMINISTRATION",
    "Page · Government organization",
    "nasa.gov",
    "nasa.gov/nasa-app",
    "public-inquiries@hq.nasa.gov"
  ],
  "scraped_at": "2026-09-09T17:54:36.079280+00:00"
}
```

### Contact provenance and quality

Contact extraction is limited to the target Page's own Intro records. Email-like strings in visitor comments or unrelated embedded entities are not treated as the Page's contact. The parser associates the Intro block with the same profile identity as the Page header before collecting values.

Website links sometimes use Facebook's outgoing redirect URL. The Actor unwraps the public destination and preserves the actual website link instead of returning Facebook's redirect wrapper. It does not visit those websites, scrape their contact pages, or guess additional email addresses.

Published does not mean deliverable. This Actor performs no SMTP mailbox verification and makes no claim that a listed phone is current. `verified_badge` reflects a Facebook display field, not independent business verification by this tool. Retain source URLs and check important details before relying on them.

### Limits and duplicate handling

`pageUrls` accepts up to 100 URLs and `maxResults` caps distinct returned Pages from 1 to 100. Exact normalized URLs are deduplicated before fetching; repeated Page IDs are deduplicated before export. Several aliases can therefore result in fewer rows than input URLs.

Requests run sequentially with a short delay. The default run has 512 MB of memory and a five-minute timeout. Large batches or slow source responses can require a longer timeout. Start with a small run and an explicit maximum charge to understand your expected output and cost.

If an HTTP-200 response temporarily lacks a public Page record, the Actor retries the same URL twice with a delay. One persistently inaccessible input causes a failed run. Earlier saved rows remain available in its dataset, so inspect that dataset before rerunning a mixed batch. A failed run should not be interpreted as a complete export. The Actor does not report a private or blocked Page as an empty but successfully scraped business.

### Pricing

Free-plan pricing is **$0.008 per exported Page**, or **$8 per 1,000 Pages**, plus a **$0.00005 start event** at 512 MB. Progressive plan discounts apply. Published contact fields are included in the Page price; there is no separate email, phone or website charge.

At the Free price, three returned Pages cost $0.02405 at 512 MB. Ten returned Pages cost $0.08005. A run that returns no Pages has no dataset-result charge, although the start charge remains. These calculations illustrate the event formula, not guaranteed output. Larger memory settings incur one start event per GB, with a minimum of one.

The Actor stops exporting when Apify reports that the maximum result charge has been reached. No paid external data service is required for the default engine. Optional proxy usage depends on the configuration and allowances of your Apify account; inspect the current pricing panel before a large batch.

### Scheduling and integrations

Save tested input as an Apify Task for repeated snapshots. Schedule that Task at a sensible interval and use the dataset API or an integration to write records to a spreadsheet, database or CRM. `page_id` is the preferred destination key when comparing rows across runs. Preserve `scraped_at` if you need a history of observations.

This version returns the current snapshot on each run. It does not maintain a change-only baseline, collect posts or claim an exhaustive history. Destination-side upserts by `page_id` prevent duplicate business rows when importing another snapshot.

### Python API workflow

Copy the first input JSON above into `input.json` and save this code as `export.py`. In a Python virtual environment, install `apify-client` with `python -m pip install apify-client`. Set `APIFY_TOKEN` to your own Apify token in your environment, then run `python export.py`. Keep the token out of source files and shared screenshots.

```python
import json
import os
from decimal import Decimal
from pathlib import Path

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("benthepythondev/facebook-pages-scraper").call(
    run_input=json.loads(Path("input.json").read_text(encoding="utf-8")),
    max_total_charge_usd=Decimal("0.05"),
    memory_mbytes=512,
    timeout_secs=300,
)
if not run or run["status"] != "SUCCEEDED":
    raise RuntimeError(f"Inspect the run before retrying: {run and run['id']}")

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
Path("facebook-pages.json").write_text(
    json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8"
)
print(f"Saved {len(rows)} records from run {run['id']}")
```

This starts a run in your account, waits for completion and saves `facebook-pages.json`. The $0.05 limit bounds Actor charges; it is not a promised bill or result count. Check the printed run ID and server log if the result is shorter than expected. If your client loses its connection, inspect the existing run in Console before starting another one. See the [official Python client](https://docs.apify.com/api/client/python/) for other run options.

Upsert business rows by `page_id`, keeping `profile_id` separate. Retain each contact's `source_url` and `source_section` in your CRM so a reviewer can trace it. Empty contact arrays are valid. This workflow exports Page information and does not send messages or collect visitor contacts.

For recurring runs without writing a scheduler, copy a tested public Task into your account and attach an Apify Schedule to that copy. Keep its maximum-charge limit and avoid overlapping runs when using monitor state. The Python example above is also suitable for an existing scheduler; run it from the directory containing `input.json` and provide the token through that scheduler's secret settings.

### Support

If an expected public Page fails, open an Actor issue with its URL, the run URL and the expected fields. Do not include login cookies, passwords or private account data. Source layouts and access rules can change; clear examples help reproduce the problem. An honest review after a useful export helps other users assess this Actor.

For businesses discovered by keyword and city, see [Google Maps Business Scraper](https://apify.com/benthepythondev/google-maps-business-scraper). For contacts published on business websites, see [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor). Those products have separate input contracts and pricing.

Keywords: Facebook Pages scraper, Facebook business data, public Page contacts, Facebook Page export, business contact provenance, Facebook pages CSV, Facebook page metadata API.

# Actor input Schema

## `pageUrls` (type: `array`):

Main Page URLs such as https://www.facebook.com/NASA/. Posts, groups, searches and personal profiles are not supported.

## `maxResults` (type: `integer`):

Maximum number of unique Pages exported. Stops at this cap or the run spending limit.

## `proxyConfiguration` (type: `object`):

Uses direct HTTP by default. Supply your own Apify proxy configuration if needed; proxy availability and charges depend on your account.

## Actor input object example

```json
{
  "pageUrls": [
    "https://www.facebook.com/NASA/"
  ],
  "maxResults": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `pages` (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 = {
    "pageUrls": [
        "https://www.facebook.com/NASA/"
    ],
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/facebook-pages-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 = {
    "pageUrls": ["https://www.facebook.com/NASA/"],
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/facebook-pages-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "pageUrls": [
    "https://www.facebook.com/NASA/"
  ],
  "maxResults": 3
}' |
apify call benthepythondev/facebook-pages-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,benthepythondev/facebook-pages-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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