# Facebook Comments Scraper (`crawlerbros/facebook-comments-scraper`) Actor

Scrape public comments from Facebook posts, Watch videos, and photo stories. Extract comment text, author info, reactions, timestamps, and nested replies via GraphQL pagination.

- **URL**: https://apify.com/crawlerbros/facebook-comments-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Developer tools, Other
- **Stats:** 140 total users, 38 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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 Comments Scraper

Extract public comments from Facebook posts, Reels, Watch videos, and photo stories. Get comment text, author info, reactions, timestamps, and nested reply threads — no login or cookies required.

### Features

- Scrape comments from any public Facebook post, Watch video, or page video
- Support for group posts, shared posts, and page video URLs
- Three comment sorting modes: All, Newest, or Most Relevant
- Nested reply extraction with full parent/reply threading metadata
- Author details: name, profile picture, profile URL, ID
- Reaction counts and reply counts per comment
- ISO 8601 timestamps
- Anti-blocking: headless Chromium browser, residential proxy support, request delays
- Export to JSON, CSV, Excel, or XML

### Input

| Field                   | Type     | Required | Default     | Description                                                                                                       |
| ----------------------- | -------- | -------- | ----------- | ----------------------------------------------------------------------------------------------------------------- |
| Start URLs              | string[] | Yes      | —           | Facebook post, Reel, Watch, or photo URLs to scrape comments from                                                 |
| Max items per URL       | integer  | No       | 100         | Maximum number of comments to collect per URL                                                                     |
| Comments mode           | string   | No       | ALL         | Sort order: `ALL` (chronological), `NEWEST` (reverse chronological), or `MOST_RELEVANT` (Facebook's ranked order) |
| Include nested comments | boolean  | No       | true        | Also scrape reply threads under top-level comments                                                                |
| Max request retries     | integer  | No       | 3           | Number of retries per failed request                                                                              |
| Proxy Configuration     | object   | No       | Residential | Proxy settings. Residential IPs strongly recommended                                                              |

#### Supported URL Formats

- **Posts**: `https://www.facebook.com/PageName/posts/1234567890`
- **Posts (pfbid)**: `https://www.facebook.com/PageName/posts/pfbid0...`
- **Reels**: `https://www.facebook.com/reel/1234567890` *(requires login — not supported)*
- **Watch videos**: `https://www.facebook.com/watch?v=1234567890`
- **Photos**: `https://www.facebook.com/photo?fbid=1234567890`
- **Photo (legacy)**: `https://www.facebook.com/photo.php?fbid=1234567890`
- **Group posts**: `https://www.facebook.com/groups/groupname/permalink/1234567890/`
- **Page videos**: `https://www.facebook.com/PageName/videos/1234567890`
- **Shared posts**: `https://www.facebook.com/share/p/abc123/`

#### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/NASA/posts/1234567890" },
    { "url": "https://www.facebook.com/reel/9876543210" }
  ],
  "maxItems": 200,
  "commentsMode": "MOST_RELEVANT",
  "includeNestedComments": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Output

Each comment record contains the following fields:

| Field              | Type    | Description                                                      |
| ------------------ | ------- | ---------------------------------------------------------------- |
| `facebookUrl`      | string  | Canonical URL of the post                                        |
| `commentUrl`       | string  | Direct permalink to the comment                                  |
| `commentId`        | string  | Legacy numeric comment ID                                        |
| `id`               | string  | Internal relay ID                                                |
| `feedbackId`       | string  | Feedback ID for the comment                                      |
| `date`             | string  | Comment timestamp (ISO 8601)                                     |
| `text`             | string  | Full comment text                                                |
| `profilePicture`   | string  | Author's profile picture URL                                     |
| `profileId`        | string  | Author's numeric profile ID                                      |
| `profileName`      | string  | Author's display name                                            |
| `profileUrl`       | string  | Author's profile URL                                             |
| `likesCount`       | integer | Number of reactions on the comment                               |
| `threadingDepth`   | integer | 0 = top-level comment, 1+ = reply depth                         |
| `commentsCount`    | integer | Number of replies (0 for replies themselves)                     |
| `facebookId`       | string  | Post/story ID                                                    |
| `inputUrl`         | string  | Original URL provided in input                                   |
| `replyToCommentId` | string  | Parent comment legacy ID (empty string for top-level comments)   |
| `postTitle`        | string  | Post title extracted from page metadata (empty if not available) |

#### Example Output

**Top-level comment:**

```json
{
  "facebookUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...",
  "commentUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...?comment_id=809453025548580",
  "commentId": "809453025548580",
  "id": "Y29tbWVudDoxNDg3...",
  "feedbackId": "ZmVlZGJhY2s6MTQ4...",
  "date": "2026-03-26T23:31:17.000Z",
  "text": "Ah I remember the moon landing of 1969 on the eve of my 9th birthday!",
  "profilePicture": "https://scontent.xx.fbcdn.net/v/...",
  "profileId": "pfbid0248UufsteCx...",
  "profileName": "Gwen Weidell",
  "profileUrl": "https://www.facebook.com/gwen.weidell.9",
  "likesCount": 26,
  "threadingDepth": 0,
  "commentsCount": 2,
  "replyToCommentId": "",
  "facebookId": "1487017912793580",
  "inputUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...",
  "postTitle": "Our Artemis II crew will be the first to fly around the Moon in more than 50 years..."
}
```

**Reply to a comment (threadingDepth 1):**

```json
{
  "facebookUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...",
  "commentUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...?comment_id=810234567890123",
  "commentId": "810234567890123",
  "id": "Y29tbWVudDo4MDk0...",
  "feedbackId": "ZmVlZGJhY2s6ODA5...",
  "date": "2026-03-26T15:10:22.000Z",
  "text": "Totally agree with you!",
  "profilePicture": "https://scontent.xx.fbcdn.net/v/...",
  "profileId": "100012345678901",
  "profileName": "John Doe",
  "profileUrl": "https://www.facebook.com/john.doe",
  "likesCount": 2,
  "threadingDepth": 1,
  "commentsCount": 0,
  "replyToCommentId": "809453025548580",
  "facebookId": "1487017912793580",
  "inputUrl": "https://www.facebook.com/NASA/posts/pfbid025kwyoB...",
  "postTitle": "Our Artemis II crew will be the first to fly around the Moon in more than 50 years..."
}
```

### Use Cases

- **Brand monitoring** — Track what people say about your brand on Facebook posts
- **Market research** — Analyze audience sentiment and topics in post comments
- **Content analysis** — Study engagement patterns across different types of posts
- **Community insights** — Understand audience reactions to news, announcements, or campaigns
- **Competitor analysis** — Monitor comments on competitor pages and posts
- **Lead generation** — Identify engaged users from comment activity

### Tips for Best Results

1. **Use residential proxies** — Facebook blocks datacenter IPs aggressively. Select "Residential" proxy group for best results
2. **Start with fewer URLs** — Test with 1-2 URLs first, then scale up
3. **Public posts only** — The scraper can only access comments on public posts accessible without login
4. **Comment limits** — Set `maxItems` per URL to control costs and runtime. Each URL fetches up to the specified limit

### Limitations

- Only public posts are supported. Private, friends-only, or restricted posts cannot be accessed
- **Reels require Facebook login** — Reels (`/reel/` URLs) are not accessible without a Facebook session. Use post or video URLs instead
- **Video URLs need residential proxy** on Apify — Facebook blocks video pages from datacenter IPs. Standard posts work without proxy
- Facebook may occasionally block requests — use residential proxies and keep concurrency low
- Comment ordering depends on Facebook's API. The `MOST_RELEVANT` mode uses Facebook's own ranking algorithm
- Some older posts may have limited data availability
- Nested reply depth is limited to what Facebook's API returns (typically 1-2 levels)

### FAQ

**Q: Do I need a Facebook account or cookies to use this scraper?**
A: No. The scraper works with public posts and videos without any login or authentication. The only exception is Reels, which Facebook requires login to access.

**Q: Can I scrape comments from Facebook Reels?**
A: No. Facebook Reels require login to view, which this scraper does not support. Use the post URL or video URL format instead.

**Q: Why are some comments missing?**
A: Facebook may restrict access to certain comments based on privacy settings, regional blocking, or content moderation. Only publicly visible comments can be scraped.

**Q: What happens if Facebook blocks my requests?**
A: The scraper includes automatic retry logic and uses a headless Chromium browser to bypass anti-bot protections. Using residential proxies significantly reduces blocking. If you still experience issues, try spacing out your runs.

**Q: Can I scrape comments from private groups?**
A: No. Only public group posts where comments are visible without login can be scraped.

**Q: How does the comment sorting work?**
A: `ALL` returns comments in chronological order (oldest first), `NEWEST` returns newest first, and `MOST_RELEVANT` uses Facebook's ranking algorithm which prioritizes popular and engaging comments.

**Q: What is `threadingDepth`?**
A: It indicates the nesting level. `0` means it's a top-level comment directly on the post. `1` means it's a reply to a top-level comment. Higher values indicate deeper nesting.

**Q: How many comments can I scrape per run?**
A: You can set `maxItems` up to 10,000 per URL. The actual number depends on how many public comments exist on the post.

# Actor input Schema

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

Facebook post, Reel, Watch, or photo URLs to scrape comments from. Supports /posts/, /reel/, /watch?v=, /photo?fbid=, /groups/.../permalink/, and /share/p/ URLs.

## `maxItems` (type: `integer`):

Maximum number of comment rows to collect per start URL (not global across all URLs).

## `commentsMode` (type: `string`):

How comments are sorted: ALL (chronological unfiltered), NEWEST (reverse chronological), or MOST\_RELEVANT (Facebook's ranked ordering).

## `includeNestedComments` (type: `boolean`):

If true, also scrape reply rows under top-level comments (with parentComment/parentReply metadata). If false, only top-level comments are collected (faster).

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

Maximum parallel HTTP requests. Keep low for Facebook (1-3 recommended).

## `minConcurrency` (type: `integer`):

Floor for the autoscaled pool.

## `maxRequestRetries` (type: `integer`):

Retries per failed request before giving up.

## `proxy` (type: `object`):

Residential proxy recommended for reliable results, especially for video URLs. Standard posts may work without proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA/posts/pfbid025kwyoBjhFGUC22fC4Sies56D5xvd65ZHR5PYjHhc7XSzqGsxuWq2uDVriZNxWbeol"
    }
  ],
  "maxItems": 5,
  "commentsMode": "MOST_RELEVANT",
  "includeNestedComments": true,
  "maxConcurrency": 2,
  "minConcurrency": 1,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `comments` (type: `string`):

Dataset containing all scraped Facebook comments

# 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": [
        {
            "url": "https://www.facebook.com/NASA/posts/pfbid025kwyoBjhFGUC22fC4Sies56D5xvd65ZHR5PYjHhc7XSzqGsxuWq2uDVriZNxWbeol"
        }
    ],
    "maxItems": 5,
    "commentsMode": "MOST_RELEVANT",
    "includeNestedComments": true,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/facebook-comments-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": [{ "url": "https://www.facebook.com/NASA/posts/pfbid025kwyoBjhFGUC22fC4Sies56D5xvd65ZHR5PYjHhc7XSzqGsxuWq2uDVriZNxWbeol" }],
    "maxItems": 5,
    "commentsMode": "MOST_RELEVANT",
    "includeNestedComments": True,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/facebook-comments-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": [
    {
      "url": "https://www.facebook.com/NASA/posts/pfbid025kwyoBjhFGUC22fC4Sies56D5xvd65ZHR5PYjHhc7XSzqGsxuWq2uDVriZNxWbeol"
    }
  ],
  "maxItems": 5,
  "commentsMode": "MOST_RELEVANT",
  "includeNestedComments": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/facebook-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments Scraper",
        "description": "Scrape public comments from Facebook posts, Watch videos, and photo stories. Extract comment text, author info, reactions, timestamps, and nested replies via GraphQL pagination.",
        "version": "1.0",
        "x-build-id": "ktWoPVJDbLdajsgdp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-facebook-comments-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/crawlerbros~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-facebook-comments-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/crawlerbros~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-facebook-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Facebook post, Reel, Watch, or photo URLs to scrape comments from. Supports /posts/, /reel/, /watch?v=, /photo?fbid=, /groups/.../permalink/, and /share/p/ URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items per URL",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of comment rows to collect per start URL (not global across all URLs).",
                        "default": 100
                    },
                    "commentsMode": {
                        "title": "Comments mode",
                        "enum": [
                            "ALL",
                            "NEWEST",
                            "MOST_RELEVANT"
                        ],
                        "type": "string",
                        "description": "How comments are sorted: ALL (chronological unfiltered), NEWEST (reverse chronological), or MOST_RELEVANT (Facebook's ranked ordering).",
                        "default": "ALL"
                    },
                    "includeNestedComments": {
                        "title": "Include nested comments",
                        "type": "boolean",
                        "description": "If true, also scrape reply rows under top-level comments (with parentComment/parentReply metadata). If false, only top-level comments are collected (faster).",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum parallel HTTP requests. Keep low for Facebook (1-3 recommended).",
                        "default": 2
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Floor for the autoscaled pool.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retries per failed request before giving up.",
                        "default": 3
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy recommended for reliable results, especially for video URLs. Standard posts may work without proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
