# Facebook Metrics Scraper (`chronometrica/facebook-metrics-scraper`) Actor

Collect public Facebook engagement metrics from post, reel, watch, video, photo, and profile/page URLs without login or cookies. Get views, plays, reactions, likes, comments, shares, author follower counts, content IDs, availability statuses, and clean run summaries.

- **URL**: https://apify.com/chronometrica/facebook-metrics-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media
- **Stats:** 5 total users, 3 monthly users, 94.8% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 facebook content metrics

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Facebook Metrics Scraper

### 📊 What does Facebook Metrics Scraper do?

Facebook Metrics Scraper extracts public engagement metrics from Facebook post,
reel, watch, video, photo, and profile/page URLs. Paste known Facebook content
URLs to measure them directly, or paste profile/page URLs to discover recent
public content first.

Use it for repeatable public engagement monitoring: views, plays, reactions,
likes, comments, shares, author audience counts, content IDs, and clear
availability statuses in one dataset. Rows can also include public
collaboration profile context when available.

This Actor does not log in, use cookies, scrape private content, collect
comments, collect liker identities, or bypass Facebook access controls. It only
returns data that is publicly visible without logging in.

With Facebook Metrics Scraper, you can:

- 📈 Collect public views, plays, reactions, likes, comments, and shares.
- 🎬 Measure reels, watch URLs, videos, posts, photos, permalink URLs, and pfbid
  post URLs.
- 👤 Add best-effort author/profile follower and page-like counts.
- 🤝 Capture public owner and collaboration profile context when available.
- 🔎 Discover public content URLs from Facebook profile/page URLs.
- 🆔 Extract normalized content and profile fields such as `contentUrl`,
  `contentId`, `contentType`, `profileUsername`, and `profileName`.
- 🚦 Get structured statuses when a URL resolves but public metrics are not
  available.
- 📦 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What Facebook metric data can I extract?

Each dataset row represents one Facebook content URL. The row is flattened and
grouped for scanning: input, content, profile, media text, metrics,
collaboration context, profile metrics, and row status.

| Data group                | Example fields                                                |
| ------------------------- | ------------------------------------------------------------- |
| 🔗 Source attempt         | `platform`, `inputUrl`                                        |
| 🆔 Content entity         | `contentUrl`, `contentId`, `contentType`                      |
| 👤 Author/profile entity  | `profileUrl`, `profileId`, `profileUsername`, `profileName`   |
| 🧾 Media details          | `description`                                                 |
| 📊 Engagement metrics     | `views`, `plays`, `reactions`, `likes`, `comments`, `shares`  |
| 🎯 Content metric quality | `contentMetricStatus`                                         |
| 🤝 Collaboration bridge   | `collaborationCount`, `collaborationProfiles`                 |
| 👥 Author/profile metrics | `profileFollowers`, `profilePageLikes`, `profileMetricStatus` |
| 🚦 Row status             | `status`, `statusReason`, `scrapedAt`                         |

Metric availability depends on what Facebook exposes publicly for each URL.
Reels, watch URLs, and videos usually provide the strongest metric coverage.
Static posts can be partial. URLs with no public content metrics are counted in
`OUTPUT` and skipped from the dataset by default.

`contentType` describes the kind of Facebook content resolved for the row:

Additional source-specific IDs can appear in full JSON exports for API users,
but they are omitted from the default dataset table view to keep the main output
focused.

Facebook Stories URLs, such as `facebook.com/stories/...`, are not supported.

| Content type | Meaning                                      |
| ------------ | -------------------------------------------- |
| `reel`       | Reel-style Facebook video content.           |
| `video`      | Standard Facebook video or watch content.    |
| `post`       | Static Facebook post, including pfbid posts. |
| `photo`      | Direct Facebook photo content.               |
| `unknown`    | The URL resolved, but type was unclear.      |

For video-like content, `views` represents the public video view counter
when Facebook exposes it. `plays` is a broader public play counter when
available, and can be higher than `views`. Keep both when you care about
video measurement details.

`contentMetricStatus` and `profileMetricStatus` include status, precision, and
source details for each public metric. The metric values live in the dedicated
metric fields, not repeated inside the status arrays. Precision values include:

| Precision value      | Meaning                                                                     |
| -------------------- | --------------------------------------------------------------------------- |
| `exact`              | The count was available as a full public number.                            |
| `exact_or_displayed` | The count appeared as a complete displayed number, such as `31,557 views`.  |
| `compact_rounded`    | The count came from public shorthand, such as `3.3M views` or `437K plays`. |

For `compact_rounded` values, the dataset stores the expanded numeric value. For
example, `3.3M views` becomes `3300000`. Treat those values as useful
approximations, not exact counters.

Author/profile metrics are separate from content engagement metrics.
`profileFollowers` and `profilePageLikes` describe the public
profile/page audience. `likes`, `comments`, and `shares` describe
the individual content row.

`collaborationProfiles` contains public owner/byline profile context when it is
available. The first profile is marked `owner`; additional profiles are marked
`collaborator`.

### ⚙️ Can I use this Actor through an API?

Yes. You can run Facebook Metrics Scraper manually in Apify Console
or use it through:

- Apify API
- Python SDK
- Node.js SDK
- Webhooks
- Scheduled runs
- Apify integrations

This makes it useful for social listening workflows, creator dashboards,
competitive intelligence, campaign reporting, content audits, warehouse loads,
and automated market research.

### 🎯 Why scrape Facebook post and reel metrics?

Facebook public engagement data helps you understand which posts, reels, and
videos are gaining traction across creators, brands, campaigns, and competitors.

| Use case                        | How Facebook metric data helps                                          |
| ------------------------------- | ----------------------------------------------------------------------- |
| 📈 Track creator performance    | Monitor public engagement across known creator URLs.                    |
| 🎬 Compare content formats      | Compare reels, videos, and posts side by side.                          |
| 📣 Measure campaign activity    | Collect repeatable metrics for known campaign or brand content URLs.    |
| 🕵️ Run competitive intelligence | Track public engagement on competitor posts and reels you already know. |
| 📊 Build reporting workflows    | Feed normalized Facebook metrics into dashboards and client reports.    |
| 🔎 Audit URL availability       | Separate available, partial, unavailable, and failed rows cleanly.      |

### 💵 How much does scraping Facebook metrics cost?

Facebook Metrics Scraper uses Apify Actor pricing. If the Actor is
monetized, you are charged according to the current price shown on the
**Pricing** tab.

Start with a small batch of 3 to 10 URLs when testing. The run summary shows how
many URLs resolved, how many dataset rows were produced, how many returned no
public metrics, and whether any URLs failed.

### 🚀 How do I use Facebook Metrics Scraper?

1. Create or log in to your Apify account.
2. Open **Facebook Metrics Scraper**.
3. Choose **Auto-detect mixed URLs**, **Content URLs only**, or
   **Profile/page discovery only**.
4. Paste Facebook content URLs, profile/page URLs, or both.
5. Leave the default settings for your first run.
6. Click **Start**.
7. Open the **Output** tab to inspect the dataset and run summary.
8. Download your data in JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### ⬇️ Input

The main input is `startUrls`. Paste at least one supported Facebook URL.
`https://` is optional, so `www.facebook.com/reel/...` works too. Extra spaces
around pasted URLs are ignored. In Auto-detect mixed URLs mode, you can paste
content URLs and profile/page URLs into the same list. Facebook Stories URLs are
rejected by the input form and runtime validation.

```json
{
    "mode": "knownUrls",
    "startUrls": ["https://www.facebook.com/reel/2645452435840671"],
    "maxItemsPerProfile": 20,
    "includePosts": true,
    "includeReels": true,
    "includeVideos": true,
    "includePhotos": false,
    "includeAuthorProfileMetrics": true,
    "maxConcurrency": 3,
    "requestDelayMillis": 250,
    "maxFetchRetries": 3,
    "requestTimeoutSecs": 20
}
````

#### 🔗 Facebook URLs

Supported content URL shapes include:

```text
www.facebook.com/reel/2645452435840671
https://www.facebook.com/reel/2645452435840671
https://www.facebook.com/watch/?v=1203714368298095
https://www.facebook.com/{page}/posts/{post-id-or-pfbid}
https://www.facebook.com/{page}/videos/{video-id}
https://www.facebook.com/{page}/videos/{slug}/{video-id}
https://www.facebook.com/photo?fbid={photo-id}
https://www.facebook.com/photo.php?fbid={photo-id}
https://www.facebook.com/{page}/photos/{photo-id}
https://www.facebook.com/permalink.php?story_fbid={post-id}&id={page-id}
https://fb.watch/{short-code}/
```

Best results usually come from direct reel, watch, video, and photo URLs that
open publicly in a logged-out browser.

`permalink.php?story_fbid=...` is a regular Facebook post permalink shape, not
a Facebook Stories URL.

Facebook Stories URLs such as `facebook.com/stories/...` are not supported.

#### 👤 Profile/Page Discovery

Use profile/page discovery when you want the Actor to find public content URLs
before collecting metrics.

```json
{
    "mode": "profileUrls",
    "startUrls": ["https://www.facebook.com/ThomasSandersOfficial"],
    "maxItemsPerProfile": 20,
    "includePosts": true,
    "includeReels": true,
    "includeVideos": true,
    "includePhotos": false,
    "includeAuthorProfileMetrics": true,
    "maxConcurrency": 3,
    "requestDelayMillis": 250,
    "maxFetchRetries": 3,
    "requestTimeoutSecs": 20
}
```

Use `maxItemsPerProfile` to control how many discovered URLs are resolved from
each profile/page. The default is conservative for routine runs, and larger
values are accepted for high-volume jobs.

#### 🎛️ Settings

| Option                        | What it does                                                                                                 |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `mode`                        | `auto` to detect mixed URLs, `knownUrls` for content URLs only, or `profileUrls` for profile/page discovery. |
| `startUrls`                   | Facebook content and/or profile/page URLs. Paste at least one URL.                                           |
| `maxItemsPerProfile`          | Maximum discovered content URLs to resolve per profile/page.                                                 |
| `includePosts`                | Include discovered post URLs.                                                                                |
| `includeReels`                | Include discovered reel URLs.                                                                                |
| `includeVideos`               | Include discovered video URLs.                                                                               |
| `includePhotos`               | Include public photo URLs found during profile/page discovery. Direct photo URLs are always accepted.        |
| `includeAuthorProfileMetrics` | Fetch each public author/profile once and add best-effort follower and page-like counts.                     |
| `maxConcurrency`              | Controls how many URLs are resolved at the same time.                                                        |
| `requestDelayMillis`          | Adds a minimum delay between public Facebook requests.                                                       |
| `maxFetchRetries`             | Retries transient public request failures before marking a URL failed.                                       |
| `requestTimeoutSecs`          | Maximum wait time for each public Facebook request.                                                          |

### ⬆️ Output sample

The results are stored in the default dataset. Each result is one Facebook
content URL with at least one public content metric.

```json
{
    "platform": "facebook",
    "inputUrl": "https://www.facebook.com/reel/2098858540985362/",
    "contentUrl": "https://www.facebook.com/reel/2098858540985362/",
    "contentId": "2098858540985362",
    "contentType": "reel",
    "profileUrl": "https://www.facebook.com/ExampleCreator",
    "profileId": "123456789",
    "profileUsername": "ExampleCreator",
    "profileName": "Example Creator",
    "description": "Example public reel description",
    "views": 277000,
    "plays": 660000,
    "reactions": 21424,
    "likes": 21424,
    "comments": 267,
    "shares": 553,
    "contentMetricStatus": [
        {
            "metric": "views",
            "status": "present",
            "precision": "exact",
            "source": "public_content"
        },
        {
            "metric": "plays",
            "status": "present",
            "precision": "exact",
            "source": "public_content"
        },
        {
            "metric": "reactions",
            "status": "present",
            "precision": "exact",
            "source": "public_content"
        },
        {
            "metric": "likes",
            "status": "present",
            "precision": "exact",
            "source": "public_content"
        },
        {
            "metric": "comments",
            "status": "present",
            "precision": "exact",
            "source": "public_content"
        },
        {
            "metric": "shares",
            "status": "present",
            "precision": "exact_or_displayed",
            "source": "public_content"
        }
    ],
    "collaborationCount": 1,
    "collaborationProfiles": [
        {
            "id": "123456789",
            "name": "Example Creator",
            "url": "https://www.facebook.com/ExampleCreator",
            "role": "owner",
            "type": "Page"
        }
    ],
    "profileFollowers": 1200000,
    "profilePageLikes": 840000,
    "profileMetricStatus": [
        {
            "metric": "profileFollowers",
            "status": "present",
            "precision": "compact_rounded",
            "source": "public_profile"
        },
        {
            "metric": "profilePageLikes",
            "status": "present",
            "precision": "compact_rounded",
            "source": "public_profile"
        }
    ],
    "status": "ok",
    "statusReason": null,
    "scrapedAt": "2026-06-21T22:15:00.000Z"
}
```

#### 📌 Run summary

Facebook Metrics Scraper also saves an `OUTPUT` summary in the
default key-value store.

```json
{
    "actorName": "facebook-metrics-scraper",
    "mode": "auto",
    "providedUrls": 3,
    "contentUrls": 2,
    "profileUrls": 1,
    "inputUrls": 22,
    "discoveredUrls": 20,
    "resolvedUrls": 21,
    "datasetRows": 18,
    "skippedDatasetRows": 3,
    "skippedFailedRows": 0,
    "skippedInvalidRows": 0,
    "skippedNoPublicMetricRows": 3,
    "metricRows": 18,
    "noPublicMetricRows": 3,
    "failedRows": 0,
    "invalidRows": 0,
    "statusCounts": {
        "ok": 18,
        "resolved_no_public_metrics": 3
    },
    "postTypeCounts": {
        "reel": 12,
        "video": 5,
        "post": 4
    },
    "authorProfileMetricsStatusCounts": {
        "ok": 17,
        "no_public_profile_metrics": 4
    }
}
```

### ❓ Why did I get fewer metrics than expected?

The Actor returns only metrics that Facebook exposes publicly without login. A
successful URL resolution does not guarantee that every metric is available.

Common reasons include:

- Facebook exposed preview-level counts but not richer engagement counters.
- A static post exposed only partial metrics, such as shares.
- Some static posts did not expose public counts.
- The content requires login, is private, removed, region-limited, age-gated, or
  otherwise unavailable to logged-out users.
- The rendered Facebook UI rounds or updates counters differently from public
  data available at collection time.

Use `contentMetricStatus`, `profileMetricStatus`, and `statusReason` to decide
whether a row is suitable for your reporting workflow.

### ✅ Tips for scraping Facebook metrics

- Start with a small test run and inspect the dataset before increasing volume.
- Use direct Facebook content URLs whenever possible.
- Prefer reel, watch, and video URLs for richer public metric availability.
- Leave `includeAuthorProfileMetrics` on when you want follower/page-like
  context.
- Keep `maxConcurrency` modest for steadier large runs.
- Leave network and retry settings at their defaults unless you have a specific
  reason to change them.
- Failed, invalid, and no-public-metric input rows are counted in `OUTPUT` and
  `SKIPPED_DATASET_ROWS` but are not pushed to the dataset by default.
- Treat `resolved_no_public_metrics` as an audit status in `OUTPUT`, not a
  failed run.

### ⚖️ Is it legal to scrape Facebook post and reel metrics?

This Actor extracts public Facebook data that is available without login. You
are responsible for making sure your use case complies with applicable laws,
platform terms, and privacy rules.

Facebook content can sometimes include personal data, names, profile details, or
other sensitive information. Do not scrape, store, or process personal data
unless you have a legitimate reason and the right legal basis. If you're unsure,
consult your lawyers.

Facebook is a trademark of its owner. This Actor is independent and is not
affiliated with, endorsed by, or sponsored by Facebook or Meta.

### 🛟 Support

If a run does not return what you expected, open an issue with the run ID and the
input URLs you used. Include the dataset row for the affected URL when possible.
The row-level `status`, `statusReason`, `contentMetricStatus`, and
`profileMetricStatus` fields make support specific.

Related searches: Facebook scraper, Facebook posts scraper, Facebook reels
scraper, Facebook post metrics scraper, Facebook reel metrics scraper, Facebook
post engagement scraper, Facebook video metrics scraper, Facebook public metrics,
Facebook likes scraper, Facebook comments count scraper, Facebook shares
scraper, Facebook views scraper, no-cookie Facebook scraper.

# Actor input Schema

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

Choose how to use the URLs below. Auto-detect mixed URLs accepts content URLs and profile/page URLs in the same list.

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

Paste at least one supported Facebook post, reel, watch, video, photo, profile, or page URL. Facebook Stories URLs are not accepted.

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

Backward-compatible API field for users that still send known content URLs as urls.

## `profileUrls` (type: `array`):

Backward-compatible API field for users that still send profile/page URLs as profileUrls.

## `maxItemsPerProfile` (type: `integer`):

Maximum number of discovered public content URLs to resolve from each profile/page URL.

## `includePosts` (type: `boolean`):

Include public post URLs found on profile/page pages.

## `includeReels` (type: `boolean`):

Include public reel URLs found on profile/page pages.

## `includeVideos` (type: `boolean`):

Include public video URLs found on profile/page pages.

## `includePhotos` (type: `boolean`):

Include public photo URLs found on profile/page pages. Direct photo URLs are always accepted when provided as input.

## `includeAuthorProfileMetrics` (type: `boolean`):

Fetch each public author/profile page once per run and add best-effort follower and page-like counts when Facebook exposes them without login.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for each public Facebook request.

## `maxConcurrency` (type: `integer`):

Maximum number of URLs to resolve at the same time.

## `requestDelayMillis` (type: `integer`):

Minimum delay between public Facebook requests.

## `maxFetchRetries` (type: `integer`):

Number of retry attempts for transient public request failures.

## `includeFailedRows` (type: `boolean`):

API option. When false, failed, invalid, and no-public-metric rows are counted in the run summary but not pushed to the dataset.

## Actor input object example

```json
{
  "mode": "knownUrls",
  "startUrls": [
    "https://www.facebook.com/reel/2645452435840671"
  ],
  "urls": [],
  "profileUrls": [],
  "maxItemsPerProfile": 20,
  "includePosts": true,
  "includeReels": true,
  "includeVideos": true,
  "includePhotos": false,
  "includeAuthorProfileMetrics": true,
  "requestTimeoutSecs": 20,
  "maxConcurrency": 3,
  "requestDelayMillis": 250,
  "maxFetchRetries": 3,
  "includeFailedRows": false
}
```

# Actor output Schema

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

No description

## `output` (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 = {
    "mode": "knownUrls",
    "startUrls": [
        "https://www.facebook.com/reel/2645452435840671"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/facebook-metrics-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 = {
    "mode": "knownUrls",
    "startUrls": ["https://www.facebook.com/reel/2645452435840671"],
}

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/facebook-metrics-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 '{
  "mode": "knownUrls",
  "startUrls": [
    "https://www.facebook.com/reel/2645452435840671"
  ]
}' |
apify call chronometrica/facebook-metrics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Metrics Scraper",
        "description": "Collect public Facebook engagement metrics from post, reel, watch, video, photo, and profile/page URLs without login or cookies. Get views, plays, reactions, likes, comments, shares, author follower counts, content IDs, availability statuses, and clean run summaries.",
        "version": "1.1",
        "x-build-id": "uxrZZaoldcphkKJIw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~facebook-metrics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-facebook-metrics-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/chronometrica~facebook-metrics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-facebook-metrics-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/chronometrica~facebook-metrics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-facebook-metrics-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",
                "properties": {
                    "mode": {
                        "title": "URL handling",
                        "enum": [
                            "auto",
                            "knownUrls",
                            "profileUrls"
                        ],
                        "type": "string",
                        "description": "Choose how to use the URLs below. Auto-detect mixed URLs accepts content URLs and profile/page URLs in the same list.",
                        "default": "knownUrls"
                    },
                    "startUrls": {
                        "title": "Facebook URLs",
                        "minItems": 0,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste at least one supported Facebook post, reel, watch, video, photo, profile, or page URL. Facebook Stories URLs are not accepted.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\s*(?:https?:\\/\\/)?(?:(?:(?:www\\.|m\\.|mbasic\\.)?facebook\\.com\\/(?!stories(?:[\\/?#]|$))\\S.*)|(?:fb\\.watch\\/\\S.*))\\s*$"
                        },
                        "default": [
                            "https://www.facebook.com/reel/2645452435840671"
                        ]
                    },
                    "urls": {
                        "title": "Legacy content URLs",
                        "type": "array",
                        "description": "Backward-compatible API field for users that still send known content URLs as urls.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "profileUrls": {
                        "title": "Legacy profile URLs",
                        "type": "array",
                        "description": "Backward-compatible API field for users that still send profile/page URLs as profileUrls.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxItemsPerProfile": {
                        "title": "Content URLs per profile/page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of discovered public content URLs to resolve from each profile/page URL.",
                        "default": 20
                    },
                    "includePosts": {
                        "title": "Discover posts",
                        "type": "boolean",
                        "description": "Include public post URLs found on profile/page pages.",
                        "default": true
                    },
                    "includeReels": {
                        "title": "Discover reels",
                        "type": "boolean",
                        "description": "Include public reel URLs found on profile/page pages.",
                        "default": true
                    },
                    "includeVideos": {
                        "title": "Discover videos",
                        "type": "boolean",
                        "description": "Include public video URLs found on profile/page pages.",
                        "default": true
                    },
                    "includePhotos": {
                        "title": "Discover photos",
                        "type": "boolean",
                        "description": "Include public photo URLs found on profile/page pages. Direct photo URLs are always accepted when provided as input.",
                        "default": false
                    },
                    "includeAuthorProfileMetrics": {
                        "title": "Add author/profile metrics",
                        "type": "boolean",
                        "description": "Fetch each public author/profile page once per run and add best-effort follower and page-like counts when Facebook exposes them without login.",
                        "default": true
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Maximum seconds to wait for each public Facebook request.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of URLs to resolve at the same time.",
                        "default": 3
                    },
                    "requestDelayMillis": {
                        "title": "Request delay",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum delay between public Facebook requests.",
                        "default": 250
                    },
                    "maxFetchRetries": {
                        "title": "Fetch retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of retry attempts for transient public request failures.",
                        "default": 3
                    },
                    "includeFailedRows": {
                        "title": "Output failed rows",
                        "type": "boolean",
                        "description": "API option. When false, failed, invalid, and no-public-metric rows are counted in the run summary but not pushed to the dataset.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
