# Facebook Videos Scraper (`scraperforge/facebook-videos-scraper`) Actor

🎥 Facebook Videos Scraper pulls video URLs, titles, views, reactions, comments, dates, duration, captions & thumbnails from public Pages, Groups and posts. ⚡ Ideal for marketing, content analysis & competitor tracking. 🔎 Fast, reliable, export-ready (CSV/JSON).

- **URL**: https://apify.com/scraperforge/facebook-videos-scraper.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 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 Videos Scraper

Facebook Videos Scraper is an Apify actor that extracts structured metadata from public Facebook videos, Reels, and group/page posts using yt-dlp. It solves the hassle of manual copy-paste by returning clean fields like URL, title, uploader, duration, dimensions, and a full raw metadata blob for analysis and automations. Built for marketers, developers, data analysts, and researchers, this Facebook video scraper scales from one-off lookups to batch runs, powering workflows like a Facebook video URL extractor, Facebook reels scraper, and Facebook video metadata scraper for analytics at scale.

### What data / output can you get?

Below are the exact fields this actor saves to the Dataset. On success, you’ll get core fields plus the full raw metadata from yt-dlp; on failure, you’ll get a row with the error for that URL.

| Data type | Description | Example value |
| --- | --- | --- |
| url | Input video URL processed | https://www.facebook.com/mrbeast/videos/1395487772147320 |
| id | Video identifier extracted by yt-dlp | 1395487772147320 |
| title | Video title | Lamborghini Vs World's Largest Shredder |
| uploader | Channel/page/uploader name | MrBeast |
| duration | Duration in seconds (float) | 79.312 |
| webpage_url | Canonical webpage URL | https://www.facebook.com/mrbeast/videos/1395487772147320 |
| width | Selected/best-detected video width | 1080 |
| height | Selected/best-detected video height | 1350 |
| format | Best combined format string (video+audio or fallback) | 1474688177015818v - 1080x1350 (DASH video)+815764524126361a - audio only (DASH audio) |
| status | Processing status per URL | Success |
| error | Error string for failed rows only | HTTPError: 429 Too Many Requests |
| raw.title | Title from raw metadata | Lamborghini Vs World's Largest Shredder |
| raw.description | Description (when available) | Lamborghini Vs World's Largest Shredder |
| raw.view_count | View count (when available) | 1623084 |
| raw.automatic_captions | Captions map with language and SRT URLs | {"en_US":[{"url":"...srt","name":"English","ext":"srt"}]} |
| raw.thumbnails | Array of thumbnail objects | [{"url":"https://scontent...jpg","id":"0"}] |
| raw.formats | All detected media formats with URLs/bitrates | [{"format_id":"hd","ext":"mp4","url":"https://video...mp4",...}] |
| raw.upload_date | Upload date (YYYYMMDD when available) | 20250925 |

Notes:
- Results are saved live to the Apify Dataset per URL (success or failure). You can export in JSON or CSV directly from the Dataset.
- Bonus/extra outputs live under raw (e.g., full formats list with stream URLs, captions, thumbnails, and other yt-dlp metadata) — useful for Facebook video extractor and Facebook video transcript extractor use cases.

### Key features

- ⚙️ Bold metadata extraction (yt-dlp powered)
  Returns structured fields (url, id, title, uploader, duration, width, height, format) plus a full raw metadata object for deep analysis and downstream processing.

- 🔁 Resilient scraping with retries & backoff
  Built-in MAX_RETRIES with exponential backoff helps you get stable results even when Facebook is flaky or rate limits occur.

- 🛡️ Smart proxy support with fallback
  Use Apify Proxy or custom proxies. On blocks (e.g., 403/429), the actor can auto-switch to Apify residential proxy to improve success rates.

- 📡 Batch runs for scale
  Paste multiple URLs and process them in one run — perfect for a Facebook page video scraper, Facebook group video scraper, or Facebook reels scraper workflow.

- 💾 Live Dataset writes + run summary
  Every URL writes a row to the Dataset immediately. A run-level SUMMARY.json (totals and per-URL status map) is saved to the Key-Value Store.

- 📤 Export-ready (CSV/JSON)
  Download your Dataset as JSON/CSV for reporting, BI, and pipelines. Ideal for marketing analytics, content research, and data engineering.

- 👩‍💻 Developer-friendly raw payload
  The raw object includes formats with media URLs, captions, thumbnails, and more — enabling Facebook video URL extractor flows or “download Facebook videos online” pipelines outside this actor.

- 🧱 Production-ready reliability
  Quiet, headless extraction via yt-dlp with socket timeouts, format selection logic, and clear failure rows. Designed for repeatable runs on Apify infrastructure.

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

1. Sign in to Apify
   Create or log in to your Apify account to run the actor in the cloud.

2. Open the actor
   Find “Facebook Videos Scraper” and click Try for free.

3. Add your input URLs
   In the “Facebook Video URLs” field, paste one or more public Facebook links (Reels, page videos, or group post videos). One URL per line.

4. (Optional) Configure proxy
   In proxyConfiguration, choose Apify Proxy (residential/datacenter) or add your own proxy URLs. Leaving it off uses a direct connection; the actor can auto-switch to residential if blocked.

5. Start the run
   Click Start. The actor will process each URL with retries and, if needed, proxy fallback. You’ll see live status updates like “Processing 1/10: https://...”.

6. Monitor progress
   The actor writes a Dataset row per URL — either a full success item with metadata or a failure row with status and error.

7. Download your results
   Go to the Dataset tab to export JSON or CSV. Check the Key-Value Store for SUMMARY.json with total counts and per-URL statuses.

Pro tip: Use the raw.formats entries (and requested_formats when present) to power downstream Facebook video URL extractor or HD Facebook video downloader workflows outside the actor.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing + competitor tracking | Aggregate titles, durations, dimensions, and raw view counts to compare performance across pages and Reels for campaign insights. |
| Facebook reels metadata scraper | Extract structured Reels fields (title, duration, dimensions, webpage_url) and analyze trends from public Reels at scale. |
| Facebook page video scraper | Crawl lists of page video URLs and export clean CSV/JSON for dashboards and editorial planning. |
| Group video monitoring | Track public group video posts by URL and log success/failure per item for social listening workflows. |
| Facebook video URL extractor | Use raw.formats and requested_formats to surface stream URLs and resolutions for downstream processing/archival tools. |
| Facebook video transcript extractor | Collect caption URLs from raw.automatic_captions (e.g., English SRT) for accessibility or content analysis. |
| Data engineering pipelines | Pipe Dataset exports into ETL jobs for enrichment, ML labeling, or content repurposing automations. |
| Academic/media research | Build longitudinal datasets from public videos (upload dates, view counts in raw, and captions) for research reproducibility. |

### Why choose Facebook Videos Scraper?

Built for precision and reliability, this actor combines yt-dlp extraction with Apify-grade resilience to deliver clean, structured Facebook video data at scale.

- 🎯 Accurate, structured outputs: Returns clear top-level fields and a deep raw payload for advanced analysis.
- 🌍 Public data focus: Designed for publicly accessible videos, Reels, and post URLs — no login parameters required.
- 📈 Scales from single to bulk: Paste many URLs and get live per-URL results in the Dataset.
- 👩‍💻 Developer-ready: Raw metadata includes formats, captions, thumbnails, and more for flexible downstream use.
- 🛡️ Proxy + fallback logic: Optional Apify Proxy and automatic residential fallback on blocks improve success rates.
- 💾 Export-friendly: Download JSON/CSV straight from the Dataset for BI tools and notebooks.
- 🧱 Stable and production-ready: Retries, timeouts, and clear failure rows outperform brittle browser extensions.

In short: a reliable Facebook video crawler alternative to unstable tools — with structured outputs and infrastructure you can trust.

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

Yes — when used responsibly on publicly accessible content. This actor targets public Facebook video pages (including Reels and page/group posts) and returns metadata. It does not log in or access private/behind-login data.

Guidelines:
- Only process publicly available URLs and respect platform terms.
- Avoid private or restricted content and sensitive personal data.
- Comply with applicable data protection laws (e.g., GDPR, CCPA).
- Validate your specific use case with your legal team if unsure.

### Input parameters & output format

Example input
```json
{
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "urls": [
    "https://www.facebook.com/mrbeast/videos/1395487772147320"
  ]
}
````

Parameter details

| Parameter | Type | Required | Description | Default |
| --- | --- | --- | --- | --- |
| urls | array | Yes | Paste Facebook video links — Reels (facebook.com/reel/...), page videos (facebook.com/username/videos/...), or group post videos. One URL per line. All URLs must be publicly accessible. | None |
| proxyConfiguration | object | No | Optional proxy settings. Use Apify Proxy (residential/datacenter) or custom proxy URLs to reduce blocks. If blocked, the actor can auto-switch to residential proxy. | {"useApifyProxy": false} |

Example output (success)

```json
{
  "url": "https://www.facebook.com/mrbeast/videos/1395487772147320",
  "id": "1395487772147320",
  "title": "Lamborghini Vs World's Largest Shredder",
  "uploader": "MrBeast",
  "duration": 79.312,
  "webpage_url": "https://www.facebook.com/mrbeast/videos/1395487772147320",
  "width": 1080,
  "height": 1350,
  "format": "1474688177015818v - 1080x1350 (DASH video)+815764524126361a - audio only (DASH audio)",
  "raw": {
    "title": "Lamborghini Vs World's Largest Shredder",
    "description": "Lamborghini Vs World's Largest Shredder",
    "uploader": "MrBeast",
    "view_count": 1623084,
    "automatic_captions": {
      "en_US": [
        {
          "url": "https://scontent-.../captions.srt",
          "name": "English",
          "ext": "srt"
        }
      ]
    },
    "formats": [
      {
        "format_id": "hd",
        "ext": "mp4",
        "url": "https://video-...mp4"
      }
    ],
    "webpage_url": "https://www.facebook.com/mrbeast/videos/1395487772147320",
    "upload_date": "20250925"
  },
  "status": "Success"
}
```

Example output (failure)

```json
{
  "url": "https://www.facebook.com/some/video/that/does-not-exist",
  "status": "Failed",
  "error": "HTTPError: 404 Not Found"
}
```

Notes:

- Each input URL produces exactly one Dataset item: a Success row with metadata or a Failed row with an error message.
- A run summary is saved to the Key-Value Store as SUMMARY.json with totals and a per-URL status map.
- Some raw.\* fields may be absent depending on the source video; in such cases, they won’t appear in the payload.

### FAQ

#### Do I need to log in or provide cookies to use this Facebook video scraper?

No. The actor processes publicly accessible Facebook videos, Reels, and posts without login parameters. It does not accept cookies and is designed for public pages only.

#### Does this Facebook video extractor download videos?

No. The actor runs yt-dlp with skip\_download to extract metadata only. However, it includes format details and stream URLs in raw.formats/requested\_formats, which you can use in external “download Facebook videos online” workflows.

#### What kinds of data does the Facebook video metadata scraper return?

It returns top-level fields (url, id, title, uploader, duration, webpage\_url, width, height, format, status) and a full raw object with rich metadata like formats, captions, thumbnails, and more (when available).

#### Can I use it as a Facebook reels downloader or Facebook live video downloader?

Not directly. This actor does not download files. It can serve as a Facebook reels scraper and Facebook video URL extractor by providing format URLs in raw.formats, which you can use in separate downloader tools.

#### How does error handling work in bulk runs?

Each URL gets up to 3 attempts with exponential backoff. If all attempts fail, the actor writes a failure row with status "Failed" and an error string. The Key-Value Store includes SUMMARY.json with success/failed counts and a per-URL status map.

#### Is proxy supported to reduce blocks?

Yes. You can enable Apify Proxy or supply custom proxies. On encountering blocks (e.g., 403/429), the actor can automatically switch to Apify residential proxy and retry.

#### How many URLs can I process at once with this Facebook video scraper?

You can paste multiple URLs in one run. The actor processes them sequentially, writing each result live to the Dataset. One URL = one row (success or failure).

#### What export formats are available?

All results are stored in the Apify Dataset, which you can export as JSON or CSV. This makes it easy to feed data into analytics tools, research notebooks, or ETL pipelines.

### Closing CTA / Final thoughts

Facebook Videos Scraper is built for structured, reliable Facebook video data extraction at scale. It delivers clean top-level fields and a rich raw payload for marketers, developers, analysts, and researchers. Configure proxies when needed, run bulk URL lists, and export JSON/CSV for instant insights or pipelines. Developers can leverage raw.formats and captions to power Facebook video URL extractor and transcript workflows. Start extracting smarter with a production-ready Facebook video scraper that’s fast, resilient, and analysis-ready.

# Actor input Schema

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

📎 Paste Facebook video links — Reels (facebook.com/reel/...), page videos (facebook.com/username/videos/...), or group post videos. One URL per line. Supports bulk scraping from pages, groups, and Reels. All URLs must be publicly accessible.

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

🛡️ Optional. Use Apify Proxy (residential/datacenter) or custom proxy URLs to avoid IP blocks and improve success rates. If blocked, the actor auto-switches to residential proxy. Leave disabled for direct connection.

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/reel/2429400350831482"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.facebook.com/reel/2429400350831482"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/facebook-videos-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 = {
    "urls": ["https://www.facebook.com/reel/2429400350831482"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/facebook-videos-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 '{
  "urls": [
    "https://www.facebook.com/reel/2429400350831482"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/facebook-videos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Videos Scraper",
        "description": "🎥 Facebook Videos Scraper pulls video URLs, titles, views, reactions, comments, dates, duration, captions & thumbnails from public Pages, Groups and posts. ⚡ Ideal for marketing, content analysis & competitor tracking. 🔎 Fast, reliable, export-ready (CSV/JSON).",
        "version": "1.0",
        "x-build-id": "ehp0f9lxFzMOoF9iw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~facebook-videos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-facebook-videos-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/scraperforge~facebook-videos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-facebook-videos-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/scraperforge~facebook-videos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-facebook-videos-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Facebook Video URLs",
                        "type": "array",
                        "description": "📎 Paste Facebook video links — Reels (facebook.com/reel/...), page videos (facebook.com/username/videos/...), or group post videos. One URL per line. Supports bulk scraping from pages, groups, and Reels. All URLs must be publicly accessible.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "🛡️ Optional. Use Apify Proxy (residential/datacenter) or custom proxy URLs to avoid IP blocks and improve success rates. If blocked, the actor auto-switches to residential proxy. Leave disabled for direct connection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
