# Facebook Accounts Scraper — Pages, Profiles & Groups (`data-wan/facebook-accounts`) Actor

Scrape Facebook Pages, profiles and groups for contact details, audience, About information and Page transparency when publicly available.

- **URL**: https://apify.com/data-wan/facebook-accounts.md
- **Developed by:** [Data Wan](https://apify.com/data-wan) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.10 / 1,000 account with verified data

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Facebook Accounts Scraper — Pages, Profiles & Groups

Enrich a list of public Facebook accounts with identity, audience counts, contact details
and available About information. This Facebook scraper supports Pages, profiles and public
groups in one batch, returning structured records for research, account matching and
ongoing monitoring. No Facebook login or supplied cookies are needed.

### Why choose this Facebook scraper?

- **One batch for mixed account lists.** Submit up to 1,000 Page, profile and public-group
  references together. Automatic enrichment means no collection modes to choose.
- **Context beyond names and follower counts.** Build richer account records with available
  public About and transparency details, including gender, creation dates and management
  countries where exposed. Availability depends on the account and source response.
- **Useful results even with gaps.** Verified fields survive an unavailable section, so you
  can use partial records while checking exactly which sections have issues.
- **Results you can join back to your list.** Ordered rows preserve every input occurrence,
  including duplicates, with an input index and status for matching results to CRM records.
- **Precision you can assess.** Counts and dates retain source and accuracy or precision;
  unknown values stay distinct from zero, helping you avoid treating estimates as exact facts.

**Pay only for newly collected results with verified account data.** Empty results and
reused observations are free. Partial results are billed too, including an identity-only
result with a verified account ID.

### Pricing

Pay per newly collected result with verified data. Rates per 1,000 results are:

| Apify plan tier | Price per 1,000 |
|---|---:|
| FREE | $3.00 |
| BRONZE | $2.70 |
| SILVER | $2.40 |
| GOLD, PLATINUM, DIAMOND | $2.10 |

There is no minimum charge. Platform usage is included in the event price; this Actor
does not add a separate platform-usage charge. Use the latest build for discounted rates;
older pinned builds may reject discounted runs before collection.

A saved `collected` or `partial` row with a verified `id` is billable when it comes from a
new collection. `unsupported`, `unavailable`, `notProcessed` and rows without a verified
ID are free. A duplicate is free when its row says `reused: true`; references that cannot
yet be proved to identify the same account may require separate collections and charges.
A fresh run is a new observation and may charge again.

Set Apify's **maximum total charge** before starting. Collection reserves the remaining
result allowance; an earlier free result releases its reservation for the next account.
When another result is no longer affordable, the Actor stops new collection. Cached
observations and unsupported inputs can still be returned; other inputs receive
`notProcessed` with `budgetReached`. Consult `remainingInputs` before starting another run.

### Quick start

1. Open this Actor in Apify Console and go to **Input**.

2. In the JSON editor, paste this example:

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

3. Click **Start**, then inspect the results in **Output**. Check each row's `status` before
   using its data.

4. Click **Export** to download the dataset. JSON preserves the nested account details;
   CSV and Excel are also available.

To try a Page, profile and group together, use:

```json
{
  "targets": [
    "https://www.facebook.com/facebook",
    "https://www.facebook.com/zuck",
    "https://www.facebook.com/groups/874728723021553"
  ]
}
```

These are example targets, not a promise that every field will be available when you run them.
Enrichment is automatic: the Actor attempts the supported public sections it can access.
There are no basic/full modes, field-selection switches or proxy settings to configure.

### Supported inputs

`targets` is the only input field. Supply **1–1,000 strings**, each at most 2,048 characters.
You can mix:

- Facebook desktop/mobile account URLs, usernames or `@username` references.
- Numeric IDs, `profile.php?id=<numeric-id>` and `/people/name/<numeric-id>/` URLs.
- Legacy `/pages/name/<numeric-id>/` URLs and group URLs. A bare numeric group ID works
  when Facebook supplies a matching group route.
- Root `pfbid…` and `/people/name/pfbid…/` references. Preserve their exact case;
  these opaque references have limited enrichment, explained below.

Post, reel, event and search URLs are unsupported. This Actor enriches accounts you supply;
it does not search for accounts or collect posts and comments.

### What data can I get?

Availability varies by account and by what Facebook exposes anonymously. Fields below are
possible outputs, not a completeness guarantee.

| Account type | Available public information |
|---|---|
| Pages | Identity, name, URL, images, bio/description, categories, websites, email/phone, address, business hours, services, price/rating text, audience counts, creation dates and transparency information, including management countries and advertising observations |
| Profiles | Identity, name, URL, images, bio/description, audience counts, public contact details, raw public gender value, work, education, places, relationship, Life Events references and available creation/transparency observations |
| Public groups | Identity, name, URL, cover image, description, member count, creation date, privacy/discoverability, rules, topics, locations and aggregate activity |

Public gender is copied as Facebook reports it, including values such as `UNKNOWN`; it is
never inferred from a name or image. About gender/pronouns can appear separately as labeled
observations. Creation dates retain their source and precision; conflicting observations
remain visible. Management countries describe where an account is managed, not the owner's
home or business address. Unknown and opted-out manager counts stay separate.

No private content, member/admin/follower lists or media files are collected. Image and
photo-page URLs are references and may expire or change. Life Events references are not
followed to collect their posts.

### Reading your results

The dataset contains **one row per input occurrence, in input order** when normal storage
completes. Up to four observations can be collected at once; rows are still saved in input
order. Repeated inputs share their observation, including its timestamp and partial/unavailable
outcome. Different references can require separate collection until their returned identity
proves they name the same account. Later proved reuse takes the earlier observation for free;
`reused` identifies those rows. Start a new run when you need a fresh observation.

`inputIndex` is the zero-based input position. `input` is a safe normalized reference;
rejected strings become `unsupported-input`. Resolved identity and canonical URL can differ
from the supplied reference. `id` preserves the observed Header object ID, which can be
numeric or opaque. `facebookId` is the numeric account identity corroborated by this
source observation, or null when that evidence is missing. It describes the resolved
account, even when the input named its linked Page. `linkedPageId` remains that separate
Page's identity; `routeUserId` remains an observation-specific request selector.
These fields do not promise permanent URLs or opaque-token lifetimes, and `facebookId`
does not create additional input aliases or change reuse within a run.

| Row status | Meaning and next step |
|---|---|
| `collected` | Identity verified and supported sections inspected. Use the returned fields; some can still be unknown. |
| `partial` | Useful verified data retained with gaps. Inspect `issues` and `sections` before using it. |
| `unavailable` | No verified account data from this attempt. Check the reference and reported reason. |
| `unsupported` | Unsupported or unsafe reference; no request made for it. Correct the input format. |
| `notProcessed` | Source work stopped before this occurrence, for example after a block, deadline or charge limit. Review the run summary for unfinished inputs. |

**Null is unknown, not zero.** An explicit zero or returned empty list is distinct from
missing data. Counts retain `display`, `accuracy` and `source`: a rounded `1.2K followers`
label does not become an invented exact integer. `exact` means an unabridged source-reported
count, not an independently measured audience. The same distinction applies to group members.

This **synthetic excerpt** illustrates a useful partial result. It is not a live sample;
full rows include additional metadata and run fields, with nulls for unknown values.

```json
{
  "inputIndex": 0,
  "input": "https://www.facebook.com/examplegarden/",
  "id": "123456789",
  "facebookId": "123456789",
  "name": "Example Garden",
  "accountType": "page",
  "followers": {
    "value": null,
    "display": "1.2K followers",
    "accuracy": "approximate",
    "source": "header.followers"
  },
  "creationDates": [
    {
      "value": "2020-01-01T12:00:00Z",
      "precision": "second",
      "source": "transparency.history.CREATION"
    }
  ],
  "transparency": {
    "managerCountries": [{"country": "Canada", "count": 2}],
    "unknownManagerCount": 0,
    "optedOutManagerCount": 0
  },
  "status": "partial",
  "sections": ["header", "about", "transparency"],
  "issues": [{"section": "about_details", "reason": "missingSection"}]
}
```

### Limits and recovery

The first source block or rate limit stops new Facebook requests for the whole run.
Requests already in flight may finish, and verified fields already acquired are retained.
Up to four in-flight results can therefore be saved as billable `partial` rows, including
identity-only results with a verified account ID. An input that sent a source request but
stopped before verified data is free `unavailable` with `blocked`. Inputs blocked before
their first request, without verified identity, and unstarted inputs receive free
`notProcessed` with `blocked`. An unavailable result does not prove an account is private, deleted or nonexistent.
Group privacy must be confirmed public before deeper enrichment.

Each input initially has a 120-second enrichment budget. Under the default 24-hour platform
limit, aggregate source work stops after 23 hours to leave time for saving remaining rows
and cleanup. Shorter platform deadlines reduce source time. Large or slow batches may not
inspect all inputs; hard timeouts and user aborts can interrupt saving too.

The key-value record **`OUTPUT`** summarizes accepted inputs, acknowledged rows, rows with
data, outcomes and `remainingInputs` (indices into your original input). This retry list
contains unacknowledged or `notProcessed` occurrences, including zero-request blocked inputs.
An acknowledged `unavailable` row with an actual attempted request and `blocked` is excluded.
Inspect row outcomes too before deciding what to resubmit.
Detailed metadata lives in dataset rows. The stored summary can lag the dataset during
execution or after a hard kill. An uncertain append is not retried, so a row may exist without acknowledgment.
Billing follows acknowledged row storage. If a charge fails or its response is uncertain,
the run fails technically and keeps already saved data; a charge may still have reached
the platform. The last affordable charge waits until the remaining free rows and a full
running summary are saved. A platform stop at that boundary can leave the summary marked
`running` even though all rows were saved. A hard stop before settlement can leave a saved
result uncharged. Use the dataset and Apify's charge history together; the summary is not
a billing receipt. Inspect and deduplicate existing results before submitting unfinished
inputs in a **fresh run**. There is no in-run resume; existing execution storage is refused.

### FAQ

#### Why is a public account partial or unavailable?

Anonymous access and fields vary. Read `issues` for the affected section and reason.
`protocolError` means the response could not be interpreted; `foreignIdentity` means its
identity could not be verified. Neither proves the account is missing. Opaque `pfbid…`
routes currently retain verified identity and available images only, with partial coverage;
About enrichment across their different identity forms is not verified.

#### Do I need a Facebook account, cookies or a proxy?

No login or imported cookies are accepted. Facebook-issued anonymous cookies stay in memory.
Proxy use for eligible count requests is managed by the Actor; there is no input setting.

#### Why did the run succeed if some rows have no data?

Run success means processing and required storage completed, not that every account was
available. Invalid input envelopes reaching the Actor return `OUTPUT.status=invalidInput`
with no rows; Apify can reject them before a run starts. Configuration, programming,
storage and cleanup errors fail the run technically.

#### How can I automate repeat collection?

Use Apify's API to start runs and retrieve datasets, or schedule recurring runs. See
[Run Actors](https://docs.apify.com/platform/actors/running) and
[Schedules](https://docs.apify.com/platform/actors/running/schedules)
(official guides checked November 8, 2026). Keep each run's observation time when comparing
results: availability and account metadata can change.

#### How do I report a problem?

Open an issue in this Actor's **Issues** tab with the run ID, row status/reason and the
field you expected. Include a public example reference only if appropriate to share.
Do not include credentials, cookies, access tokens or private data.

# Actor input Schema

## `targets` (type: `array`):

1–1,000 public Page, profile or group URLs, usernames or numeric IDs. Each occurrence produces one ordered result row, including duplicates and unavailable accounts.

## Actor input object example

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

# Actor output Schema

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

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

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

```

## MCP server setup

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

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/HrWI5XMqAfKueys7X/builds/y2xSUTQvyNqJtrtT6/openapi.json
