# Facebook Followers/Following Scraper (`thenetaji/facebook-followers-following-scraper`) Actor

List the accounts following a public Facebook Page, or the accounts that Page follows. Returns each account's name, profile link and verification status, with the Page's own reported total on every row. Optionally fetch each listed account's full profile.

- **URL**: https://apify.com/thenetaji/facebook-followers-following-scraper.md
- **Developed by:** [The Netaji](https://apify.com/thenetaji) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 1,000 results

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 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 Followers/Following Scraper

The Actor lists the accounts following a public Facebook Page, or the accounts that Page itself follows, exactly as Facebook shows them to a logged-out visitor. No Facebook account, login, or session cookie is used; nothing is read that an anonymous visit to the Page's Followers or Following tab would not already show.

### Accepted input

`page` is required and accepts a list of Page usernames, numeric IDs, or full `facebook.com/<page>/` URLs, one per line; duplicates are collapsed before any request is made. `collection` chooses which list is read — `followers` (default) or `following`. `maxItems` (default `50`) bounds the number of accounts saved per Page; `0` continues until Facebook stops returning a next page.

```json
{
  "page": ["NASA", "https://www.facebook.com/unicef/"],
  "collection": "followers",
  "maxItems": 100
}
```

### Result fields

Each row carries `page`, `id`, `name`, `subtitle`, `url`, `isVerified`, `imageUrl`, `totalCount`, and `raw`. `raw` carries the complete record Facebook returned, beyond what appears in the fields above.

The example below illustrates field shapes; it is not captured from a live run.

```json
{
  "page": "NASA",
  "id": "100064467884671",
  "name": "Jane Whoever",
  "subtitle": null,
  "url": "https://www.facebook.com/jane.whoever",
  "isVerified": false,
  "imageUrl": "https://scontent.xx.fbcdn.net/v/...",
  "totalCount": 41823012
}
```

`subtitle` is Facebook's own secondary line beneath the name where the list entry carries one — a mutual-friend count or shared network, typically — and is `null` when it does not. `isVerified` reflects whether the account carries Facebook's verification badge, not whether it follows under a real name.

### How much of a list is returned

Facebook's followers and following surface pages 8 accounts at a time. The Actor walks that pagination automatically, request after request, until `maxItems` is reached, Facebook stops returning a next page, or a cursor repeats. Facebook also reports a total count for the collection alongside the first page it serves. That figure is stamped on `totalCount` on **every row the run produces** — not logged once and left out of the export — so an exported CSV still shows how large the collection was against however many rows were actually saved. It can be larger than the number of rows a run produces — when `maxItems` is reached first, or when Facebook's pagination stops advancing before the reported figure.

### Fetching each account's full profile

`addonAccountProfile` (default `false`) is opt-in. When set, each listed account's own Page record and About details are fetched and attached under `accountProfile` on that row, on top of the thin record the followers or following list itself carries.

This costs one extra request per row, billed as an additional event at $0.006 per row, on top of the Actor's usual per-result price. It is charged only for a row that is actually enriched; a lookup that fails is not billed. It defaults to off, so a run that only needs names and links is not charged for it.

```json
{
  "page": "NASA",
  "collection": "followers",
  "addonAccountProfile": true
}
```

### Behaviour on partial results

Each Page's list is a separate paginated series of requests. A Page that cannot be resolved — because the username or ID does not exist, or the Page is not public — is logged as a warning and skipped, and the run continues with the rest of the list.

### Public, logged-out data only

Everything returned here is visible on a Page's own Followers or Following tab to somebody who is not signed in. The Actor does not use a Facebook account, login, or cookie, and returns nothing for a Page whose Followers or Following list is not publicly visible.

### Frequently asked questions

**Why does a Page report more followers than the run collected?**
Facebook states the collection's total on the first page independently of how far the pagination actually gets before stopping. A `maxItems` bound reached first, or a page that repeats a cursor instead of advancing to a new one, ends the run before `totalCount` is reached — a difference in how far the pagination got, not a parsing gap.

**Can followers and following be collected in the same run?**
Not in a single run: `collection` selects one list. Run the Actor twice, once with each value, to get both.

**What does `addonAccountProfile` cost on a bulk job?**
One extra request and one billable event per row, at $0.006 a row. On a large export that is the dominant cost — a 10,000-row job with the add-on on is 10,000 extra requests. Export the thin list first, then enrich only the accounts worth the extra depth.

**Is a Facebook account or login required?**
No. Only the Followers and Following tabs, and the listed accounts' own public profiles when `addonAccountProfile` is on, are read — all of it visible to a logged-out visitor.

### What this is useful for

Sizing and sampling a Page's follower base for competitor or partner research; checking who a Page follows to map its network of affiliated accounts; and building a lightweight audience snapshot without needing Business Manager access to the Page.

### Related Actors

| Actor | Purpose |
| --- | --- |
| [Facebook Page Scraper](https://apify.com/thenetaji/facebook-page-scraper) | Profile, About and Transparency details for a Page |
| [Facebook Posts Scraper](https://apify.com/thenetaji/facebook-posts-scraper) | Timeline posts for a Page |
| [Facebook Marketplace Scraper](https://apify.com/thenetaji/facebook-marketplace-scraper) | Marketplace listings by category |

# Actor input Schema

## `page` (type: `array`):

Facebook Page usernames, numeric IDs, or full facebook.com/<page>/ URLs, one per line.

## `collection` (type: `string`):

Collect the accounts following the Page, or the accounts the Page itself follows.

## `addonAccountProfile` (type: `boolean`):

Swap each follower/following row's thin record for that account's full public profile and About details. Adds one request and a billable event per row.

## `maxItems` (type: `integer`):

Maximum accounts to save per Page. Set `0` to continue until no further accounts are available.

## Actor input object example

```json
{
  "page": [
    "NASA",
    "https://www.facebook.com/unicef/"
  ],
  "collection": "followers",
  "addonAccountProfile": false,
  "maxItems": 20
}
```

# Actor output Schema

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

All records scraped by this run

# 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 = {
    "page": [
        "NASA"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("thenetaji/facebook-followers-following-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 = {
    "page": ["NASA"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("thenetaji/facebook-followers-following-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 '{
  "page": [
    "NASA"
  ],
  "maxItems": 20
}' |
apify call thenetaji/facebook-followers-following-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thenetaji/facebook-followers-following-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/FlQuwe3TDjBhrwagN/builds/Akj89KMlFhamEqmXv/openapi.json