# Facebook Followers Scraper (`scraperoka/facebook-followers-scraper`) Actor

📣 Facebook Followers Scraper pulls follower data from public Facebook pages fast and reliably. ✅ Great for market research, lead generation, and audience insights. 🔎 Export for analysis and outreach. 🚀 Professional results, simple setup.

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

## Pricing

from $0.01 / 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.

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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Followers Scraper 🚀 — Extract Followers From Public Facebook Profiles at Scale

Manually visiting Facebook pages to collect follower lists wastes hours and doesn’t scale. **Facebook Followers Scraper** quickly extracts follower profile data from a public Facebook profile URL, giving you a practical path to build lead lists with a **facebook followers scraper** and **facebook follower scraper tool**. It’s ideal for marketers, recruiters, and growth teams who want **facebook followers count scraper**-style results fast—often thousands of records in minutes.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "url": "https://www.facebook.com/example.person",
  "title": "Example Person",
  "image_uri": "https://example.com/profile.jpg",
  "id": "123456789012345",
  "data_type": "follower",
  "base_url": "https://web.facebook.com/leomessi"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | Direct link to the follower profile page you can open or deduplicate downstream |
| `title` | string | The follower display name extracted alongside the profile link |
| `image_uri` | string | Profile image URL for quick previews and enrichment workflows |
| `id` | string | Stable identifier to deduplicate and join with other datasets |
| `data_type` | string | Helps you confirm the record type (set to `"follower"`) for clean pipelines |
| `base_url` | string | The Facebook profile you started from, so you can trace results back to the source |
| `status` / `error_message` | not present | The actor writes follower items directly to the dataset; if a run fails, you’ll see errors in Apify logs rather than per-item error fields |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Facebook Followers Scraper?

There are a lot of ways to pull follower-related data from Facebook — here’s what sets **Facebook Followers Scraper** apart.

#### Built for follower list extraction workflows

This **facebook followers scraper** is designed specifically to extract follower entries from a Facebook profile’s followers view, making it a focused option for **facebook page followers scraper** use cases.

#### Output includes profile links and media

Each follower record includes `url`, `title`, and `image_uri`, so you’re not just collecting IDs—you also get the information needed for review, enrichment, and exporting.

#### Pagination support for deeper lists

If the target follower list spans multiple pages, the actor supports pagination to keep gathering results until your `maxItems` cap is reached (or no further pages are available).

#### Works with built-in proxy support

Built-in proxy support helps the run stay resilient when scraping publicly available web data at scale—useful for a **facebook follower extractor** workflow.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrl": "https://web.facebook.com/leomessi",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `startUrl` | ✅ | The Facebook profile URL the actor scrapes followers from (example: a public profile page) |
| `maxItems` | ⬜ | Maximum number of follower items to scrape (default is `200`, minimum is `1`) |
| `proxyConfiguration` | ⬜ | Proxy settings used for the run (the actor uses residential proxy groups by default) |
| ↳ `proxy support` | ⬜ | When `true`, route requests through Apify Proxy for reliability |
| ↳ `proxy support` | ⬜ | Proxy group selection (the actor defaults to `["RESIDENTIAL"]`) |

***

### Core Capabilities

#### Profile-first follower extraction

**Facebook Followers Scraper** focuses on extracting follower records as structured items containing profile `url`, `title`, and `image_uri`, so you can quickly turn results into an **export facebook followers** dataset.

#### Flexible run limits for lead building

Set `maxItems` to control how much you collect per run. This is handy when you’re building a shortlist for **facebook followers lead generation** or running smaller tests before scaling.

#### Resilient data collection with retries

The actor includes retries and fallback behavior to handle transient failures and keep runs moving when possible—useful when you’re running a **facebook followers scraper online** workflow.

#### Structured dataset writing as results arrive

Results are pushed to the dataset using `Actor.push_data(..., charged_event_name="result")`. Each follower item includes the same core fields, making downstream processing easier.

#### Automation-friendly for bulk pipelines

Because the actor writes consistent records to your dataset, it pairs well with automation and analysis pipelines—ideal when you want a **facebook engagement scraper**-adjacent dataset for follow-up enrichment.

***

### Who Gets the Most Out of This

**Marketers and growth teams** use Facebook Followers Scraper to build prospect lists from public creator or brand profiles, then export and merge follower data into their outreach workflows. The result is faster **facebook followers scraper** execution without manual tab-switching and copy-paste.

**Recruiters and talent sourcers** can use scraped follower data as an input into sourcing hypotheses—filter by profile identity, then validate manually. It’s a practical way to support **scrape facebook followers** research when building candidate shortlists.

**Sales development reps** can run the actor for target profiles and quickly produce a usable lead pool for outreach and segmentation. With `maxItems`, they control volume while iterating on targeting.

**Data analysts and researchers** benefit from consistent output fields (`url`, `title`, `image_uri`, `id`, plus `data_type` and `base_url`) for deduping and joining against other datasets. This makes the **facebook follower scraper tool** a handy component of broader data collection work.

**Automation specialists and developers** can trigger runs via the Apify platform, then use the dataset as the stable handoff into their ETL or enrichment stack. If you’re looking for a **facebook followers bot**-style workflow, this actor fits naturally into scheduled scraping pipelines.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Facebook Followers Scraper from start to finish:

1. **Open the actor on Apify** — visit the Apify console and open *Facebook Followers Scraper* at [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `startUrl` to the public Facebook profile URL and (optionally) adjust `maxItems`.
3. **Configure proxy settings** — keep the default residential proxy configuration for better scraping reliability on larger lists.
4. **Hit Run and watch the live log** — confirm the actor fetches the followers page and starts collecting items.
5. **View results in the dataset tab** — your dataset will contain follower records with `url`, `title`, `image_uri`, `id`, and more.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dataset view.
7. **Repeat with new sources** — run again for additional profiles to scale your **facebook followers count scraper**-style list building.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Facebook Followers Scraper plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab: **JSON**, **CSV**, and **Excel**. That makes it easy to support **facebook page followers scraper** and **export facebook followers** workflows without writing extra scripts.

You can also connect results to your systems through the Apify ecosystem using integrations and the Apify API. For deeper setup details, refer to [apify.com/docs/api](https://apify.com/docs/api) on the Apify developer documentation, and consider no-code options like Zapier or Make for pushing scraped follower data to downstream tools.

***

### Pricing & Free Trial

Facebook Followers Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free tier to run test extractions and validate the output for your **facebook followers scraper** use case.

After that, you typically pay as you go based on Apify platform compute (CU). For the most up-to-date plan details and how pricing works for your workload, check the Apify pricing page on [apify.com](https://apify.com).

Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Transient failures | Retries and resilience behaviors to improve completion rates |
| Large follower lists | Pagination support to gather results beyond the initial page |
| Scraping stability | Built-in proxy support for more reliable requests |
| Controlled output volume | `maxItems` caps the number of follower items to collect |
| Clean dataset handoff | Each follower item is pushed to the dataset with consistent fields |

Limitations: This actor is intended for **publicly available data**. If the follower list is empty, restricted, or unavailable in the required public view, you may receive fewer items or none for that run. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier with usage credits so you can test Facebook Followers Scraper before scaling up to production runs.

#### Do I need to log in to Facebook to use this?

No login is required for the actor to run, because it extracts follower data from publicly accessible pages. If a profile’s followers view isn’t publicly accessible, results may be limited.

#### How accurate is the data?

The output reflects what’s available from publicly accessible sources and the follower entries that can be collected for the target profile. If certain fields are not present, those specific values may be missing in the resulting dataset.

#### How many results can I get per run?

You control that with `maxItems`. The actor will collect follower items up to your requested cap, and it stops when it reaches the limit or when there are no more pages to paginate.

#### How often is the data updated / how fresh is it?

The data is captured when you run the actor. If follower counts or new followers matter for your **facebook follower extractor** workflow, you’ll want to schedule or rerun at the cadence you need.

#### Is this legal? Does it comply with GDPR / CCPA?

This actor is designed to extract **publicly available data**. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations for how you store, process, and use the collected data.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dashboard. From there, you can load it into Google Sheets or other tools as needed.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actors to run automatically on a cadence that fits your research or lead generation workflows. Use the Apify platform scheduling features for automation setup.

#### Can I access this via API?

Yes. You can trigger runs and retrieve results programmatically via the Apify API. See [apify.com/docs/api](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

If the actor encounters issues, you’ll see logs in the Apify run logs and the actor will stop collecting further items for that run. Partial results may still be available depending on when the failure happens, but the dataset is populated as items are pushed.

***

### Need Help or Have a Request?

Got a question about Facebook Followers Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and can discuss improvements like batch **facebook followers scraper** runs and webhook notifications when jobs complete.

***

### Disclaimer & Responsible Use

*Facebook Followers Scraper is the fastest, most reliable way to extract follower profile data from public Facebook views — start your free run today.*\
This actor collects **publicly available data** and does not access private profiles, login-gated content, or password-protected pages. You are responsible for ensuring GDPR, CCPA, platform ToS, and any applicable legal requirements are followed. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `startUrl` (type: `string`):

The URL of the Facebook profile to scrape followers from.

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

Maximum number of followers to scrape.

## Actor input object example

```json
{
  "startUrl": "https://web.facebook.com/leomessi",
  "maxItems": 200
}
```

# 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 = {
    "startUrl": "https://web.facebook.com/leomessi"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/facebook-followers-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 = { "startUrl": "https://web.facebook.com/leomessi" }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/facebook-followers-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 '{
  "startUrl": "https://web.facebook.com/leomessi"
}' |
apify call scraperoka/facebook-followers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Followers Scraper",
        "description": "📣 Facebook Followers Scraper pulls follower data from public Facebook pages fast and reliably. ✅ Great for market research, lead generation, and audience insights. 🔎 Export for analysis and outreach. 🚀 Professional results, simple setup.",
        "version": "1.0",
        "x-build-id": "HJPH5RW7SgRtM4U43"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-followers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-facebook-followers-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/scraperoka~facebook-followers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-facebook-followers-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/scraperoka~facebook-followers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-facebook-followers-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": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Facebook Profile URL",
                        "type": "string",
                        "description": "The URL of the Facebook profile to scrape followers from."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of followers to scrape.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
