# Facebook Reels & Video Scraper - MP4, Transcript, No Login (`apivault_labs/facebook-reels-video-scraper`) Actor

Scrape & download public Facebook Reels and Videos without login. Get the MP4 link, thumbnail, caption, hashtags, views, reactions, comments, creator info and transcript/subtitles. Search by keyword, filter by date, geo-target, real-time webhook. Pay per result, hard cost caps - no runaway bills.

- **URL**: https://apify.com/apivault\_labs/facebook-reels-video-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 video scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Reels & Video Scraper — MP4 Download, Transcript, No Login

![Facebook Reels & Video Scraper — download MP4, transcript, views, creator data, no login](https://api.apify.com/v2/key-value-stores/E76hLVOROveornuAY/records/facebook-reels-hero-v2.jpg)

**Scrape and download public Facebook Reels and Videos without login or cookies.** Give the scraper a Reel/Video URL — or just a keyword — and get back the direct **MP4 download link**, thumbnail, caption, hashtags, view count, reactions, comments, shares, creator details and a clean **transcript / subtitles**. Export to JSON, CSV or Excel.

Built for **predictable cost and reliability**: hard spend caps, charge-only-on-success, automatic proxy rotation and clean run-and-exit — **no runaway bills**.

---

### ✅ What this Facebook video scraper does

- 📥 **Download Facebook Reels & Videos (MP4)** — direct HD + SD links for every video
- 📝 **Transcript & subtitles** — native captions parsed to text + timed cues (free), or bring your own speech-to-text key
- 🔎 **Keyword & hashtag search** — discover public Reels/Videos via search engines, no URL list needed
- 📊 **Full engagement data** — views, reactions, comments, shares + a 0–100 engagement score
- 👤 **Creator info** — name, profile URL, ID, followers, rating
- 🏷️ **Smart metadata** — hashtags, @mentions, auto category, language, music/audio, resolution & orientation
- 📅 **Date filter, geo-targeting, real-time webhook, retries** — control that most scrapers skip

No login, no cookies, no API key. Only public content.

### 📦 Output (per video)

| Field | Description |
|---|---|
| `videoId`, `videoUrl`, `videoType` | ID, canonical URL, reel/video/live |
| `title`, `caption`, `hashtags`, `mentions`, `category`, `language` | Content & metadata |
| `videoMp4Url` (+ HD/SD), `thumbnailUrl`, `durationSeconds` | Media & download links |
| `width`, `height`, `aspectRatio`, `orientation` | Video dimensions |
| `viewCount`, `reactionCount`, `commentCount`, `shareCount`, `engagementScore` | Engagement |
| `creatorName`, `creatorUrl`, `creatorId`, `creatorFollowers`, `creatorRating` | Creator |
| `publishedAt`, `musicTitle`, `musicArtist` | Timing & audio |
| `transcript`, `transcriptCues`, `transcriptSummary`, `hasTranscript` | Transcript |

### ⚙️ Input

| Field | What it does |
|---|---|
| `startUrls` | Reel/Video URLs — `/reel/<id>`, `/watch/?v=<id>`, `/<page>/videos/<id>`, `fb.watch/…`, bare IDs |
| `searchQueries` | Keywords / #hashtags to discover public Reels & Videos |
| `maxResults`, `maxCostUsd` | Hard caps on results and spend — the run stops when reached |
| `sinceDays`, `keywordFilter` | Keep only recent videos / captions matching a keyword |
| `downloadMp4`, `includeTranscript` | Toggle MP4 links and native transcript |
| `transcribeWithAsr` + `asrApiKey` | Optional: transcribe audio with **your own** OpenAI-compatible speech-to-text key |
| `proxyCountry` | Geo-target the proxy (US, GB, DE, …) |
| `maxConcurrency`, `timeout`, `maxRetries` | Throughput & reliability |
| `notifyWebhookUrl` | POST each result to Zapier / Make / n8n / Slack in real time |

#### Example input

```json
{
  "searchQueries": ["#fitness"],
  "startUrls": ["https://www.facebook.com/reel/1234567890123456"],
  "maxResults": 50,
  "sinceDays": 30,
  "downloadMp4": true,
  "includeTranscript": true,
  "proxyCountry": "US"
}
````

### 🆚 Why choose this scraper

| Feature | This scraper | Typical competitor |
|---|:--:|:--:|
| URL/ID input + MP4 + engagement | ✅ | ✅ |
| Transcript / captions | ✅ | some |
| Keyword search | ✅ | some |
| **Date / recency filter** | ✅ | rare |
| **Category & music metadata** | ✅ | rare |
| **Creator rating** | ✅ | rare |
| **Geo-targeting** | ✅ | rare |
| **Real-time webhook** | ✅ | rare |
| **Hard spend cap (no runaway bills)** | ✅ | rare |

### 💡 Use cases

- **Download Facebook Reels** in bulk for re-use, archives or analysis
- **Video transcript extraction** for SEO, captions, repurposing to blog/LinkedIn
- **Competitor & creator research** — track engagement, hooks and posting cadence
- **Trend & hashtag monitoring** — find top-performing Reels in any niche
- **Ad creative & influencer scouting** — filter by engagement, followers, recency
- Feeding **n8n / Make / Zapier** automations and **AI agents (MCP)**

### 💸 Pricing

Pay per result. You're charged **only for videos successfully scraped and saved** — filtered, duplicate or failed items are free. Set `maxResults` / `maxCostUsd` to cap spend to the cent. No subscriptions, no surprise bills.

### ❓ FAQ

**Do I need to log in or provide cookies?** No. The scraper only reads public Reels and Videos.

**Can I download the MP4?** Yes — `videoMp4Url` gives a direct HD/SD link. Facebook links are time-limited, so download promptly.

**Does it get the transcript?** Yes, when the video has captions (parsed to text). For videos without captions, enable BYO speech-to-text with your own API key.

**Can I search instead of providing URLs?** Yes — use `searchQueries` with keywords or #hashtags.

**How do I avoid unexpected costs?** Use `maxResults` and `maxCostUsd`; the run stops at your cap and only bills saved videos.

**What about private videos?** Only public content is returned. Private/removed videos are reported with a clear status and are not billed.

***

*Not affiliated with or endorsed by Facebook/Meta. Use responsibly and in line with applicable laws and platform terms; scrape only public data.*

# Actor input Schema

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

Public Facebook Reel or Video URLs. Supports /reel/<id>, /watch/?v=<id>, /<page>/videos/<id>, fb.watch short links and bare numeric video IDs. Multiple inputs run in parallel.

## `searchQueries` (type: `array`):

Optional. Keywords or #hashtags to discover public Reels/Videos via search engines (keyless) — results are resolved to reel/video pages and enriched. Use instead of, or together with, URLs.

## `maxResults` (type: `integer`):

Hard cap on the number of videos scraped and billed. Protects against runaway cost from large searches. 0 = no cap.

## `maxCostUsd` (type: `number`):

Hard budget in USD. The run stops charging/scraping once this estimated cost is reached. 0 = no budget cap.

## `sinceDays` (type: `integer`):

Recency filter (gap feature — only 1/12 competitors have it). Keep only videos published within the last N days. Empty = no date filter.

## `keywordFilter` (type: `string`):

Optional. Keep only videos whose caption/description contains this keyword (case-insensitive).

## `enrichDetailPage` (type: `boolean`):

Fetch the full video page for richer data — view count, exact publish time, full caption, captions/subtitle track, creator follower count (gap feature — only 1/12). Slightly slower per video.

## `downloadMp4` (type: `boolean`):

Extract direct MP4 (HD/SD) playable URLs for each video. URLs are time-limited by Facebook — download promptly.

## `includeTranscript` (type: `boolean`):

When the video has Facebook auto-generated or uploaded captions, fetch and parse them into plain-text transcript + timed cues. Free (no third-party ASR).

## `transcribeWithAsr` (type: `boolean`):

Optional. When no native captions exist, download the audio and transcribe it via YOUR OpenAI-compatible speech-to-text endpoint. You pay the ASR provider directly with your key.

## `asrApiKey` (type: `string`):

Your OpenAI-compatible API key used only for audio transcription. Never stored or logged.

## `asrModel` (type: `string`):

Speech-to-text model name (e.g. whisper-1).

## `asrBaseUrl` (type: `string`):

OpenAI-compatible base URL for the transcription endpoint.

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

How many videos to scrape in parallel. Higher is faster; residential IPs rotate per request. Recommended 5-10.

## `timeout` (type: `integer`):

Maximum time to wait for each video fetch.

## `maxRetries` (type: `integer`):

Retries for a failed/blocked fetch, each rotating a fresh proxy IP with exponential backoff (gap feature — only 2/12). 0-8.

## `useResidentialProxy` (type: `boolean`):

Datacenter proxy is used first (cheap). When a video is blocked on datacenter, the Actor escalates to Apify residential proxy. Disable to stay datacenter-only (cheapest, but a few blocked videos may fail).

## `proxyCountry` (type: `string`):

ISO 2-letter country code (e.g. US, GB, DE). Geo-targets both datacenter and residential proxy to get region-specific availability and avoid locale redirects. Empty = automatic.

## `dedupe` (type: `boolean`):

Drop duplicate input URLs and duplicate output videos (same video ID), so the same Reel is never scraped or billed twice.

## `notifyWebhookUrl` (type: `string`):

Optional. Each scraped video is POSTed as JSON to this URL the moment it's found (Zapier / Make / n8n / Slack / Discord) — gap feature, only 1/12.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/reel/1234567890123456",
    "https://www.facebook.com/watch/?v=1234567890123456"
  ],
  "searchQueries": [],
  "maxResults": 50,
  "maxCostUsd": 0,
  "enrichDetailPage": true,
  "downloadMp4": true,
  "includeTranscript": true,
  "transcribeWithAsr": false,
  "asrModel": "whisper-1",
  "asrBaseUrl": "https://api.openai.com/v1",
  "maxConcurrency": 5,
  "timeout": 45,
  "maxRetries": 2,
  "useResidentialProxy": true,
  "proxyCountry": "US",
  "dedupe": true
}
```

# 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/reel/1234567890123456",
        "https://www.facebook.com/watch/?v=1234567890123456"
    ],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/facebook-reels-video-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/reel/1234567890123456",
        "https://www.facebook.com/watch/?v=1234567890123456",
    ],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/facebook-reels-video-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/reel/1234567890123456",
    "https://www.facebook.com/watch/?v=1234567890123456"
  ],
  "searchQueries": []
}' |
apify call apivault_labs/facebook-reels-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reels & Video Scraper - MP4, Transcript, No Login",
        "description": "Scrape & download public Facebook Reels and Videos without login. Get the MP4 link, thumbnail, caption, hashtags, views, reactions, comments, creator info and transcript/subtitles. Search by keyword, filter by date, geo-target, real-time webhook. Pay per result, hard cost caps - no runaway bills.",
        "version": "0.1",
        "x-build-id": "YSoqBdOaaLCGSvz8I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apivault_labs~facebook-reels-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apivault_labs-facebook-reels-video-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/apivault_labs~facebook-reels-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apivault_labs-facebook-reels-video-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/apivault_labs~facebook-reels-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apivault_labs-facebook-reels-video-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": {
                    "startUrls": {
                        "title": "Facebook Reel / Video URLs",
                        "type": "array",
                        "description": "Public Facebook Reel or Video URLs. Supports /reel/<id>, /watch/?v=<id>, /<page>/videos/<id>, fb.watch short links and bare numeric video IDs. Multiple inputs run in parallel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Keyword / hashtag search (optional)",
                        "type": "array",
                        "description": "Optional. Keywords or #hashtags to discover public Reels/Videos via search engines (keyless) — results are resolved to reel/video pages and enriched. Use instead of, or together with, URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (cost cap)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on the number of videos scraped and billed. Protects against runaway cost from large searches. 0 = no cap.",
                        "default": 50
                    },
                    "maxCostUsd": {
                        "title": "Max cost USD (cost cap)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Hard budget in USD. The run stops charging/scraping once this estimated cost is reached. 0 = no budget cap.",
                        "default": 0
                    },
                    "sinceDays": {
                        "title": "Only videos from last N days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Recency filter (gap feature — only 1/12 competitors have it). Keep only videos published within the last N days. Empty = no date filter."
                    },
                    "keywordFilter": {
                        "title": "Caption keyword filter",
                        "type": "string",
                        "description": "Optional. Keep only videos whose caption/description contains this keyword (case-insensitive)."
                    },
                    "enrichDetailPage": {
                        "title": "Detail-page enrichment",
                        "type": "boolean",
                        "description": "Fetch the full video page for richer data — view count, exact publish time, full caption, captions/subtitle track, creator follower count (gap feature — only 1/12). Slightly slower per video.",
                        "default": true
                    },
                    "downloadMp4": {
                        "title": "Extract MP4 download URL",
                        "type": "boolean",
                        "description": "Extract direct MP4 (HD/SD) playable URLs for each video. URLs are time-limited by Facebook — download promptly.",
                        "default": true
                    },
                    "includeTranscript": {
                        "title": "Include native captions / transcript",
                        "type": "boolean",
                        "description": "When the video has Facebook auto-generated or uploaded captions, fetch and parse them into plain-text transcript + timed cues. Free (no third-party ASR).",
                        "default": true
                    },
                    "transcribeWithAsr": {
                        "title": "Transcribe audio with my ASR key (BYO)",
                        "type": "boolean",
                        "description": "Optional. When no native captions exist, download the audio and transcribe it via YOUR OpenAI-compatible speech-to-text endpoint. You pay the ASR provider directly with your key.",
                        "default": false
                    },
                    "asrApiKey": {
                        "title": "ASR API key (BYO)",
                        "type": "string",
                        "description": "Your OpenAI-compatible API key used only for audio transcription. Never stored or logged."
                    },
                    "asrModel": {
                        "title": "ASR model",
                        "type": "string",
                        "description": "Speech-to-text model name (e.g. whisper-1).",
                        "default": "whisper-1"
                    },
                    "asrBaseUrl": {
                        "title": "ASR base URL",
                        "type": "string",
                        "description": "OpenAI-compatible base URL for the transcription endpoint.",
                        "default": "https://api.openai.com/v1"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many videos to scrape in parallel. Higher is faster; residential IPs rotate per request. Recommended 5-10.",
                        "default": 5
                    },
                    "timeout": {
                        "title": "Timeout per video (seconds)",
                        "minimum": 15,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time to wait for each video fetch.",
                        "default": 45
                    },
                    "maxRetries": {
                        "title": "Max retries per video",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Retries for a failed/blocked fetch, each rotating a fresh proxy IP with exponential backoff (gap feature — only 2/12). 0-8.",
                        "default": 2
                    },
                    "useResidentialProxy": {
                        "title": "Allow residential proxy fallback (recommended)",
                        "type": "boolean",
                        "description": "Datacenter proxy is used first (cheap). When a video is blocked on datacenter, the Actor escalates to Apify residential proxy. Disable to stay datacenter-only (cheapest, but a few blocked videos may fail).",
                        "default": true
                    },
                    "proxyCountry": {
                        "title": "Proxy country code (geo-targeting)",
                        "type": "string",
                        "description": "ISO 2-letter country code (e.g. US, GB, DE). Geo-targets both datacenter and residential proxy to get region-specific availability and avoid locale redirects. Empty = automatic.",
                        "default": "US"
                    },
                    "dedupe": {
                        "title": "Deduplicate",
                        "type": "boolean",
                        "description": "Drop duplicate input URLs and duplicate output videos (same video ID), so the same Reel is never scraped or billed twice.",
                        "default": true
                    },
                    "notifyWebhookUrl": {
                        "title": "Real-time webhook URL",
                        "type": "string",
                        "description": "Optional. Each scraped video is POSTed as JSON to this URL the moment it's found (Zapier / Make / n8n / Slack / Discord) — gap feature, only 1/12."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
