# Facebook Reels Scraper (`data_minds/facebook-reels-scraper`) Actor

Facebook Reels Scraper extracts captions, play counts, reactions, hashtags and HD/SD video links — scrape Facebook Reels in bulk for analytics, influencer research, monitoring and short-video content export.

- **URL**: https://apify.com/data\_minds/facebook-reels-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.

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 Reels Scraper: Captions, Engagement, HD Links & Bulk Download

**Scrape Facebook Reels** from public pages, profiles, or single reel links — captions, play counts, reactions, comments, shares, music, hashtags, and **HD/SD video URLs** in one clean dataset.

🔗 **Paste Facebook URLs or usernames → Start → watch reels stream into Output in real time.**

***

### 📑 Table of Contents

- [What Is Facebook Reels Scraper?](#-what-is-facebook-reels-scraper)
- [What Data Can You Extract From Facebook Reels?](#-what-data-can-you-extract-from-facebook-reels)
- [How It Works](#-how-it-works)
- [How to Use (Apify Console)](#-how-to-use-apify-console)
- [Input Parameters](#-input-parameters)
- [Output Example](#-output-example)
- [Related Actors & Workflows](#-related-actors--workflows)
- [Frequently Asked Questions](#-frequently-asked-questions)
- [Support & Contact](#-support--contact)

***

### 🎁 What Is Facebook Reels Scraper?

**Facebook Reels Scraper** is an [Apify Actor](https://apify.com/actors) built to **scrape Facebook Reels** at scale without a browser login wall for public content. It is a purpose-built **Facebook Reels data extractor** / **Facebook short video scraper**: give it page URLs, profile usernames, reel links, share links, or `fb.watch` URLs, and it returns structured **Facebook Reels metadata** — caption text, **Facebook Reels engagement** (plays, reactions, comments, shares), thumbnails, music, hashtags, mentions, and author details.

Use it for **influencer analytics**, **competitor analysis**, **Facebook Reels monitoring**, content archiving, and research pipelines. Because it runs on the **Apify platform**, you get scheduling, run monitoring, a REST API for every **Facebook Reels dataset**, webhooks, and export to **Facebook Reels to CSV** / Excel / JSON — so **bulk Facebook Reels** collection fits Make, Zapier, Sheets, or your own stack.

This is **not** a fragile screenshot tool. It is a practical **Facebook Reels API**-style workflow for teams that need repeatable **Facebook Reels export**, optional **Facebook Reels HD download**, and clean rows ready for analytics — including **Meta Reels scraper** style research without building your own crawler.

***

### 📊 What Data Can You Extract From Facebook Reels?

For **social media scraper** workflows and **Facebook Reels analytics**, one run can deliver:

- 📝 **Caption & context** — reel text, post time, hashtags, mentions, sponsored / reshare / AI flags.
- 📊 **Facebook Reels engagement** — **Facebook Reels play count**, reactions, comments, and shares.
- 🎬 **Media** — duration, thumbnail, HD and SD video URLs (plus optional permanent **Facebook Reels MP4 download**).
- 🎵 **Music & creator** — music title, author name / username, verified flag, profile links.
- 🔗 **Identity** — reel URL, reel id, post id, and related profile context.
- 🧾 **Run hygiene** — optional profile summary rows and error rows so failed inputs stay auditable.

Use **download Facebook Reels** runs for archiving, **Facebook Reels bulk download** for creative research, or feed **Facebook Reels JSON export** into dashboards for **influencer analytics** and **competitor analysis**.

***

### 🔧 How It Works

1. **Add your targets.** Paste Facebook page/profile/reel/share/`fb.watch` URLs and/or usernames (bulk supported; duplicates are removed).
2. **Set limits & filters.** Cap reels per run, date windows, play-count floors/ceilings, and duration filters.
3. **Optionally download videos.** Turn on HD/SD **Facebook Reels downloader** mode to store MP4s in the key-value store.
4. **The Actor resolves each target.** Profiles open their Reels feed; single reel links resolve to one full record.
5. **Matching reels stream live.** Rows appear in Output as soon as they are ready — Reels, Profile summary, and Errors views.
6. **Export or automate.** Download JSON/CSV/Excel or pull the dataset via the Apify API on a schedule for ongoing **Facebook Reels monitoring**.

***

### 🚀 How to Use (Apify Console)

1. Open this Actor in [Apify Console](https://console.apify.com/actors).
2. Paste **Facebook** page / profile / reel URLs (or usernames).
3. Set **Results limit**, optional date / popularity filters, and download toggles.
4. Leave proxy on automatic escalation, or force your own proxy.
5. Click **Start** and watch the **Output** tab fill with **Facebook Reels data**.
6. Switch views (Reels / Profile summary / Errors) and export, or connect Sheets / Make / Zapier.

#### 🤖 Quick API example

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items" \
     -H "Authorization: Bearer $APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "startUrls": [{"url": "https://www.facebook.com/LeonardoDiCaprio"}],
       "resultsLimit": 20
     }'
```

***

### 🧩 Input Parameters

#### 🎯 Targets

| Field | Type | Description | Default |
|---|---|---|---|
| `startUrls` | array | Facebook pages, profiles, reels, share links, `fb.watch`, or bare usernames — core input for this **Facebook Reels scraper**. | example prefill |
| `usernames` | array | Extra bare usernames / numeric IDs. | none |

#### 📏 How Much to Scrape

| Field | Type | Description | Default |
|---|---|---|---|
| `resultsLimit` | integer | Max reels to keep (`0` = all). | `100` |
| `onlyPostsNewerThan` / `onlyPostsOlderThan` | string | Date / relative window for **Facebook Reels monitoring**. | none |
| `maxPages` / `maxProfiles` | integer | Optional batch / profile caps. | `0` |

#### 🔍 Popularity & Length Filters

| Field | Type | Description | Default |
|---|---|---|---|
| `minPlayCount` / `maxPlayCount` | integer | Filter by **Facebook Reels play count**. | none |
| `minDurationSeconds` / `maxDurationSeconds` | number | Keep only reels in this duration band. | none |

#### ⬇️ Video & Output Shaping

| Field | Type | Description | Default |
|---|---|---|---|
| `downloadVideos` | boolean | Permanent **Facebook Reels HD download** / SD MP4 to key-value store. | `false` |
| `videoQuality` | string (`hd` | `sd`) | Quality for **download Facebook Reels**. | `hd` |
| `includeDashManifest` | boolean | Keep DASH manifest details when available. | `true` |
| `includeRawNode` | boolean | Include raw node payload for power users. | `false` |
| `includeProfileSummary` | boolean | Emit per-target summary rows. | `true` |
| `includeErrorRows` | boolean | Emit error rows for failed inputs. | `true` |

#### ⚡ Performance & Access

| Field | Type | Description | Default |
|---|---|---|---|
| `language` | string | UI language preference. | `en-US` |
| `concurrency` | integer | Parallel targets. | `3` |
| `proxyConfiguration` | object | Optional; auto-escalates if Facebook pushes back. | no proxy |
| `maxRetries` / delays / timeout | number | Resilience dials. | sensible defaults |

***

### 📦 Output Example

Each matching reel becomes **one JSON object** in your dataset as soon as it is collected.

```json
{
  "recordType": "reel",
  "reelId": "1234567890123456",
  "reelUrl": "https://www.facebook.com/reel/1234567890123456",
  "text": "Behind the scenes from today's shoot 🎬",
  "time": "2026-09-01T18:22:10.000Z",
  "playCount": 1250000,
  "reactionCount": 8400,
  "commentCount": 620,
  "shareCount": 310,
  "durationSeconds": 28.4,
  "thumbnailUrl": "https://…",
  "videoUrlHd": "https://…",
  "videoUrlSd": "https://…",
  "hashtags": ["#bts", "#filming"],
  "mentions": [],
  "authorName": "Example Creator",
  "authorUsername": "examplecreator",
  "authorVerified": true,
  "musicTitle": "Original audio",
  "success": true,
  "scrapedAt": "2026-09-15T12:00:00.000Z"
}
```

#### 🗂️ Dataset views

| View | What you see |
|---|---|
| 🎬 **Reels** | Captions, engagement, media URLs, music, hashtags — main **Facebook Reels export** |
| 👤 **Profile summary** | Per-target found / saved / filtered counts |
| ⚠️ **Errors** | Inputs that failed, with a clear reason |

***

### 🔗 Related Actors & Workflows

| Goal | How this Actor helps |
|---|---|
| **Scrape Facebook Reels** from many creators | Paste many `startUrls` / usernames |
| **Facebook Reels analytics** & ranking | Sort/filter exports by play count & engagement |
| **Facebook Reels bulk download** | Enable `downloadVideos` for MP4 archiving |
| Ongoing **Facebook Reels monitoring** | Schedule the **Apify Facebook Reels** Actor daily |
| Page contact / business data (not reels) | Use the sibling **Facebook Pages Scraper** |

If you only need a single reel opened in the browser, Facebook itself is enough. This Actor is for teams that need structured **Facebook Reels metadata**, repeatable **Facebook video scraper** runs, and automation — a practical **Facebook Reels API** alternative for research and archiving.

***

### ❓ Frequently Asked Questions

#### 🎥 What is a Facebook Reels scraper?

A **Facebook Reels scraper** collects public reel captions, **Facebook Reels engagement**, media links, and creator fields into a structured **Facebook Reels dataset**. This Actor is built specifically to **scrape Facebook Reels** for analytics and automation.

#### 📥 Can I download Facebook Reels as MP4?

Yes. Enable video download and choose HD or SD for a permanent **Facebook Reels MP4 download** in the key-value store — useful because CDN links can expire. That is the built-in **Facebook Reels downloader** mode.

#### 📊 Does it capture Facebook Reels play count and engagement?

Yes. Each reel can include play count, reactions, comments, and shares — the core of **Facebook Reels analytics** and **influencer analytics**.

#### 🔗 What URLs does the Facebook short video scraper accept?

Page URLs, profile URLs, reel URLs, share links, `fb.watch` links, and bare usernames. That covers most **Facebook share link scraper** / **fb.watch scraper** needs in one input list.

#### 🔓 Do I need a Facebook login?

No. This Actor scrapes **public** pages and profiles signed-out. Private or login-walled Reels are out of scope — enable Apify Proxy if a public page is blocked, then re-run.

#### 🛡️ Is scraping Facebook Reels legal?

This Actor works with **publicly available** Facebook content. You remain responsible for Facebook’s terms, applicable laws, and how you use personal data (GDPR/CCPA and similar). This is not legal advice.

#### ⏱️ Can I schedule Facebook Reels monitoring?

Yes. Apify Schedules let you re-run hourly/daily for ongoing **Facebook Reels monitoring**, competitor tracking, and content archiving.

#### 🧹 How do I keep only high-performing reels?

Set `minPlayCount` (and optional duration filters) so your **Facebook Reels to Excel** / CSV export stays focused on the clips that matter.

***

### 🙋 Support & Contact

Found a bug, need a new field, or want a **custom solution** built around this **Facebook Reels scraper** / **Facebook Reels data extractor**?

Reach out via the **Issues** tab on this Actor’s Apify Store page, or email **[hello.dataminds@gmail.com ](mailto:hello.dataminds@gmail.com)** for custom builds, integrations, and feature requests.

Feedback is welcome — this Actor is actively maintained for teams that need reliable **Facebook Reels export**, **Meta Reels scraper** workflows, and clean **social media scraper** pipelines.

# Changelog

This Actor's version history is a separate document: https://apify.com/data\_minds/facebook-reels-scraper/changelog.md

# Actor input Schema

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

One or more Facebook links — bulk paste supported. Accepted formats:<br>📄 Page / profile: <code>https://www.facebook.com/LeonardoDiCaprio/</code><br>🎞️ Reels tab: <code>https://www.facebook.com/LeonardoDiCaprio/reels/</code><br>🆔 Numeric profile: <code>https://www.facebook.com/profile.php?id=100044203430980</code> or <code>people/Name/123456789</code><br>🎬 Single reel: <code>https://www.facebook.com/reel/31939704905645094</code> or <code>/videos/\<id></code><br>🔗 Share links: <code>https://www.facebook.com/share/r/…</code>, <code>fb.watch/…</code><br>👤 Bare usernames such as <code>LeonardoDiCaprio</code> work too.<br><strong>At least one URL here or one username below is required.</strong>

## `usernames` (type: `array`):

✨ One username or numeric profile ID per line — bulk paste supported. Each is turned into a full profile URL automatically, e.g. <code>Cristiano</code>, <code>nike</code>, <code>100044203430980</code>. Use this instead of (or together with) the URL list above.

## `resultsLimit` (type: `integer`):

Stop after this many reels for each page or profile. <code>0</code> = every reel the page has. Start low (10–50) to test, then scale up. Single-reel URLs always return exactly one record.

## `onlyPostsNewerThan` (type: `string`):

Only keep reels posted on or after this date. Absolute <code>YYYY-MM-DD</code> / ISO timestamp (<code>2025-09-23T10:02:01</code>, UTC) or relative like <code>3 days</code>, <code>2 weeks</code>, <code>6 months</code>, <code>1 year</code>. Pagination stops automatically once the feed gets older than this, saving time and cost.

## `onlyPostsOlderThan` (type: `string`):

Only keep reels posted on or before this date — combine with the field above to scrape an exact date range. Same formats: <code>YYYY-MM-DD</code>, ISO timestamp, or relative (<code>1 month</code>).

## `minPlayCount` (type: `integer`):

Skip reels with fewer plays than this. Leave empty / <code>0</code> for no minimum. Great for surfacing only viral content.

## `maxPlayCount` (type: `integer`):

Skip reels with more plays than this. Leave empty / <code>0</code> for no maximum.

## `minDurationSeconds` (type: `number`):

Skip reels shorter than this many seconds. Leave empty / <code>0</code> for no minimum.

## `maxDurationSeconds` (type: `number`):

Skip reels longer than this many seconds. Leave empty / <code>0</code> for no maximum.

## `downloadVideos` (type: `boolean`):

When ON, each reel's MP4 (progressive, with audio) is downloaded and saved to this run's key-value store with a public download link in <code>downloadedVideoUrl</code>. Facebook's own video URLs expire after a few hours — this gives you a link that keeps working. ⚠️ Slower and uses more bandwidth; raise the Actor memory for big batches.

## `videoQuality` (type: `string`):

Which progressive MP4 to download when video download is ON. HD falls back to SD when Facebook only offers SD.

## `includeDashManifest` (type: `boolean`):

Keep the complete <code>playback\_video</code> block including the DASH manifest XML (every video/audio rendition with direct URLs). Adds ~10–25 KB per reel. Turn OFF for a leaner dataset — the parsed <code>videoQualities</code> list and HD/SD URLs stay either way.

## `includeRawNode` (type: `boolean`):

Attach the complete raw reel object under <code>raw</code> — for power users and debugging, or if a field you need isn't mapped yet.

## `includeProfileSummary` (type: `boolean`):

Emit one bookkeeping record per input URL (<code>recordType: "profileSummary"</code>) with reels found / saved / filtered, batches walked and why scraping stopped — shown in its own <em>Profile summary</em> view of the Output tab. These rows are never charged.

## `includeErrorRows` (type: `boolean`):

Emit one record (<code>recordType: "error"</code>, <code>success: false</code>) for every input URL that could not be scraped, with a plain-English reason — shown in the <em>Errors</em> view. Never charged.

## `language` (type: `string`):

Accept-Language sent to Facebook (affects localized labels such as privacy). Default <code>en-US</code>.

## `concurrency` (type: `integer`):

How many pages/profiles are scraped at the same time. 2–5 is a good balance between speed and staying under Facebook's radar.

## `maxProfiles` (type: `integer`):

Cap the merged, de-duplicated worklist to the first N targets. <code>0</code> = process everything you pasted.

## `minRequestDelay` (type: `number`):

A polite randomized pause is taken before every request, between this and the maximum below.

## `maxRequestDelay` (type: `number`):

Upper bound of the randomized pause. Raise both delays if you see a lot of retry / backoff activity in the log.

## `maxRetries` (type: `integer`):

How many times one failed / rate-limited request is retried (with backoff) before giving up on it. The residential proxy tier always gets at least 3 full attempts per page.

## `requestTimeout` (type: `integer`):

How long to wait for one response. Reels pages are large (10–20 MB), so keep this generous.

## `maxPages` (type: `integer`):

Safety valve: hard cap on how many batches (≈10 reels each) are loaded per page or profile. <code>0</code> = no cap (until the limit / date range / end of feed).

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

🚦 Default is NO proxy — the Actor talks to Facebook directly. If Facebook ever rejects or blocks a request, it escalates automatically step by step: 🚫 no proxy → 🖥️ datacenter proxy → 🏠 residential proxy (retrying up to 3× on residential), then sticks with residential for the rest of the run. Every escalation is logged clearly. Force a tier here if you already know what you need (residential is the most reliable for Facebook).

## `debug` (type: `boolean`):

Log every retry / backoff with details. Handy when reporting an issue.

## `paginationDocId` (type: `string`):

Internal — leave empty.

## `paginationFriendlyName` (type: `string`):

Internal — leave empty.

## `graphqlPageSize` (type: `integer`):

Internal — leave at the default.

## `extraRelayFlags` (type: `object`):

Internal — leave empty.

## `urls` (type: `array`):

Plain-string alias of startUrls for API callers.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/LeonardoDiCaprio/",
    "https://www.facebook.com/reel/31939704905645094"
  ],
  "usernames": [
    "Cristiano",
    "nike"
  ],
  "resultsLimit": 20,
  "onlyPostsNewerThan": "2025-01-01",
  "onlyPostsOlderThan": "2025-12-31",
  "downloadVideos": false,
  "videoQuality": "hd",
  "includeDashManifest": true,
  "includeRawNode": false,
  "includeProfileSummary": true,
  "includeErrorRows": true,
  "language": "en-US",
  "concurrency": 3,
  "maxProfiles": 0,
  "minRequestDelay": 0.5,
  "maxRequestDelay": 1.5,
  "maxRetries": 3,
  "requestTimeout": 60,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debug": false,
  "graphqlPageSize": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Every scraped record together, in scrape order.

## `reels` (type: `string`):

Only reel records — caption, engagement, video & thumbnail links, music, hashtags and author details.

## `profileSummary` (type: `string`):

Per-input bookkeeping: reels found / saved / filtered, batches walked, why scraping stopped.

## `errors` (type: `string`):

Input URLs that could not be scraped, with the reason.

## `outputJson` (type: `string`):

Every record from this run in a single JSON array — the classic output.json shape — saved to the run's key-value store under the 'OUTPUT' key.

## `videos` (type: `string`):

When video download is enabled, each reel's MP4 is stored in the run's key-value store as reel-<id>.mp4.

# 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": [
        "https://www.facebook.com/LeonardoDiCaprio/"
    ],
    "resultsLimit": 20,
    "language": "en-US",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/facebook-reels-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": ["https://www.facebook.com/LeonardoDiCaprio/"],
    "resultsLimit": 20,
    "language": "en-US",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/facebook-reels-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": [
    "https://www.facebook.com/LeonardoDiCaprio/"
  ],
  "resultsLimit": 20,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_minds/facebook-reels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_minds/facebook-reels-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/h2mdbBYNYQnK3D1Xa/builds/789jzO6x6pefRY8ax/openapi.json