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

Extract Facebook Reels data including video information, engagement metrics, and metadata from Facebook pages.

- **URL**: https://apify.com/scrapeengine/facebook-reels-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 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/platform/actors/running/actors-in-store#rental-actors

## 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 Reels Scraper

Facebook Reels Scraper is a purpose-built Apify actor that collects public Facebook Reels from the profiles you choose and turns them into structured records for analysis and export. It helps you scrape Facebook Reels videos at scale — extracting captions, timing, shareable links, and rich media context — without manual effort. Ideal for marketers, developers, data analysts, and researchers, this Facebook Reels extractor powers monitoring, reporting, and archiving workflows with robust pagination and proxy support. 🚀

### What data / output can you get?

Each dataset item represents one Reel with normalized fields plus nested metadata for deeper analysis and downstream workflows (e.g., Facebook Reels to CSV export).

| Data field | Description | Example value |
| --- | --- | --- |
| facebookUrl | Base Facebook page/profile URL for the Reel’s owner | https://www.facebook.com/LeonardoDiCaprio/ |
| startUrl | The original profile URL you provided in input | https://www.facebook.com/LeonardoDiCaprio/ |
| inputUrl | The Reel page URL requested during extraction | https://www.facebook.com/reel/123456789012345 |
| topLevelUrl | Top-level post URL derived from the post_id (when available) | https://facebook.com/607752005666436/posts/undefined/ |
| topLevelReelUrl | Canonical/shareable Reel permalink (normalized with trailing “/”) | https://www.facebook.com/reel/123456789012345/ |
| text | Reel caption/description (if present) | “Protecting our oceans starts today.” |
| time | ISO timestamp (UTC) derived from publish/creation time | 2026-03-18T12:00:00.000Z |
| playCountRounded | Numeric play count normalized from display string | 3600000 |
| play_count_reduced | Display-friendly play count string from Facebook | 3.6M |
| video_owner | Reel owner object (e.g., name, URL, verification) | {"name":"Leonardo DiCaprio","url":"https://www.facebook.com/LeonardoDiCaprio/"} |
| playback_video | Playback metadata (dimensions, length, thumbnails, audio info) | {"height":1350,"width":1080,"length_in_second":30.0,"image":{"uri":"https://.../thumb.jpg"}} |
| video | Video object with enriched fields (e.g., id, duration, thumbnail) | {"id":"123456789012345","playable_duration_in_ms":30000,"first_frame_thumbnail":"https://.../thumb.jpg"} |
| attachments | Media attachment array (when available) | [{"media":{"__typename":"Video","id":"123456789012345"}}] |
| tracking | Tracking metadata dictionary (e.g., top_level_post_id) | {"top_level_post_id":"123456789012345"} |

Notes:
- Additional fields can appear when present on the page, including: is_passive_content, fb_shorts_reshare_context, remix_info, video_owner_type, soundtrack_info (e.g., type = CUSTOM_AUDIO when original), track_title, music_album_art_uri, is_original_audio_on_facebook, shareable_url, if_should_change_url_for_reels.
- Optional diagnostic fields may appear on edge cases: parse_error (if page JSON couldn’t be parsed), request_error (if the request failed), http_status (only when status != 200).
- Export your dataset to JSON, CSV, or Excel directly from Apify.

### Key features

- 🧭 Robust ID discovery & GraphQL-backed pagination  
  Harvests Reel IDs from profile and Reels tab HTML, then paginates via Facebook’s GraphQL to collect more items reliably.

- ⚡ Batch scraping & per-profile limits  
  Queue multiple profiles at once and cap collection using “Max Reels per profile” (resultsLimit) — up to 10,000 Reels per profile.

- 🔒 Proxy-ready for stability  
  Built-in Apify Proxy integration with recommended RESIDENTIAL group for resilient Facebook Reels API scraper–style runs.

- 📥 Streaming dataset writes  
  Items are pushed as soon as each Reel is saved — no need to wait for the entire run to finish.

- 🧾 Analysis-ready structure  
  Normalized counters (playCountRounded) alongside raw objects (video, playback_video) to power Facebook Reels analytics scraper workflows.

- 👩‍💻 Developer friendly (Python + Apify SDK)  
  Integrate via Apify API, orchestrate with schedulers, or plug into pipelines — a practical Facebook Reels automation bot foundation.

- 🛡️ Resilient by design  
  Retries, pacing across profiles, and controlled parallel requests reduce throttling and improve success.

- 📤 Easy exports  
  Open the run’s Dataset to export Reels data to CSV, JSON, or Excel for BI tools and reporting.

### How to use Facebook Reels Scraper - step by step

1. Sign in to Apify and open the Facebook Reels Scraper actor.  
2. Add Profile URLs under startUrls. You can paste full links (e.g., https://www.facebook.com/LeonardoDiCaprio/) or bare usernames — the actor resolves them.  
3. Set Max Reels per profile via resultsLimit (1 to 10,000) to control how many Reels are collected from each profile.  
4. (Optional) Apply a time filter with onlyPostsNewerThan. Use an absolute date (YYYY-MM-DD) or a relative window like “7 days” or “2 weeks”.  
5. (Optional) Configure proxyConfiguration. Residential proxies are recommended for Facebook; you can select the RESIDENTIAL group.  
6. Start the run. The actor discovers Reel IDs, paginates where available, and pushes each Reel to the dataset as it’s processed.  
7. Export results. In the run’s Dataset tab, download as JSON, CSV, or Excel for dashboards, ETL, or audits.

Pro Tip: Schedule this Facebook Reels scraping tool to run on a cadence and feed a Facebook Reels to CSV export or data lake for ongoing analytics.

### Use cases

| Use case | Description |
| --- | --- |
| Marketing analytics for Facebook Reels | Aggregate captions, timestamps, and play counts to benchmark creator/page performance and content themes. |
| Brand monitoring & competitive tracking | Track public Reels across competitors and measure cadence and engagement signals over time. |
| Content archiving & compliance | Preserve public Reel metadata and media context for audits, accessibility, or research repositories. |
| Research & academic studies | Build longitudinal datasets for topic analysis, messaging trends, and media narratives on public pages. |
| Data engineering pipelines | Feed structured items (JSON/CSV/Excel) into ETL, lakes, or warehouses for BI and reporting. |
| API/Python automation | Use the Apify API to integrate this Facebook Reels crawler into workflows, orchestrations, and no-code tools. |

### Why choose Facebook Reels Scraper?

Built for precision, automation, and reliability, this Facebook Reels scraping tool focuses on public data at scale.

- ✅ Accurate, structured records: Normalized counters plus raw video/playback objects for deeper analysis.
- 🌍 Scales across profiles: Process multiple pages in one run with clear per-profile limits.
- 👩‍💻 Developer access: Python-based actor with Apify API integration for pipelines and scheduled jobs.
- 🛡️ Safer operations: Targets publicly available content; supports proxies to reduce blocks.
- 💸 Cost-effective automation: Run in the cloud and export to your analytics stack.
- 🔁 Production-ready reliability: Retries, pacing, and streaming writes outperform brittle browser extensions.

In short: a stable Facebook Reels data scraper vs. unstable, manual alternatives.

### Is it legal / ethical to use Facebook Reels Scraper?

Yes — when used responsibly. This actor targets publicly available Reels data on Facebook pages and does not require login.

Guidelines for compliant use:
- Only collect publicly accessible content (no private or login-gated data).
- Avoid personal/sensitive information and respect privacy regulations (e.g., GDPR/CCPA).
- Review and respect the platform’s terms and applicable laws for your jurisdiction and use case.
- Consult your legal team for redistribution or commercial edge cases.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.facebook.com/LeonardoDiCaprio/",
    "mrbeast"
  ],
  "resultsLimit": 25,
  "onlyPostsNewerThan": "7 days",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Input parameter reference

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array(string) | Yes | — | One URL per line — e.g., facebook.com/YourPage or a /people/... link. Usernames without https:// work too. |
| resultsLimit | integer | No | 10 | Stop after this many Reels from each profile (newest-first order where available). Min 1, max 10,000. |
| onlyPostsNewerThan | string | No | "" | Absolute date (YYYY-MM-DD) or relative window like “7 days”, “2 weeks”. Leave blank for no cutoff. |
| proxyConfiguration | object | No | {"useApifyProxy": true, "apifyProxyGroups": \["RESIDENTIAL"]} | Route traffic through Apify Proxy (recommended for fewer blocks). Residential proxy is recommended for Facebook. |

#### Example JSON output

Each Reel is pushed to the dataset as a separate item. Keys may vary depending on what Facebook returns for a given Reel.

```json
{
  "facebookUrl": "https://www.facebook.com/LeonardoDiCaprio/",
  "startUrl": "https://www.facebook.com/LeonardoDiCaprio/",
  "inputUrl": "https://www.facebook.com/reel/123456789012345",
  "topLevelUrl": "https://facebook.com/123456789012345/posts/undefined/",
  "topLevelReelUrl": "https://www.facebook.com/reel/123456789012345/",
  "text": "Protecting our oceans starts today.",
  "time": "2026-03-18T12:00:00.000Z",
  "playCountRounded": 3600000,
  "play_count_reduced": "3.6M",
  "attachments": [
    {
      "media": {
        "__typename": "Video",
        "id": "123456789012345",
        "playable_duration_in_ms": 30000
      }
    }
  ],
  "tracking": {
    "top_level_post_id": "123456789012345"
  },
  "self_view_boost": null,
  "video": {
    "id": "123456789012345",
    "playable_duration_in_ms": 30000,
    "first_frame_thumbnail": "https://example-cdn.fbcdn.net/thumb.jpg",
    "embeddable": true,
    "__typename": "Video"
  },
  "if_should_change_url_for_reels": {
    "shareable_url": "https://www.facebook.com/reel/123456789012345/"
  },
  "shareable_url": "https://www.facebook.com/reel/123456789012345/",
  "playback_video": {
    "height": 1350,
    "width": 1080,
    "length_in_second": 30.0,
    "image": {
      "uri": "https://example-cdn.fbcdn.net/thumb.jpg"
    },
    "audio_user_preferred_language": "en"
  },
  "video_owner": {
    "name": "Leonardo DiCaprio",
    "url": "https://www.facebook.com/LeonardoDiCaprio/"
  },
  "is_passive_content": false,
  "fb_shorts_reshare_context": {},
  "remix_info": {},
  "video_owner_type": "FACEBOOK_PAGE",
  "soundtrack_info": {
    "type": "CUSTOM_AUDIO"
  },
  "track_title": "Leonardo DiCaprio · Original audio",
  "music_album_art_uri": "https://example-cdn.fbcdn.net/album-art.jpg",
  "is_original_audio_on_facebook": true
}
```

In rare cases, the actor adds diagnostic or error items:

- When a profile fails entirely:

```json
{
  "startUrl": "https://www.facebook.com/SomePage/",
  "error": "TimeoutError('profile fetch timed out')",
  "type": "profile_error"
}
```

- When a specific Reel fails to load:

```json
{
  "startUrl": "https://www.facebook.com/SomePage/",
  "inputUrl": "https://www.facebook.com/reel/999999999999999",
  "request_error": "RequestException"
}
```

Notes:

- Optional keys like parse\_error and http\_status only appear when non-200 responses occur or when page JSON couldn’t be parsed.
- Some nested fields (e.g., soundtrack\_info, track\_title, music\_album\_art\_uri) may be missing when not present in Facebook’s response.

### FAQ

#### Is there a free trial for Facebook Reels Scraper?

Yes. This actor includes trial minutes on Apify (120 trial minutes are configured), allowing you to validate results and workflows before scaling.

#### Do I need to log in to scrape Facebook Reels?

No. The actor targets public Facebook Reels and does not require login or cookies. It uses request headers and supports proxies to improve reliability.

#### Can I use this as a Facebook Reels API scraper alternative?

Yes. You can access dataset items programmatically via the Apify API, making it a practical Facebook Reels API scraper alternative for public metadata.

#### How many Reels can I collect per profile?

You control this via resultsLimit, from 1 up to 10,000 per profile. Actual counts depend on how many public Reels Facebook returns for that profile.

#### Does it download videos?

The actor extracts playback\_video and related metadata when available. While it’s not a Facebook Reels downloader by itself, these fields enable downstream workflows to bulk download Facebook Reels where permitted.

#### Can it scrape by hashtag or keywords?

No. This is a Facebook Reels crawler focused on profiles/pages. Provide profile URLs or usernames via startUrls. Hashtag-based discovery is not supported.

#### Does it scrape comments, likes, or shares?

No. This version focuses on Reel metadata (e.g., captions, time, shareable URLs, playback and owner info). Engagement breakdowns and comments are not pushed to the dataset.

#### How do I export results to CSV?

Open the run’s Dataset in Apify and choose CSV, JSON, or Excel. This supports quick Facebook Reels to CSV exports for analysis or BI.

#### Can I automate with Python or no-code tools?

Yes. The actor is implemented in Python and runs on Apify. Use the Apify API for programmatic access or schedule runs for a repeatable Facebook Reels scraping tool in your pipeline.

### Closing CTA / Final thoughts

Facebook Reels Scraper is built to turn public Reels into structured, analytics-ready data at scale. With GraphQL-backed discovery, proxy support, and streaming dataset writes, it helps marketers, developers, analysts, and researchers automate reliable Facebook Reels data extraction. Access results via the Apify API, export to CSV/JSON/Excel, and integrate with your pipelines — start extracting smarter with a production-ready Facebook Reels data scraper today.

# Actor input Schema

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

One URL per line — e.g. facebook.com/YourPage or a /people/… link. Usernames without https:// work too.

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

Stop after this many Reels from each profile (newest-first order where available).

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

📆 Absolute: pick a date. ⏱️ Relative: e.g. 7 days, 2 weeks. Leave blank for no cutoff.

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

Route traffic through Apify Proxy (recommended for fewer blocks).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/people/Emily-Olivia/61563061022550/",
    "https://www.facebook.com/LeonardoDiCaprio/"
  ],
  "resultsLimit": 10,
  "onlyPostsNewerThan": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.facebook.com/people/Emily-Olivia/61563061022550/",
        "https://www.facebook.com/LeonardoDiCaprio/"
    ],
    "resultsLimit": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeengine/facebook-reels-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        "https://www.facebook.com/people/Emily-Olivia/61563061022550/",
        "https://www.facebook.com/LeonardoDiCaprio/",
    ],
    "resultsLimit": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeengine/facebook-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 '{
  "startUrls": [
    "https://www.facebook.com/people/Emily-Olivia/61563061022550/",
    "https://www.facebook.com/LeonardoDiCaprio/"
  ],
  "resultsLimit": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapeengine/facebook-reels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reels Scraper",
        "description": "Extract Facebook Reels data including video information, engagement metrics, and metadata from Facebook pages.",
        "version": "1.0",
        "x-build-id": "1J04F8dNGUj9Nxofr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~facebook-reels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-facebook-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/scrapeengine~facebook-reels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-facebook-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/scrapeengine~facebook-reels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-facebook-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "📍 Profile URLs",
                        "type": "array",
                        "description": "One URL per line — e.g. facebook.com/YourPage or a /people/… link. Usernames without https:// work too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "🔢 Max Reels per profile",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many Reels from each profile (newest-first order where available).",
                        "default": 10
                    },
                    "onlyPostsNewerThan": {
                        "title": "🕐 Only posts newer than",
                        "type": "string",
                        "description": "📆 Absolute: pick a date. ⏱️ Relative: e.g. 7 days, 2 weeks. Leave blank for no cutoff.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy",
                        "type": "object",
                        "description": "Route traffic through Apify Proxy (recommended for fewer blocks)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
