# Facebook Reels Scraper With Creator Insights (`api-empire/facebook-reels-scraper`) Actor Facebook Reels Scraper With Creator Insights: Extract Facebook Reels data, creator profiles, video metrics, captions, views, likes, comments, shares, and timestamps. Discover trending creators, measure content performance, analyze engagement, and uncover actionable social media insights. - **URL**: https://apify.com/api-empire/facebook-reels-scraper.md - **Developed by:** [API Empire](https://apify.com/api-empire) (community) - **Categories:** Social media, Automation, Agents - **Stats:** 22 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks - **User rating**: No ratings yet ## Pricing $19.99/month + usage To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors ## 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 — Extract Reels, Profiles and Metrics Facebook Reels Scraper With Creator Insights extracts public Facebook Reels together with the creator who posted them, in one run. Every row returns typed, normalized JSON — no HTML, no selectors, no parsing — covering Reel captions, view counts, and timestamps; creator identity, verification, and follower counts; and a per-creator summary with total/average views and a views-per-follower reach ratio. Point it at a list of creator profiles and you get a dataset ready to filter, join, or feed into an agent. ### What is Facebook Reels Scraper With Creator Insights? Facebook Reels Scraper With Creator Insights is an Apify Actor that collects recent public Reels from one or more Facebook creator profiles or Pages and enriches each one with the owner's identity and follower count. It runs logged-out — no Facebook account or login is required — and can also emit one roll-up summary row per creator. The Actor is reachable as a standard HTTP API and, through Apify's Actors MCP Server, as a tool for MCP-compatible AI agents. - Scrape recent Reels from any public Facebook creator profile or Page - Attach creator identity — name, ID, verified flag, profile URL — to every Reel - Add follower/fan counts and compute per-creator views-per-follower reach ratios - Filter to Reels published after a given date, and cap how many to sample per creator - Export as JSON, CSV, or Excel, or pull results by API for agent workflows ### What data does Facebook Reels Scraper With Creator Insights collect? Each run can return up to three kinds of rows: the Reels themselves, the creator identity attached to each one, and an optional per-creator engagement summary. | Data Type | Key Fields | JSON Field Names | | --- | --- | --- | | Reels (video posts) | caption, publish time, view count, permalink | `text`, `time`, `playCountRounded`, `topLevelReelUrl` | | Creator identity (per Reel) | name, ID, verified flag, profile URL | `creatorName`, `creatorId`, `creatorIsVerified`, `creatorUrl` | | Follower / fan counts | public follower count enrichment | `followerCount` | | Per-creator engagement summary | total Reels, total/average views, reach ratio | `totalReels`, `sumViews`, `avgViews`, `viewsPerFollower` | #### Need more Facebook data? If you need the full feed rather than just Reels, Facebook Posts Scraper: Content Strategy Insights pulls a Page's posts, photos, and videos with content-strategy metrics. To turn the commenters on a specific Reel or post into lead rows, Facebook Comments Scraper With Author Lead Enrichment takes any public post, photo, video, or Reel URL — including ones this Actor surfaces — and adds contact-enriched commenter data. ### How does Facebook Reels Scraper differ from the official Facebook API? Meta's Graph API requires a registered developer app and, for most video and Page permissions, an App Review process — and it generally only exposes Reel/video data for Pages and assets your app manages or that have granted you access. Facebook Reels Scraper With Creator Insights takes any public creator profile or Page URL and returns Reels with creator and engagement data, without app review. | Feature | Facebook Graph API | Facebook Reels Scraper | | --- | --- | --- | | Access model | Registered Meta app + access token | No account or token — runs logged-out | | Approval process | App Review required for most video/Page permissions | No approval — start a run directly | | Arbitrary creator lookup | Limited to Pages/assets your app manages or that grant access | Works on any public creator profile or Page URL | | Creator enrichment | Not provided — returns metrics for your own connected assets only | Adds follower count and views-per-follower per creator automatically | | Entity coverage | Reel/video insights scoped to assets you control | Reels, creator identity, and engagement summary in one dataset | | Setup time | Developer account, review, token/permission management | Add profile URLs and start the run | The Graph API is the right choice when you own the Page and need first-party, authenticated access to your own Reel insights. This Actor fits better when you need Reels and creator intelligence on accounts you don't manage — competitors, creators, or partners — without going through app review. ### Why do developers and teams scrape Facebook Reels? #### For marketers and brand teams Marketers use per-creator Reel data to benchmark content strategy: pull the last `reelsPerCreator` Reels from competitor Pages or partner creators, compare `playCountRounded` and posting cadence via `time`, and see which formats or captions (`text`) are driving views. Because `includeCreatorSummary` rolls totals up automatically, a team can rank a shortlist of accounts by `avgViews` without building that aggregation logic themselves. Restricting the sample with `reelsPublishedAfter` keeps the comparison focused on what a competitor or partner has published recently rather than their entire back catalog, which matters most when planning a campaign calendar around what's currently working. #### For influencer and creator-research teams Before a partnership or sponsorship deal, teams need more than a follower count — they need to know if that audience actually watches. `viewsPerFollower` from the creator-summary row gives a reach ratio per creator, so a team can compare `followerCount` against real engagement across several candidate creators in one run and flag accounts whose reach looks inflated relative to their audience size. Because `creatorProfileUrls` accepts a list, a single run can vet an entire shortlist of prospective creators side by side instead of checking each one manually before reaching out. #### For AI engineers and agent builders Agent builders index Reel captions, creator identity, and engagement metrics into a RAG store or feed them to an LLM as tool output — every field arrives as typed JSON keyed by stable names like `creatorName`, `playCountRounded`, and `viewsPerFollower`, so an agent can answer "which of these creators has the best reach ratio" directly from the dataset without an HTML-parsing step in the loop. Calling the Actor over its REST API or through Apify's Actors MCP Server lets a scheduling agent trigger a fresh run and reason over the returned rows in the same tool call. #### For researchers and analysts Researchers studying short-form video engagement on Facebook can sample recent Reels from a set of public creator profiles, restrict the sample with `reelsPublishedAfter` to a defined window, and analyze `playCountRounded` alongside `followerCount` across accounts. Because the Actor only touches public profiles and Pages, the resulting dataset stays within the scope of public-data research on video performance and creator reach. The per-creator `creator_summary` rows also make it straightforward to compare reach ratios across a whole cohort of accounts in a single dataset export, rather than recomputing totals from raw per-Reel rows by hand. ### How to scrape Facebook Reels (step by step) 1. Open Facebook Reels Scraper With Creator Insights on its Apify Store listing and click **Try for free** (or **Run**). 2. Add one or more creator profile or Page URLs to `creatorProfileUrls` — full links (e.g. `facebook.com/YourPage`) or bare usernames, one per line. 3. Set `reelsPerCreator` to control sample size, optionally set `reelsPublishedAfter` to restrict to a recency window, and toggle `includeFollowerCount` / `includeCreatorSummary` for creator enrichment. 4. Start the run from the Apify Console, the API, or the CLI. 5. Download the results as JSON, CSV, or Excel — Reel rows and creator-summary rows together, or open the run's `-creators` child dataset for creator-only rollups. #### What to do when Facebook changes its structure The Actor is actively maintained, and the output schema stays stable — field names and types on your end don't change even when Facebook alters its markup or GraphQL internals behind the scenes. No action is required on your part when that happens. ### ⬇️ Input | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `creatorProfileUrls` | No | array | One creator per line — e.g. `facebook.com/YourPage` or a `/people/…` link. Usernames without `https://` work too. Each becomes one creator in the insights roll-up. | `["https://www.facebook.com/LeonardoDiCaprio/"]` | | `reelsPerCreator` | No | integer | How many recent Reels to sample from each creator (newest-first where available). This sample feeds the per-creator totals, averages, and reach ratios. Minimum 1, maximum 10000. UI prefill: `10`. | `10` | | `reelsPublishedAfter` | No | string | 📆 Absolute: pick a date. ⏱️ Relative: e.g. `7 days`, `2 weeks`. Leave blank for no cutoff. | `"7 days"` | | `includeFollowerCount` | No | boolean | Fetch each creator's public profile/page once (cached per creator) and add their follower/fan count to every Reel. Emits `null` when the count is not public. Default: `true`. | `true` | | `includeCreatorSummary` | No | boolean | After collecting Reels, emit one summary row per creator (`type=creator_summary`): total reels in this run, total & average views, follower count, and views-per-follower reach ratio. Also written to a per-run child dataset. Default: `true`. | `true` | | `proxyConfiguration` | No | object | Route traffic through Apify Proxy (recommended for fewer blocks). | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` | #### Example JSON input ```json { "creatorProfileUrls": [ "https://www.facebook.com/people/Emily-Olivia/61563061022550/", "https://www.facebook.com/LeonardoDiCaprio/" ], "reelsPerCreator": 10, "reelsPublishedAfter": "7 days", "includeFollowerCount": true, "includeCreatorSummary": true, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } } ``` `creatorProfileUrls` is not marked required in the input schema, so a run can technically start with it empty — but the Actor then logs an error and exits without collecting anything, so always add at least one creator before starting a run. ### ⬆️ Output Every run pushes typed, normalized JSON rows to the Apify dataset, exportable as JSON, CSV, or Excel. Reel rows and creator-summary rows are both billed under the `row_result` charged event; rows for a profile that failed outright are pushed with `type: "profile_error"` and are **not** billed — filter them out downstream with `type != "profile_error"`. #### Scraped Reels (`type: "reel"`) ```json { "facebookUrl": "https://www.facebook.com/LeonardoDiCaprio/", "inputUrl": "https://www.facebook.com/reel/1234567890123456", "topLevelUrl": "https://facebook.com/1234567890123456/posts/undefined/", "topLevelReelUrl": "https://www.facebook.com/reel/1234567890123456/", "text": "Protecting our oceans starts today.", "time": "2025-06-03T14:22:10.000Z", "playCountRounded": 8600000, "viewCount": 8600000, "attachments": [ { "media": { "playable_duration_in_ms": 18540, "owner": { "id": "5537674705", "name": "Leonardo DiCaprio", "url": "https://www.facebook.com/LeonardoDiCaprio/" } } } ], "tracking": { "top_level_post_id": "1234567890123456" }, "self_view_boost": null, "video": { "id": "998877665544332", "__typename": "Video", "embeddable": true, "playable_duration_in_ms": 18540, "first_frame_thumbnail": "https://scontent.xx.fbcdn.net/v/reel_thumb.jpg" }, "if_should_change_url_for_reels": { "shareable_url": "https://www.facebook.com/reel/1234567890123456/" }, "shareable_url": "https://www.facebook.com/reel/1234567890123456/", "playback_video": { "id": "998877665544332", "image": { "uri": "https://scontent.xx.fbcdn.net/v/reel_thumb.jpg" }, "audio_user_preferred_language": "en" }, "video_owner": { "id": "5537674705", "name": "Leonardo DiCaprio", "url": "https://www.facebook.com/LeonardoDiCaprio/", "is_verified": true }, "is_passive_content": false, "fb_shorts_reshare_context": {}, "remix_info": {}, "video_owner_type": "profile", "soundtrack_info": { "type": "CUSTOM_AUDIO" }, "track_title": "Leonardo DiCaprio · Original audio", "music_album_art_uri": null, "is_original_audio_on_facebook": true, "play_count_reduced": "8.6M", "type": "reel", "startUrl": "https://www.facebook.com/LeonardoDiCaprio/", "creatorName": "Leonardo DiCaprio", "creatorId": "5537674705", "creatorUrl": "https://www.facebook.com/LeonardoDiCaprio/", "creatorIsVerified": true, "creatorProfilePic": "https://scontent.xx.fbcdn.net/v/profile_pic.jpg", "followerCount": 41000000 } ``` Fields like `video`, `playback_video`, `attachments`, and `tracking` are passed through close to Facebook's own internal shape rather than fully flattened — if you only need clean fields, `text`, `time`, `playCountRounded`, `topLevelReelUrl`, and the `creator*`/`followerCount` fields cover the common case. On a failed fetch, a row instead carries `request_error` (an exception type) or `parse_error` plus `http_status`, with `creator*` fields `null` — these still count toward `row_result` billing. #### Creator summary rows (`type: "creator_summary"`) ```json { "type": "creator_summary", "creatorId": "5537674705", "creatorName": "Leonardo DiCaprio", "creatorUrl": "https://www.facebook.com/LeonardoDiCaprio/", "creatorIsVerified": true, "creatorProfilePic": "https://scontent.xx.fbcdn.net/v/profile_pic.jpg", "followerCount": 41000000, "totalReels": 10, "sumViews": 62500000, "avgViews": 6250000.0, "viewsPerFollower": 1.52439, "avgViewsPerFollower": 0.152439, "startUrl": "https://www.facebook.com/LeonardoDiCaprio/" } ``` Emitted once per creator at the end of the run when `includeCreatorSummary` is on, and also written to a `-creators` child dataset. `viewsPerFollower` and `avgViewsPerFollower` are `null` when a follower count isn't available. #### Profile error rows (uncharged) ```json { "type": "profile_error", "startUrl": "https://www.facebook.com/some-inactive-page/", "error": "ConnectionError" } ``` Pushed when a profile fails outright after retries (rather than per-Reel). These rows are not charged. ### How many results can you scrape with Facebook Reels Scraper With Creator Insights? `reelsPerCreator` caps the sample at up to 10,000 Reels per creator, matching the input schema's maximum — the Actor's internal cap mirrors this exactly. There is no limit in the schema on how many creators you can list in `creatorProfileUrls`, so total output scales with `reelsPerCreator` × number of creators; profiles are processed one after another in the same run. Facebook itself can limit how many Reels it returns for a given profile, so a run may return fewer rows than requested — the Actor logs this when it happens rather than treating it as a failure. There is no published benchmark for maximum throughput per run. ### Integrate Facebook Reels Scraper With Creator Insights and automate your workflow Facebook Reels Scraper With Creator Insights works with any language or tool that can send an HTTP request, using the standard Apify API. #### REST API integration ```python import requests TOKEN = "YOUR_APIFY_TOKEN" ACTOR = "API-Empire~facebook-reels-scraper-with-creator-insights" run = requests.post( f"https://api.apify.com/v2/acts/%7BACTOR%7D/run-sync-get-dataset-items", params={"token": TOKEN}, json={ "creatorProfileUrls": ["https://www.facebook.com/LeonardoDiCaprio/"], "reelsPerCreator": 10, }, ) rows = run.json() for row in rows: if row.get("type") == "creator_summary": print(row["creatorName"], row["viewsPerFollower"]) ``` Works in Python, Node.js, Go, Ruby, cURL. #### MCP for AI agents The Actor can be exposed to an MCP-compatible client through Apify's Actors MCP Server by adding its ID to the server's actor list, for example running `npx @apify/actors-mcp-server --actors API-Empire/facebook-reels-scraper-with-creator-insights`. Compatible with Claude, Cursor, and other MCP clients. #### Automation platforms (n8n, Make) In n8n, the Apify node's "Run Actor" operation can call this Actor by ID and pass `creatorProfileUrls` and the other input fields from an upstream node. In Make, the Apify app's "Run an Actor" module takes the same actor ID and input JSON, letting you route the creator-summary rows straight into a Google Sheets or Airtable creator leaderboard without custom code. ### Is it legal to scrape Facebook Reels? Yes, scraping publicly accessible Facebook Reels is generally legal — this Actor only returns data from public creator profiles and Pages that anyone can view without logging in. Creator names, profile URLs, verification status, and follower counts are personal data tied to identifiable accounts, so GDPR (if you process data on EU residents) and CCPA (California residents) govern how you may lawfully store, use, and retain it — you need a valid lawful basis, such as legitimate interest, and must honor deletion/access requests. Consult legal counsel for commercial use cases involving bulk personal data. ### Frequently asked questions #### Does Facebook Reels Scraper work without a Facebook account? Yes. The Actor runs logged-out — no Facebook login or account is required to start a run. A residential Apify Proxy is prefilled and recommended for stability, but the Actor itself needs no credentials. #### How often is the scraped data updated? Each run fetches Reels and creator profiles live from Facebook at the time it executes; nothing is served from a previous run's cache. Follower counts are cached only within that single run — once per creator, to avoid redundant fetches — never carried over between runs. #### What happens if a creator has no public Reels or the profile fails to load? If Facebook genuinely returns no Reels for a profile, that profile simply contributes zero rows to the run — no error is raised. If the request itself fails after retries (connection error, timeout, proxy issue), the Actor pushes one uncharged `type: "profile_error"` row with the input URL and the error, and moves on to the next profile. #### Can I scrape private or restricted Facebook content? No. Only Reels and profile data that are publicly visible without logging in are returned. Private profiles and login-gated pages yield `null` follower counts rather than fabricated values, and their Reels are not accessible. #### Does Facebook Reels Scraper work for AI agent workflows and LLM pipelines? Yes. It's callable as a standard HTTP API endpoint from any agent framework, and it's also reachable through Apify's Actors MCP Server for MCP-compatible clients. Every response is typed JSON with stable field names — no HTML or parsing step before passing rows to an LLM. #### How does Facebook Reels Scraper handle Facebook's anti-bot system? The Actor retries failed requests with exponential backoff on rate-limit and server errors (429, 502, 503, 504), requests a fresh proxy IP when a connection drops before any Reel has been saved for a profile, paces requests between profiles, and caps concurrent Reel fetches rather than firing them all at once. It uses realistic browser headers and no personal Facebook login, so no account is put at risk. #### Does Facebook Reels Scraper return data in a format LLMs can use directly? Yes. Every row is typed, normalized JSON with stable field names — no HTML, no selectors, no parsing step. Pass rows directly into an LLM context window, index them into a vector store, or route them through an agent tool call. #### Can I use Facebook Reels Scraper without managing proxies? Largely, yes — `proxyConfiguration` is prefilled with Apify residential proxy, so a default run already routes through it. Unlike some scrapers, this Actor honors whatever you set there: clearing the field entirely runs requests with no proxy at all, so leave the default in place (or your own configuration) for the most reliable results. #### What happens when Facebook changes its structure or blocks the scraper? The Actor is maintained on an ongoing basis, and the output schema stays stable on your end — field names and types don't change even when Facebook's internal markup or GraphQL structure shifts. No numeric turnaround time is guaranteed. ### Your feedback Found a bug or missing a field? We want to know. Reach out through the Actor's Apify Store page (Issues tab) or your Apify Console support channel with a run ID and we'll take a look — reports like this directly shape what gets fixed and maintained. # Actor input Schema ## `creatorProfileUrls` (type: `array`): One creator per line — e.g. facebook.com/YourPage or a /people/… link. Usernames without https:// work too. Each becomes one creator in the insights roll-up. ## `reelsPerCreator` (type: `integer`): How many recent Reels to sample from each creator (newest-first where available). This sample feeds the per-creator totals, averages, and reach ratios. ## `reelsPublishedAfter` (type: `string`): 📆 Absolute: pick a date. ⏱️ Relative: e.g. 7 days, 2 weeks. Leave blank for no cutoff. ## `includeFollowerCount` (type: `boolean`): Fetch each creator's public profile/page once (cached per creator) and add their follower/fan count to every Reel. Emits null when the count is not public. ## `includeCreatorSummary` (type: `boolean`): After collecting Reels, emit one summary row per creator (type=creator\_summary): total reels in this run, total & average views, follower count, and views-per-follower reach ratio. Also written to a per-run child dataset. ## `proxyConfiguration` (type: `object`): Route traffic through Apify Proxy (recommended for fewer blocks). ## Actor input object example ```json { "creatorProfileUrls": [ "https://www.facebook.com/people/Emily-Olivia/61563061022550/", "https://www.facebook.com/LeonardoDiCaprio/" ], "reelsPerCreator": 10, "includeFollowerCount": true, "includeCreatorSummary": true, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # Actor output Schema ## `results` (type: `string`): One row per scraped Facebook Reel (type=reel), with the owning creator's identity, follower count and view count attached. Also includes any type=profile\_error rows for creators the run could not fetch. ## `creatorSummaries` (type: `string`): One roll-up row per creator (type=creator\_summary): total reels sampled this run, total & average views, follower count, and views-per-follower reach ratio. Same dataset as Reels, filtered to the summary rows. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "creatorProfileUrls": [ "https://www.facebook.com/people/Emily-Olivia/61563061022550/", "https://www.facebook.com/LeonardoDiCaprio/" ], "reelsPerCreator": 10, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("api-empire/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "creatorProfileUrls": [ "https://www.facebook.com/people/Emily-Olivia/61563061022550/", "https://www.facebook.com/LeonardoDiCaprio/", ], "reelsPerCreator": 10, "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("api-empire/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 '{ "creatorProfileUrls": [ "https://www.facebook.com/people/Emily-Olivia/61563061022550/", "https://www.facebook.com/LeonardoDiCaprio/" ], "reelsPerCreator": 10, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call api-empire/facebook-reels-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-empire/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 ` 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/Z9JeO8OwWSOjEHynp/builds/IMymcsbCtSDgPTXdV/openapi.json