# Facebook Reels Downloader & Video Metadata Extractor (`scrapepilot/facebook-reels-downloader-video-metadata-extractor`) Actor

Download Facebook Reels and videos in bulk. Extract direct MP4 URLs, view counts, like counts, uploader name, thumbnail, duration, and full Facebook video metadata — no login, no cookies needed. Residential proxy ready. $7 per 1,000 videos.

- **URL**: https://apify.com/scrapepilot/facebook-reels-downloader-video-metadata-extractor.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.50 / 1,000 facebook 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 Downloader & Video Metadata Extractor

> **The most reliable Facebook Reels Downloader on Apify.** Extract direct MP4 download URLs, titles, descriptions, view counts, like counts, uploader details, thumbnails, and full Facebook video metadata from any public Facebook video or Reels URL — in bulk. No login. No cookies. Residential proxy ready. Instant structured output.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Facebook Reels Downloader?](#why-use-this-facebook-reels-downloader)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Facebook Reels Downloader & Video Metadata Extractor** is a production-ready Apify actor that pulls direct MP4 download URLs and complete Facebook video metadata from any public Facebook video or Reels link — in bulk.

Provide one or many Facebook video URLs and receive back a clean, structured record for each one: title, direct download URL, thumbnail, duration, description, uploader name, view count, like count, and timestamp — all without logging in, without cookies, and without any manual steps.

Whether you need to **download Facebook Reels** for archiving, collect **Facebook video metadata** for research, or build a content pipeline — this actor delivers ready-to-use data instantly.

---

### 🚀 Why Use This Facebook Reels Downloader?

| Feature | This Actor | Manual Download | Browser Extensions | Facebook API |
|---|---|---|---|---|
| **Facebook Reels downloader — bulk** | ✅ 1000/run | ❌ One-by-one | ❌ One-by-one | ❌ Restricted |
| **Direct MP4 download URL** | ✅ Best quality | ✅ | ✅ | ❌ |
| **Facebook video metadata** | ✅ Full set | ❌ | ❌ | ⚠️ Limited |
| **View count & like count** | ✅ | ❌ | ❌ | ⚠️ |
| **Uploader name & thumbnail** | ✅ | ❌ | ❌ | ⚠️ |
| **No login or cookies** | ✅ | ✅ | ✅ | ❌ OAuth |
| **Residential proxy support** | ✅ Built-in | ❌ | ❌ | ❌ |
| **Structured JSON output** | ✅ | ❌ | ❌ | ⚠️ |
| **Export to CSV / Excel** | ✅ Via Apify | ❌ | ❌ | ❌ |

> **Bottom line:** This **Facebook Reels Downloader** is the only actor that combines bulk MP4 extraction with complete **Facebook video metadata** — title, views, likes, uploader, thumbnail, and duration — in a single structured run with no login required.

---

### 🎯 Use Cases

#### 📥 Facebook Reels Archiving & Backup
- Download Facebook Reels and videos in bulk before they are deleted or accounts go private
- Archive brand campaigns, influencer content, and viral Reels with timestamps and engagement data
- Preserve public interest Facebook videos as evidence or historical records

#### 📊 Facebook Video Metadata Research & Analytics
- Collect Facebook video metadata — view counts, like counts, descriptions — for social media research
- Benchmark engagement rates across Facebook video content in a specific niche or industry
- Monitor competitor Facebook video performance by tracking view and like counts over time

#### 🤖 AI & Machine Learning Datasets
- Build Facebook video datasets by extracting download URLs in bulk for computer vision or video AI models
- Collect titles and descriptions from Facebook Reels for NLP, sentiment analysis, or content classification
- Scrape Facebook video metadata at scale for training recommendation or content moderation models

#### 🛠️ Developer & Content Pipeline Integrations
- Build a Facebook Reels downloader pipeline that resolves MP4 URLs on demand for your application
- Automate video content ingestion workflows from Facebook into your CMS or media platform
- Integrate Facebook video metadata into dashboards, monitoring tools, or analytics systems

#### 📰 Journalism & Evidence Preservation
- Download Facebook videos and Reels as evidence for investigative reporting
- Preserve public statements, live stream recordings, and event footage from Facebook
- Archive content that may be removed after publication of a story

#### 🎓 Academic & Media Research
- Collect Facebook video metadata for studies on social media content virality and engagement
- Build datasets of Facebook Reels for research on short-form video trends
- Study uploader patterns, posting frequency, and engagement across public Facebook pages

---

### ⚙️ Input Parameters

```json
{
  "urls": [
    "https://www.facebook.com/reel/1234567890",
    "https://www.facebook.com/watch/?v=9876543210"
  ],
  "url": "",
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `urls` | array or string | `[]` | Facebook video or Reels URLs to process — newline-separated string also accepted |
| `url` | string | `""` | Single URL shortcut — automatically merged with `urls` list |
| `proxyConfiguration` | object | Residential | Apify proxy config — residential proxy is recommended for reliable Facebook extraction |

> **Tip:** Both `url` (singular) and `urls` (plural) are accepted. Mix Facebook Reels, watch links, and page video URLs freely in the same run.

***

### 📋 Output Fields

Every record from this **Facebook Reels Downloader** includes complete **Facebook video metadata**:

| Field | Type | Description | Example |
|---|---|---|---|
| `title` | string | Video or Reel title | `"Check out this amazing sunset 🌅"` |
| `id` | string | Facebook internal video ID | `"1234567890"` |
| `source` | string | Platform identifier | `"Facebook"` |
| `url` | string | Original input URL | `"https://www.facebook.com/reel/..."` |
| `download_url` | string | Direct MP4 download URL (best quality) | `"https://video.fbcdn.net/..."` |
| `thumbnail` | string | Video thumbnail image URL | `"https://scontent.fbcdn.net/..."` |
| `duration` | string | Human-readable duration | `"01:24"` |
| `duration_raw` | integer | Duration in seconds | `84` |
| `description` | string | Full post caption or video description | `"Best travel moment from our trip..."` |
| `uploader` | string | Facebook page or profile name | `"National Geographic"` |
| `view_count` | integer | Total video views | `2400000` |
| `like_count` | integer | Total likes / reactions | `85000` |
| `timestamp` | integer | Unix timestamp of the post | `1710504600` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "url": "https://www.facebook.com/reel/1234567890",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Output:**

```json
{
  "title":        "Golden hour at the Grand Canyon 🌄",
  "id":           "1234567890",
  "source":       "Facebook",
  "url":          "https://www.facebook.com/reel/1234567890",
  "download_url": "https://video.fbcdn.net/v/t42.1790-2/abc123.mp4?...",
  "thumbnail":    "https://scontent.fbcdn.net/.../thumb.jpg",
  "duration":     "00:47",
  "duration_raw": 47,
  "description":  "Nothing beats golden hour at one of the world's greatest wonders. Shot on our Southwest road trip.",
  "uploader":     "National Geographic",
  "view_count":   2400000,
  "like_count":   85000,
  "timestamp":    1710504600
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Pay-per-use** | $7.00 per 1,000 videos | All fields, bulk processing, residential proxy |

#### Everything included:

- ✅ Direct MP4 download URL (best available quality)
- ✅ Complete Facebook video metadata — title, views, likes, uploader, thumbnail, duration
- ✅ Bulk processing — up to 1,000 URLs per run
- ✅ Residential proxy support for reliable extraction
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Real-time results as each video is processed

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Count | Estimated Time |
|---|---|---|
| Single Facebook Reel | 1 | ~10–20 seconds |
| Batch of Reels | 10 | ~2–4 minutes |
| Bulk run | 100 | ~20–35 minutes |
| Maximum per run | 1,000 | ~3–4 hours |

- Results are pushed to the Apify dataset in real time as each video is processed
- Per-URL error isolation — one failed URL never stops the rest of the batch
- Failed URLs are logged with the error message; all other URLs continue processing
- Residential proxy recommended for consistent results at higher volumes

***

### ❓ FAQ

**Q: Does this actor download the actual video file to Apify's servers?**
A: No. The actor extracts and returns the **direct signed MP4 URL** hosted on Facebook's CDN. The video file is never stored on Apify — you use `download_url` to download the video to your own system.

**Q: How long is the `download_url` valid?**
A: Facebook CDN URLs are signed and typically expire within a few hours. Use them immediately after the run, or re-run the actor to generate a fresh URL.

**Q: Can I download Facebook Reels from private profiles?**
A: No. This **Facebook Reels Downloader** only works with publicly accessible videos and Reels. Private profiles and login-gated content are not supported.

**Q: Why are `view_count` or `like_count` null for some videos?**
A: Facebook does not always expose engagement metrics publicly for every video type. The field returns `null` when the data is unavailable from the public page.

**Q: What is the maximum number of URLs I can process in one run?**
A: Up to 1,000 URLs per run. For larger batches, split across multiple runs or use Apify's scheduling to run them sequentially.

**Q: Why is residential proxy recommended?**
A: Facebook actively restricts access from datacenter IP addresses. A residential proxy makes requests appear to come from a regular home internet connection, which significantly improves extraction reliability — especially at higher volumes.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after the run completes.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Direct MP4 download URL extraction (best quality combined stream)
- ✅ Full Facebook video metadata: title, views, likes, uploader, thumbnail, duration, timestamp
- ✅ Bulk URL processing — up to 1,000 URLs per run
- ✅ Single `url` and batch `urls` input support
- ✅ Residential proxy support for reliable access
- ✅ Per-URL error isolation — one failure never stops the batch
- ✅ Real-time dataset push as each video is processed

***

### ⚖️ Legal & Terms of Use

This actor extracts publicly accessible Facebook video metadata and CDN stream URLs in the same way a regular user views video content through a browser.

**Please note:**

- Use this tool only for **personal backup, research, archiving, journalism, and education**
- Only download content that you have the right to access and store
- Redistributing copyrighted Facebook video content without authorization may violate copyright law and Facebook's Terms of Service
- Do not use this tool to scrape personal data, target private individuals, or facilitate harassment
- The actor developer is not responsible for how users choose to use the extracted content or metadata

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most reliable Facebook Reels Downloader — bulk MP4 extraction, full video metadata, no login required</em><br/><br/>
  <strong>💰 $7 per 1,000 videos ·/strong>
</p>

# Actor input Schema

## `url` (type: `string`):

Enter a single FB link.

## `urls` (type: `string`):

Enter multiple links to process at once.

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

Residential Proxy is strictly recommended to avoid blocks.

## Actor input object example

```json
{
  "url": "https://www.facebook.com/watch/?v=123456789",
  "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 = {
    "url": "https://www.facebook.com/watch/?v=123456789",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/facebook-reels-downloader-video-metadata-extractor").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 = {
    "url": "https://www.facebook.com/watch/?v=123456789",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/facebook-reels-downloader-video-metadata-extractor").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 '{
  "url": "https://www.facebook.com/watch/?v=123456789",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/facebook-reels-downloader-video-metadata-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reels Downloader & Video Metadata Extractor",
        "description": "Download Facebook Reels and videos in bulk. Extract direct MP4 URLs, view counts, like counts, uploader name, thumbnail, duration, and full Facebook video metadata — no login, no cookies needed. Residential proxy ready. $7 per 1,000 videos.",
        "version": "0.0",
        "x-build-id": "mFkkLIlR2bQbfwo11"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~facebook-reels-downloader-video-metadata-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-facebook-reels-downloader-video-metadata-extractor",
                "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/scrapepilot~facebook-reels-downloader-video-metadata-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-facebook-reels-downloader-video-metadata-extractor",
                "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/scrapepilot~facebook-reels-downloader-video-metadata-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-facebook-reels-downloader-video-metadata-extractor",
                "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": {
                    "url": {
                        "title": "Facebook Video/Reel URL",
                        "type": "string",
                        "description": "Enter a single FB link."
                    },
                    "urls": {
                        "title": "Bulk URLs (One per line)",
                        "type": "string",
                        "description": "Enter multiple links to process at once."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Residential Proxy is strictly recommended to avoid 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
