# Facebook Reels Scraper – Export Any Page's Reels (`endspec/facebook-instant-reels-scraper`) Actor

Scrape Reels from any public Facebook Page or profile by URL. Export video URL, description, play count, reactions, comments, length, timestamp and thumbnail to JSON, CSV or Excel. Synchronous, no login. Pay only per reel returned.

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

## Pricing

from $3.00 / 1,000 reel returneds

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reels Scraper – Export Any Page's Reels

**Simple Input-Output Example**

Input (`url` is required):
```json
{
  "url": "https://www.facebook.com/leomessi",
  "limit": 3
}
````

Output (one dataset item per reel):

```json
{
  "video_id": "1104857291234567",
  "post_id": "pfbid02Xq7rN8kL3mYvT9wZ1aH4",
  "type": "reel",
  "url": "https://www.facebook.com/reel/1104857291234567",
  "description": "Training day at the academy 💪",
  "timestamp": 1750112400,
  "length_in_seconds": 28.44,
  "play_count": 4821330,
  "reactions_count": 391204,
  "comments_count": 8112,
  "reshare_count": 15430,
  "author_name": "Leo Messi",
  "thumbnail_url": "https://scontent.xx.fbcdn.net/v/t15.5256-10/thumb_1104857291234567.jpg",
  "video_url": "https://video.xx.fbcdn.net/v/t42.1790-2/1104857291234567_hd.mp4",
  "_query": "{\"url\":\"https://www.facebook.com/leomessi\"}"
}
```

**Important Notes:**

- You get results **instantly** — the run is synchronous, no job queue
- Pay per result — **$0.0033 per reel returned**; failed and empty runs cost nothing
- **No Facebook login, cookies, or API key** required from you
- All data comes from **public pages and profiles** only
- **One page URL per run** — the actor scrapes a single page's Reels tab
- Contact: contact@endspec.net

***

### Full Actor Documentation

#### Facebook Reels Scraper

**Export the Reels from any public Facebook Page or profile by URL.** Get the video URL, description, play count, reactions, comments, shares, length, timestamp, and thumbnail for each reel — as JSON, CSV, or Excel.

***

#### Overview

The Facebook Reels Scraper is an Apify Actor that extracts publicly available Reels data from a [Facebook](https://www.facebook.com) Page or profile. You give it one page URL; it resolves that page's Reels tab and returns the reels it publishes, with their engagement metrics and media links attached.

It is built for people who need Facebook Reels data in a spreadsheet or a database rather than in a browser tab: marketers benchmarking creative, analysts tracking engagement, and developers feeding a content pipeline.

**What this Actor does not do:** it does not scrape comments or commenter identities, it does not scrape likers or reactors, it does not download or re-host video files, it does not search Reels by keyword or hashtag, and it does not access private profiles, private groups, or anything behind a login.

##### What You Can Do

- **Export a Page's Reels**: Pull the Reels published by any public Facebook Page or profile from a single URL
- **Measure Engagement**: Get play count, reactions, comments, and reshares per reel
- **Analyze Creative Length**: Compare reel duration against engagement to find the format that performs
- **Collect Media Links**: Get the direct video URL and thumbnail URL for each reel
- **Track Posting Cadence**: Use per-reel timestamps to chart how often a page ships Reels
- **Feed Downstream Tools**: Export to JSON, CSV, Excel, HTML, or XML, or read the dataset via the Apify API

##### Data Availability

**All data returned by this Actor is publicly available information.** It reads only Reels that a Page or profile has published publicly on Facebook — the same content any logged-out visitor can see on that page's Reels tab. It does not access private accounts, friends-only content, or anything requiring authentication.

***

#### Actor Input Parameters

The Actor accepts the following input parameters:

**url**
• Type: string
• Required: **Yes**
• Description: Full URL of the public Facebook page or profile
e.g., `https://www.facebook.com/leomessi`

**limit**
• Type: integer
• Required: Optional
• Default: `20`
• Minimum: `1` — Maximum: `100`
• Description: Maximum number of reels to return. Fewer may be returned if the page has less.
e.g., `50`

**Important Notes:**

- **`url` is required** — the run cannot start without it
- **Use the page URL, not a reel URL** — pass the page or profile itself (`facebook.com/leomessi`), not a single reel permalink (`facebook.com/reel/123...`)
- **The page must have a Reels tab** — pages that have never published a Reel return the "no Reels available" message described under [Output Examples](#output-examples), and are not charged
- **`limit` is a cap, not a target** — the Actor fetches one batch of reels and trims it to `limit`. If the page's Reels tab returns fewer than you asked for, you get fewer. Values near the `100` maximum are not guaranteed to be reachable for every page
- **Public pages and profiles only** — private profiles cannot be read and will not return reels

***

#### Input Examples

##### Example 1: Default Run (URL Only)

```json
{
  "url": "https://www.facebook.com/leomessi"
}
```

**When to use:** The simplest case. `limit` defaults to `20`, so you get up to 20 reels.

##### Example 2: Larger Pull with an Explicit Limit

```json
{
  "url": "https://www.facebook.com/9gag",
  "limit": 50
}
```

**When to use:** When you want more of a prolific page's back catalogue. Remember `limit` is a ceiling — the page may return fewer.

##### Example 3: Small Sample for a Cheap Test

```json
{
  "url": "https://www.facebook.com/natgeo",
  "limit": 1
}
```

**When to use:** To validate a page URL and see the output shape before committing to a large run. You are charged for one reel.

##### Example 4: Page With No Reels (Will Return an Error Row)

```json
{
  "url": "https://www.facebook.com/some-page-that-never-posts-reels"
}
```

**Result:** The page has no Reels tab to resolve, so the Actor emits a single error row with the message `This page has no Reels available. You were not charged.` No charge is made.

***

#### Output Structure

The Actor pushes results to the Apify dataset — **one item per reel**. You can download the dataset as JSON, CSV, Excel, HTML, or XML, or read it through the Apify API. The `overview` dataset view renders the key columns (description, author, plays, reactions, comments, shares, length, posted date, thumbnail, and reel URL) as a table.

##### Successful Output Format

Each reel is emitted with this structure:

```json
{
  "video_id": "string",
  "post_id": "string",
  "type": "string",
  "url": "string",
  "description": "string",
  "timestamp": 0,
  "length_in_seconds": 0,
  "play_count": 0,
  "reactions_count": 0,
  "comments_count": 0,
  "reshare_count": 0,
  "author_name": "string",
  "thumbnail_url": "string",
  "video_url": "string",
  "_query": "string"
}
```

**Field Descriptions:**

**video\_id**
• Type: string
• Description: Facebook's identifier for the reel's video

**post\_id**
• Type: string
• Description: Facebook's identifier for the post that carries the reel

**type**
• Type: string
• Description: Content type reported for the item (e.g. `reel`)

**url**
• Type: string
• Description: Permalink to the reel on Facebook

**description**
• Type: string
• Description: The reel's caption text, as published

**timestamp**
• Type: number
• Description: Publication time as a Unix timestamp in seconds (UTC)

**length\_in\_seconds**
• Type: number
• Description: Duration of the reel in seconds (may be fractional, e.g. `28.44`)

**play\_count**
• Type: number
• Description: Number of plays reported for the reel

**reactions\_count**
• Type: number
• Description: Total reactions on the reel

**comments\_count**
• Type: number
• Description: Number of comments on the reel

**reshare\_count**
• Type: number
• Description: Number of times the reel was reshared

**author\_name**
• Type: string
• Description: Display name of the page or profile that published the reel

**thumbnail\_url**
• Type: string
• Description: URL of the reel's cover image

**video\_url**
• Type: string
• Description: Direct URL to the reel's HD video stream. These are Facebook CDN links and expire — fetch them promptly if you intend to keep the media

**\_query**
• Type: string
• Description: A JSON string echoing the page URL this run was given, e.g. `"{\"url\":\"https://www.facebook.com/leomessi\"}"`. Useful for tracing rows back to their input when you merge datasets across runs

**Note on missing fields:** Reels rows carry no `status` field — a row in the dataset with a `video_id` is a successful result. Individual fields are omitted when Facebook does not publish them for a given reel, so treat any field other than the identifiers as possibly absent.

##### Error Output Format

When a run cannot produce reels, the Actor pushes a **single** row in this shape instead:

```json
{
  "status": "error",
  "_query": "string",
  "error": "string"
}
```

The `error` value is always one of the Actor's own fixed messages. These are the messages this Actor emits, verbatim:

| Situation | `error` message |
|---|---|
| The service is rate limited | `The service is busy right now — please retry in a moment. You were not charged.` |
| The data service returned a failure | `The data service is temporarily unavailable — please retry shortly. You were not charged.` |
| The page has no Reels tab to read | `This page has no Reels available. You were not charged.` |
| Any other failure (e.g. a network problem) | `The request could not be completed right now. Please retry shortly. You were not charged.` |

**No charge is made on any error path** — the charge only fires per reel actually pushed.

***

#### Output Examples

##### Example 1: Reel with Full Engagement Data

```json
{
  "video_id": "1104857291234567",
  "post_id": "pfbid02Xq7rN8kL3mYvT9wZ1aH4",
  "type": "reel",
  "url": "https://www.facebook.com/reel/1104857291234567",
  "description": "Training day at the academy 💪",
  "timestamp": 1750112400,
  "length_in_seconds": 28.44,
  "play_count": 4821330,
  "reactions_count": 391204,
  "comments_count": 8112,
  "reshare_count": 15430,
  "author_name": "Leo Messi",
  "thumbnail_url": "https://scontent.xx.fbcdn.net/v/t15.5256-10/thumb_1104857291234567.jpg",
  "video_url": "https://video.xx.fbcdn.net/v/t42.1790-2/1104857291234567_hd.mp4",
  "_query": "{\"url\":\"https://www.facebook.com/leomessi\"}"
}
```

##### Example 2: Reel with Partial Data (No Caption, Low Engagement)

Fields Facebook does not publish for a reel are simply absent from the row — here the reel has no caption and no reshares reported.

```json
{
  "video_id": "8823410099887766",
  "post_id": "pfbid09Kd3zQ1nB7cM2xR5t",
  "type": "reel",
  "url": "https://www.facebook.com/reel/8823410099887766",
  "timestamp": 1748996100,
  "length_in_seconds": 12.0,
  "play_count": 341,
  "reactions_count": 6,
  "comments_count": 0,
  "author_name": "Riverside Bakery",
  "thumbnail_url": "https://scontent.xx.fbcdn.net/v/t15.5256-10/thumb_8823410099887766.jpg",
  "video_url": "https://video.xx.fbcdn.net/v/t42.1790-2/8823410099887766_hd.mp4",
  "_query": "{\"url\":\"https://www.facebook.com/riversidebakery\"}"
}
```

##### Example 3: Successful Run, No Reels Returned (Empty Dataset)

If the page's Reels tab resolves but comes back with nothing, the run **succeeds and the dataset is empty** — zero items, no error row, no charge:

```json
[]
```

This means the page exists and has a Reels tab, but no reels were available to return.

##### Example 4: Page Has No Reels (Error Row)

```json
{
  "status": "error",
  "_query": "{\"url\":\"https://www.facebook.com/some-page-that-never-posts-reels\"}",
  "error": "This page has no Reels available. You were not charged."
}
```

##### Example 5: Service Temporarily Unavailable (Error Row)

```json
{
  "status": "error",
  "_query": "{\"url\":\"https://www.facebook.com/leomessi\"}",
  "error": "The data service is temporarily unavailable — please retry shortly. You were not charged."
}
```

***

#### Use Cases

##### For Social Media Marketers

**Creative Benchmarking:** Export a competitor's Reels and rank them by play count and reactions to see which hooks, lengths, and formats actually land before you brief your own.

**Example Workflow:**

1. List the Facebook Pages of your 5 closest competitors
2. Run the Actor once per page URL with `limit` set to 50
3. Export the combined dataset to CSV
4. Sort by `play_count` and compare against `length_in_seconds`
5. Brief your next batch of Reels against the top decile

##### For Brands and Agencies

**Creator Vetting:** Before you pay a creator, check whether their Reels engagement is real and consistent rather than one lucky viral hit.

**Example Workflow:**

1. Collect the Facebook page URLs of shortlisted creators
2. Run the Actor for each with `limit` set to 25
3. Compare median vs. maximum `play_count` per creator
4. Check `timestamp` spacing for posting consistency
5. Shortlist creators whose engagement holds across recent reels

##### For Analysts and Researchers

**Content Trend Analysis:** Build a longitudinal picture of how a page's Reels strategy and reception change over time.

**Example Workflow:**

1. Choose the pages that define your category
2. Schedule the Actor to run weekly per page
3. Append each run's dataset to your warehouse, keyed on `video_id`
4. Convert `timestamp` to dates and chart cadence, duration, and engagement
5. Track how the category's format norms drift quarter over quarter

##### For Developers

**Content Pipelines:** Feed Facebook Reels metadata into a dashboard, CMS, or internal tool without maintaining a scraper.

**Example Workflow:**

1. Call the Actor via the Apify API with the page URL as input
2. Read the dataset items from the run
3. Deduplicate against your store using `video_id`
4. Fetch `thumbnail_url` (and `video_url`, if you need the media) promptly — CDN links expire
5. Schedule reruns to keep engagement counters fresh

***

#### Best Practices

##### Input Selection

- **Pass the page, not the reel** — the input is a page or profile URL; a single reel permalink is not a valid target
- **Test with `limit: 1` first** — confirm the URL resolves and the shape is what you expect before a large run
- **Prefer the canonical page URL** — the plain `facebook.com/<page>` form, without tracking query strings or trailing paths

##### Getting Complete Data

- **Run one page per run** — the Actor takes a single URL; loop at the orchestration layer for multiple pages
- **Expect fewer than `limit`** — the Actor fetches one batch of reels, so `limit` caps the result but never forces it
- **Re-run to refresh counters** — `play_count` and `reactions_count` are snapshots at run time and keep climbing after you read them

##### Error Handling

- **Check for `status`** — a row containing `status: "error"` is a failure notice, not a reel; reel rows have no `status` field
- **Treat an empty dataset as valid** — zero items means the page had no reels to return, not that the run broke
- **Retry the busy and unavailable messages** — both are transient; wait a moment and run again
- **Log run IDs** — include the Apify run ID when you contact support

##### Data Usage

- **Grab media promptly** — `video_url` and `thumbnail_url` are Facebook CDN links and expire; do not store them as permanent references
- **Key on `video_id`** — it is the stable identifier for deduplicating across repeated runs
- **Respect platform terms** — use exported content for analysis, not for republishing as your own

***

#### Cost, Performance, and Limits

**Pricing:** Pay per result — **$0.0033 per reel returned**. No subscription, no minimums.

**What you are charged for:** the Actor charges a `reel-returned` event once per reel it pushes to the dataset, and nothing else. There is no per-run fee.

**What you are not charged for:**

- Runs that end in any error row — busy, unavailable, no Reels, or an unexpected failure
- Runs that resolve the page but return no reels (an empty dataset)

**Performance:** Runs are synchronous and fast — the Actor resolves the page's Reels tab and fetches one batch of reels, then returns. There is no queue to wait on and no browser to boot.

**Limits to know:**

- **One page URL per run.** Scrape multiple pages by scheduling multiple runs or driving the Actor from the Apify API.
- **`limit` accepts 1–100, but is a ceiling on a single batch.** The Actor does not paginate deeper, so a page's Reels tab may return fewer items than you request; high values are not guaranteed for every page.
- **Public pages and profiles only.** Private profiles and login-gated content are out of reach.
- **Engagement counts are point-in-time.** They reflect the moment of the run.
- **Media URLs expire.** Facebook CDN links in `video_url` and `thumbnail_url` are short-lived by design.

***

#### Data Sources and Legality

**All data returned by this Actor is publicly available information** published on Facebook Pages and profiles — the content any visitor can view without logging in. The Actor does not bypass authentication, does not access private profiles or groups, and does not collect data about commenters, reactors, or viewers.

**Your responsibilities:**

- You are responsible for complying with applicable laws, including GDPR, CCPA, and other data protection regulations
- You are responsible for complying with Facebook's Terms of Service in your use of the data
- Exported captions and videos remain the intellectual property of their creators — analysis is not a licence to republish
- Have a legitimate purpose for the data you collect and retain it no longer than that purpose requires

This Actor is **not affiliated with, endorsed by, or sponsored by Facebook or Meta.** Wording here is factual and is not legal advice; if your use case is sensitive, take your own counsel.

***

#### FAQ

**Q: Do I need a Facebook account, cookies, or an API key?**
A: No. You provide a public page URL and nothing else. There is no login step and no key for you to manage.

**Q: Will an empty or failed run cost me anything?**
A: No. You are charged only per reel actually returned. Error rows and empty datasets are free.

**Q: Which pages have Reels?**
A: Only pages and profiles that actually publish them. If a page has no Reels tab, the run returns `This page has no Reels available. You were not charged.` and is not charged.

**Q: Why did I get fewer reels than my `limit`?**
A: `limit` is a ceiling, not a target. The Actor fetches one batch from the page's Reels tab and trims it to your limit — if the page returns fewer, so does the run. This is expected for pages with a short Reels history.

**Q: Can I scrape several pages in one run?**
A: No — one page URL per run. Use Apify's scheduler or the Apify API to run the Actor once per page, then merge the datasets.

**Q: Can I pass a single reel's URL instead of the page's?**
A: No. The input is a page or profile URL; the Actor resolves that page's Reels tab. A reel permalink is not a valid input.

**Q: Does this work on private profiles?**
A: No. Only public pages and profiles are readable.

**Q: Can I download the actual video files?**
A: The Actor returns `video_url`, a direct link to the reel's HD stream, but it does not download or host media for you. Those links are Facebook CDN URLs and expire, so fetch them promptly if you need the file.

**Q: Are the play and reaction counts live?**
A: They are a snapshot from the moment of the run. Re-run the Actor to refresh them.

**Q: Can I get the comments or the people who reacted?**
A: No. This Actor returns per-reel counts (`comments_count`, `reactions_count`), not comment text or commenter/reactor identities.

**Q: How do I tell a successful row from an error row?**
A: Error rows have a `status` field set to `"error"` plus an `error` message. Reel rows have no `status` field at all — if it has a `video_id`, it is a reel.

**Q: What is the `_query` field for?**
A: It echoes back the page URL the run was given, as a JSON string. It is there so you can trace rows to their input after merging datasets from many runs.

**Q: Can I use this Actor commercially?**
A: Yes. The data is public. You remain responsible for how you use it — see [Data Sources and Legality](#data-sources-and-legality).

***

#### Contact & Support

**Questions? Need Help? We're Here for You!**

For any questions, technical support, feature requests, or general inquiries about the Facebook Reels Scraper, please reach out:

**Email:** contact@endspec.net

**Response Time:** We respond within 24 hours during business days.

**What to Include in Your Inquiry:**

- Your question or issue description
- Actor run ID (if applicable)
- The input you used (page URL and `limit`)
- Any error message or status information you received

You can also report issues through the **Issues** tab on this Actor's Apify page.

We're committed to helping you get the most out of this Actor — whether you're integrating it into a pipeline, troubleshooting a page that won't resolve, or exploring a new use case.

***

#### Related Actors

- [Instagram Instant Media Scraper](https://apify.com/endspec/instagram-instant-media-scraper) – Export a public Instagram profile's media and engagement data.
- [YouTube Instant Email Scraper](https://apify.com/endspec/youtube-instant-email-scraper) – Find public contact emails for YouTube channels.
- [LinkedIn Instant Profile Search](https://apify.com/endspec/linkedin-instant-profile-search) – Search public LinkedIn profiles by name, job title, or company.

***

*Last Updated: July 2026*

# Actor input Schema

## `url` (type: `string`):

Full URL of the public Facebook page or profile

## `limit` (type: `integer`):

Maximum number of reels to return (1-100). Fewer may be returned if the page has less.

## Actor input object example

```json
{
  "url": "https://www.facebook.com/leomessi",
  "limit": 20
}
```

# Actor output Schema

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

No description

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reels Scraper – Export Any Page's Reels",
        "description": "Scrape Reels from any public Facebook Page or profile by URL. Export video URL, description, play count, reactions, comments, length, timestamp and thumbnail to JSON, CSV or Excel. Synchronous, no login. Pay only per reel returned.",
        "version": "0.1",
        "x-build-id": "wY4XLpBI55rxnbicb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/endspec~facebook-instant-reels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-endspec-facebook-instant-reels-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/endspec~facebook-instant-reels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-endspec-facebook-instant-reels-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/endspec~facebook-instant-reels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-endspec-facebook-instant-reels-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": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "Facebook Page/Profile URL",
                        "type": "string",
                        "description": "Full URL of the public Facebook page or profile"
                    },
                    "limit": {
                        "title": "Max Reels",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reels to return (1-100). Fewer may be returned if the page has less.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
