# Facebook Reels Scraper (page reels, views, MP4, no login) (`datahamster/facebook-reels-videos`) Actor

Facebook reels scraper for any public Page: one row per reel with views, reactions, comments, shares, caption, publish date, duration, thumbnail and direct MP4 links. No login, no cookies. List a Page's reels tab, pass reel URLs, or search by keyword; monitor mode alerts on view changes.

- **URL**: https://apify.com/datahamster/facebook-reels-videos.md
- **Developed by:** [Viktor Dubnytskiy](https://apify.com/datahamster) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 result items

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?

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 Reels Scraper (page reels, views, MP4, no login)

Scrape the public Reels and videos of any Facebook Page as a flat table — no login, no cookies, no account. One row per video with the counters brands actually track: views, reactions, comments, shares, publish date and duration, plus the caption, the thumbnail and the direct MP4 URLs.

### What you get

`id`/`videoId`, `url`, `type` (reel/video), `pageSlug`, `pageName`, `ownerId`, `description`, `views`, `viewsText`, `reactions`, `comments`, `shares`, `publishedAt` (ISO 8601 UTC), `durationSec`, `videoUrlHd`, `videoUrlSd`, `thumbnail`, `query`, `rank`, `source` (page/url/search), `detailsFetched`, `scrapedAt`.

The owner is the publishing Page — its id, name and slug. No commenters, no reactors, no personal profiles.

### Example output

Real row from the example dataset (Page `nike`, MP4 URLs truncated here):

| Field | Example value |
|---|---|
| `url` | `https://www.facebook.com/reel/2166091230582141/` |
| `pageName` / `pageSlug` | `Nike` / `nike` |
| `description` | `Leave your limits at the surface. #JustDoIt` |
| `views` / `viewsText` | `3300000` / `3.3M` |
| `reactions` / `comments` / `shares` | `7904` / `2483` / `1100` |
| `publishedAt` | `2025-09-15T16:01:55+00:00` |
| `durationSec` | `30.025` |
| `videoUrlHd` | `https://video-lga3-1.xx.fbcdn.net/o1/v/t2/f2/m86/AQNrPdap6OftBP5OG6byX9Zra9AIeTlJ…` |

### Use cases

- Track a competitor's reel output and see which creatives earn the views, reactions and shares.
- Build a swipe file of top-performing reels in a niche, with the MP4 and the thumbnail attached.
- Report social performance on a schedule: monitor mode returns only what is new or what moved.

### How it works

1. **Page URLs** → the Page's reels tab (`facebook.com/<page>/reels/`) is read as a logged-out visitor and every reel in it becomes a row.
2. **Reel / video URLs** → each reel (`/reel/<id>`), watch link (`/watch/?v=<id>`) or video permalink (`/<page>/videos/<id>/`) is opened directly.
3. **Queries** → reel permalinks indexed by a public search engine are collected for your keyword, then opened like any other video URL.
4. With `fetchDetails` on, every video found by (1) or (3) is opened for its own counters. Counters are always read from the payload node carrying the same video id, so a reel never inherits its neighbour's numbers.

### Input

| Field | Meaning | Default |
|---|---|---|
| `pageUrls` | Pages whose reels you want, e.g. `https://www.facebook.com/nike` | `["https://www.facebook.com/nike"]` |
| `videoUrls` | Known reel / watch / video permalinks to read directly | empty |
| `queries` | Keywords searched over indexed reel permalinks | empty |
| `maxVideosPerPage` | Cap of reels taken from each Page (1-200) | `30` |
| `fetchDetails` | Open every video for its own counters and MP4 links | `true` |
| `maxItems` | Stop after this many video rows | `20` |
| `mode` | `scrape` or `monitor` (only new/changed since last run) | `scrape` |
| `monitorKey`, `webhookUrl`, `telegramBotToken`, `telegramChatId` | Monitor-mode state key and alert targets | empty |

### Pricing

| Event | Price |
|---|---|
| result | $0.003 per video ($3 per 1,000) |
| monitor-check | $0.006 per monitor run |
| change | $0.003 per new/changed video |

Charged only for videos actually pushed. Apify platform usage (proxy, compute) is billed on top.

### Why this actor

- No login and no cookies to supply — nothing to keep alive, nothing to get banned.
- Counters are matched to the video id inside the page payload, not to whatever number happens to sit nearby, so a reel never gets its neighbour's views.
- Direct HD and SD MP4 links plus the thumbnail come out of the same run.
- Monitor mode with webhook and Telegram alerts on view, reaction and comment changes.
- A run that finds nothing pushes nothing and charges no result events; the run summary explains why.

### Limits

- Logged-out only. The Page's `/videos/` catalogue is served empty to guests, so the listing comes from the reels tab; that tab renders a single batch (usually 6-12 reels, the most recent ones) and Facebook does not page it without a login. Use `videoUrls` for older videos.
- `views` is the exact play count where Facebook publishes one (watch pages); on a reels tab and on reel pages it is the rounded count Facebook displays (`viewsText` keeps the original, e.g. "2.4M"). The number in a page's Open Graph tag is cached from publication time and is used only when nothing better exists. Reels with few views carry no published count at all and come back with `views: null`.
- `shares` is published for reels, not for watch-page videos.
- No comment text, no commenters, no reactors, no followers — counts only.
- Live videos, stories and videos on private or age-restricted Pages are not available to logged-out visitors.

### FAQ

**Does it need a Facebook login or cookies?** No. There is no account or cookie field; everything is read as a logged-out visitor, which is also why the older back catalogue is not reachable from the reels tab.

**Can I download the video file?** The row carries `videoUrlHd` and `videoUrlSd`, the direct MP4 URLs Facebook serves for that reel. They are time-limited signed links, so fetch them soon after the run.

**What happens when there are no results?** No rows are pushed and no result events are charged. The `RUN_SUMMARY` record in the run's key-value store carries `emptyReason`, separating "this Page publishes no reels" from "Facebook answered with a login wall".

### Changelog

- 0.1: initial release — reels tab listing, single reel/video URLs, keyword discovery, monitor mode.

***

If this actor saved you time, a short review on its Store page genuinely helps other people find it. Found a bug or need a field that is missing? Open a ticket on the **Issues** tab.

# Actor input Schema

## `pageUrls` (type: `array`):

Facebook Page URLs whose reels you want, one per line, e.g. "https://www.facebook.com/nike". The actor reads each Page's reels tab as a logged-out visitor.

## `videoUrls` (type: `array`):

Single videos to open directly, one URL per line: "https://www.facebook.com/reel/2166091230582141/", "https://www.facebook.com/watch/?v=<id>" or "https://www.facebook.com/nike/videos/<id>/". Use this to reach older videos the reels tab no longer lists.

## `queries` (type: `array`):

Keywords searched over reel permalinks indexed by a public search engine, one per line, e.g. "running shoes review", "yoga kyiv". Each hit is then opened like any other reel URL.

## `maxVideosPerPage` (type: `integer`):

Cap of reels taken from each Page, e.g. 5. Logged-out Facebook renders one batch of the reels tab, usually 6-12 reels, so values above that change nothing. Range 1-200.

## `fetchDetails` (type: `boolean`):

true = open every reel/video page for its own view count, reactions, shares and MP4 links (one extra request per video). false = keep only what the reels tab listing shows. Example: true.

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

Stop after this many video rows, e.g. 20. You are charged only for rows actually pushed to the dataset.

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

"scrape" returns every matching row. "monitor" returns only rows that are new or whose views, reactions or comments changed since the previous run of the same saved task. Example: "scrape".

## `monitorKey` (type: `string`):

Optional state key for monitor mode when the actor is not run as a saved task, e.g. "nike-reels-daily". Runs sharing a key share the comparison state.

## `webhookUrl` (type: `string`):

Optional HTTPS URL that receives a POST with a JSON summary of the changes found in monitor mode, e.g. "https://hooks.zapier.com/hooks/catch/123/abc".

## `telegramBotToken` (type: `string`):

Optional Telegram bot token used to send monitor-mode change summaries, e.g. "123456789:AAE...". Leave empty to skip Telegram alerts.

## `telegramChatId` (type: `string`):

Optional Telegram chat id that receives the monitor-mode summaries, e.g. "-1001234567890" for a channel or "123456789" for a direct chat.

## Actor input object example

```json
{
  "pageUrls": [
    "https://www.facebook.com/nike"
  ],
  "maxVideosPerPage": 5,
  "fetchDetails": true,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

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

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

## `runSummary` (type: `string`):

RUN\_SUMMARY record

# 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 = {
    "pageUrls": [
        "https://www.facebook.com/nike"
    ],
    "maxVideosPerPage": 5,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/facebook-reels-videos").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 = {
    "pageUrls": ["https://www.facebook.com/nike"],
    "maxVideosPerPage": 5,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datahamster/facebook-reels-videos").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 '{
  "pageUrls": [
    "https://www.facebook.com/nike"
  ],
  "maxVideosPerPage": 5,
  "maxItems": 20
}' |
apify call datahamster/facebook-reels-videos --silent --output-dataset

```

## MCP server setup

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

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/C5020UVICAKHE46zk/builds/frBQgBEuWKikXNl03/openapi.json