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

Scrape Facebook Page and Profile followers, following, and friends previews plus aggregate follower/following counts, with structured location/workplace/school parsing. No login, cookies, or proxy required.

- **URL**: https://apify.com/crawlerbros/facebook-followers-following-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Followers & Following Scraper

Scrape **Facebook** followers, following, and friends previews for any public Page or Profile — no login, no cookies, and no proxy required. Get up to 8 real preview rows per target (name, profile URL, verification badge, location/workplace/school where shown) plus the account's aggregate follower and following counts, straight from Facebook's own logged-out preview.

### Important: Facebook's 8-row preview cap

Facebook does not expose a full follower/following/friends roster to logged-out visitors — only a fixed preview of **up to 8 rows per target**, regardless of the target's real follower count (confirmed identically on accounts ranging from 2K to 62M followers). This actor always returns exactly what Facebook itself shows on the page: the 8-row preview plus the account's aggregate counts. It never promises — and cannot deliver — a complete roster. If you need every one of a target's 10,000+ followers, no tool (including this one) can honestly provide that without the target's own login session.

### What this actor does

- **Three modes:** `followers`, `following`, `friends` (friends is only meaningful for Profile URLs)
- **Batch input:** scrape any number of Facebook Page or Profile URLs in a single run
- **Structured parsing:** location, workplace, and school pulled out of Facebook's free-text subtitle line where it shows one
- **Aggregate counts:** follower/following totals, both as Facebook's abbreviated string (e.g. `39M`) and as a parsed integer
- **Explicit access states:** every target reports whether it returned real results, is private, doesn't exist, or was blocked — a restricted target is never silently mistaken for zero followers
- **No login, no cookies, no proxy** — works out of the box on the free Apify plan
- Empty fields are omitted, not returned as `null`

### Output

Every target produces up to 8 row records plus exactly 1 target summary record.

#### Row fields (`recordType`: `follower` / `following` / `friend`)

- `name` — the follower/following/friend's display name
- `profileUrl` — direct link to their Facebook profile/Page
- `imageUrl` — their profile picture URL
- `isVerified` — `true` if Facebook shows a verification badge on this account
- `location` — parsed location, when Facebook's subtitle line recognizably shows one (e.g. "Lives in ...", "From ...", or a bare "City, Region")
- `worksAt` — parsed workplace, when Facebook's subtitle line starts with "Works at ..."
- `studiedAt` — parsed school, when Facebook's subtitle line starts with "Studied at ..."
- `subtitleRaw` — the raw, unparsed subtitle text Facebook showed under this row, kept for transparency even when `location`/`worksAt`/`studiedAt` couldn't be confidently parsed
- `accessState` — the access state of the target this row came from (see below)
- `sourceUrl` — the exact followers/following/friends page URL that was fetched
- `targetUrl` — the original Page/Profile URL from your input
- `scrapedAt` — ISO 8601 timestamp of when this row was scraped
- `recordType` — `follower`, `following`, or `friend`, matching the selected mode

#### Target summary fields (`recordType`: `targetSummary`)

- `targetUrl` — the original Page/Profile URL from your input
- `mode` — the mode that was run for this target: `followers`, `following`, or `friends`
- `accessState` — one of `results` (rows were returned), `empty_valid` (Facebook shows a genuine "no followers/results" message), `private_or_restricted` (target is privacy-restricted), `not_found` (target doesn't exist or isn't reachable), `login_required` (Facebook demanded a login), `checkpoint_or_challenge` (Facebook served a bot-challenge/checkpoint page instead of the target), `schema_failure` (an unrecognized page layout that doesn't match any known state), or `fetch_failed` (the request itself failed after retries)
- `returnedCount` — how many preview rows were returned for this target (0-8)
- `followersCount` — the target's aggregate follower count, as a parsed integer
- `followersCountFormatted` — the target's aggregate follower count, as Facebook's own abbreviated string (e.g. `39M`)
- `followingCount` — the target's aggregate following count, as a parsed integer
- `followingCountFormatted` — the target's aggregate following count, as Facebook's own abbreviated string
- `scrapedAt` — ISO 8601 timestamp of when this target was scraped
- `recordType` — always `targetSummary`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `[{"url": "https://www.facebook.com/nike"}]` | One or more Facebook Page or Profile URLs, e.g. `https://www.facebook.com/nike`, `https://www.facebook.com/zuck`, or `https://www.facebook.com/profile.php?id=...` |
| `mode` | string | `followers` | Which preview list to fetch: `followers`, `following`, or `friends` (Profile URLs only) |

#### Example: followers preview for multiple brand Pages

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/nike" },
    { "url": "https://www.facebook.com/Starbucks" },
    { "url": "https://www.facebook.com/BBCNews" }
  ],
  "mode": "followers"
}
```

#### Example: who a Page is following

```json
{
  "startUrls": [{ "url": "https://www.facebook.com/nike" }],
  "mode": "following"
}
```

#### Example: a Profile's friends preview

```json
{
  "startUrls": [{ "url": "https://www.facebook.com/zuck" }],
  "mode": "friends"
}
```

### Use cases

- **Social media monitoring** — track a competitor Page's follower growth and following list over time
- **Influencer & partnership vetting** — spot-check a Profile's or Page's follower quality and verification status before a partnership
- **Market research** — sample which brands, media outlets, or public figures a Page follows
- **Lead enrichment** — pull location/workplace signals surfaced on public follower/friend previews
- **Audience overlap analysis** — compare the follower previews of multiple related Pages
- **Compliance & brand safety** — confirm a Page's public-facing follower counts match what's advertised elsewhere

### FAQ

**Why only 8 results per target?**
This is a Facebook platform limit on the logged-out preview, not a limitation of this actor. Facebook caps the followers/following/friends preview shown to non-logged-in visitors at 8 rows regardless of the target's true follower count — see "Important" above.

**Why is a field missing for some rows?**
Facebook only shows a location/workplace/school subtitle for some accounts, never all. This actor only includes fields Facebook actually exposes — it never fabricates placeholder values.

**Does this work on private profiles?**
No. A privacy-restricted or blocked target returns no rows, with an `accessState` of `private_or_restricted`, `not_found`, or `checkpoint_or_challenge` depending on exactly how Facebook responds, matching what a logged-out visitor would see in a browser.

**Do I need a Facebook account, cookies, or a proxy to use this actor?**
No. It works entirely through Facebook's public, logged-out pages — no login, no cookies, and no proxy configuration needed to get started.

**Can I get a target's full follower list, not just the preview?**
No. Facebook does not expose a complete roster to logged-out visitors under any circumstances, so no tool — including this one — can honestly deliver more than the 8-row preview without the target's own login session.

**What does `friends` mode return for a Facebook Page?**
Nothing useful — `friends` is a Profile-only concept on Facebook. Use `friends` mode only with personal Profile URLs.

**Is this actor affiliated with Facebook or Meta?**
No. This is an independent, third-party actor that reads Facebook's own publicly accessible pages; it is not affiliated with, endorsed by, or operated by Meta Platforms, Inc.

**How fresh is the data?**
Every run fetches the target's live followers/following/friends page at request time — there's no caching, so results reflect what Facebook shows at the moment the actor runs.

# Actor input Schema

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

One or more Facebook Page or Profile URLs (e.g. https://www.facebook.com/nike, https://www.facebook.com/zuck, or https://www.facebook.com/profile.php?id=...).

## `mode` (type: `string`):

Which preview list to fetch. 'friends' is only meaningful for Profile URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/nike"
    }
  ],
  "mode": "followers"
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped follower/following/friend rows and per-target summary records.

# 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": [
        {
            "url": "https://www.facebook.com/nike"
        }
    ],
    "mode": "followers"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "startUrls": [{ "url": "https://www.facebook.com/nike" }],
    "mode": "followers",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/nike"
    }
  ],
  "mode": "followers"
}' |
apify call crawlerbros/facebook-followers-following-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/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/iyfIgeE5pdvuJsVZ2/builds/Rr4S5nFUPCTEkUJYl/openapi.json