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

💬 Facebook Comments Scraper extracts comments from public Facebook posts, pages & videos—replies, reactions, timestamps, authors—fast and at scale. 🔍 Export CSV/JSON. 📊 Ideal for social listening, sentiment, research, community management & competitor insights. ⚡️

- **URL**: https://apify.com/scrapapi/facebook-comments-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 5 total users, 0 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 Comments Scraper

The Facebook Comments Scraper is a fast, scalable Facebook comment extractor that collects comments and nested replies from public Facebook posts, pages, and videos. It solves the manual effort of digging through threads by letting you scrape Facebook comments with structure and control. Built for marketers, developers, data analysts, and researchers, this Facebook comments scraping tool turns conversations into clean datasets you can analyze, automate, and export at scale.

### What data / output can you get?

Below are the primary fields this Facebook post comments scraper exports to the Apify dataset. Values are pushed per comment (with replies embedded when available).

| Data field | Description | Example value |
| --- | --- | --- |
| url_key | Short identifier derived from the post URL path | "pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl" |
| full_url | Full Facebook post/page/video URL | "https://www.facebook.com/.../posts/pfbid0BbK..." |
| text | Comment text content | "This is incredible news—congrats!" |
| profileName | Comment author’s display name | "Jane Doe" |
| profileId | Comment author’s numeric/opaque ID | "100089123456789" |
| profileUrl | Author profile/page URL (if present) | "https://www.facebook.com/janedoe" |
| profilePicture | Author profile image URL (if present) | "https://scontent.xx.fbcdn.net/v/t39.30808-6/..." |
| date | ISO 8601 timestamp (UTC) | "2026-03-24T15:12:03+00:00" |
| likesCount | Number of reactions to the comment (string) | "12" |
| commentsCount | Number of replies to the comment (integer) | 3 |
| reply | Array of reply objects (same structure as comments) | [ { ...reply fields... } ] |
| commentUrl | Direct link to the comment (if available) | "https://www.facebook.com/.../comment_id=..." |
| id | Comment node ID | "987654321098765" |
| feedbackId | Feedback ID used for GraphQL requests | "ZmVlZGJhY2s..." |
| facebookId | Legacy FBID (if available) | "1234567890123456" |
| threadingDepth | Depth level in the thread | 0 |
| facebookUrl | Source post URL (same as full_url) | "https://www.facebook.com/.../posts/pfbid0BbK..." |
| inputUrl | Normalized input URL captured during processing | "https://www.facebook.com/.../posts/pfbid0BbK..." |
| expansionToken | Token used to fetch replies (if present) | "AQ6...token" |
| pageAdLibrary | Ad Library page metadata (if present) | {"is_business_page_active": true, "id": "123456789"} |
| error | Error message for failed posts (appears only in error items) | "Failed to extract doc_id or feedback_id" |

Notes:
- Each pushed item represents a single comment. When replies are available, they are embedded under the reply array for that comment.
- On errors per post, the actor pushes a single item containing url_key, full_url, error, and comments: [].
- Export your results to CSV, JSON, or Excel directly from the Apify dataset to download Facebook comments.

### Key features

- ⚡ Automatic residential proxy routing  
  Always uses Apify Residential proxies to minimize blocking on Facebook. The optional proxy input is ignored by design for reliability.

- 📦 Bulk URL processing  
  Paste multiple post/page/video URLs and process them in one run with this Facebook comments export tool.

- 🧵 Comments + nested replies  
  Captures top-level comments and reply threads, returning a clean structure ideal to download Facebook comments for analysis.

- 🧭 Sort controls  
  Choose commentsSortOrder from most_relevant, newest, or all to tailor how you extract comments from Facebook posts.

- 🔁 Robust pagination with retries  
  Built-in backoff and batching handle multi-page threads for large volumes, making this a dependable Facebook comments data extractor.

- 💾 Ready-to-analyze output  
  Structured fields include author, timestamps, reactions, reply counts, and more—perfect to export Facebook comments to CSV/JSON/Excel.

- 🔒 Public data focus  
  Targets publicly accessible posts, pages, and videos, making it a safe Facebook comments API alternative without logins or cookies.

- 🧱 Production-ready on Apify  
  Deployed as an Apify actor for operational stability, monitoring, and easy scheduling—ideal to automate Facebook comments extraction.

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

1. Sign in to Apify  
   Create or log in to your Apify account.

2. Open the actor  
   Find “facebook-comments-scraper” in the Apify Console and click Try for free.

3. Add input URLs  
   In startUrls, paste one or more public Facebook post/page/video URLs (one per line).

4. Configure limits  
   - maxComments: Set how many comments to fetch per post.  
   - maxRepliesPerComment: Limit replies per comment (use a higher number to fetch more).  
   - commentsSortOrder: Choose most_relevant, newest, or all.

5. Proxy setting (no action required)  
   The actor always uses residential proxies automatically; proxyConfiguration in the input is ignored.

6. Run the actor  
   Click Start. Watch the run logs for progress (“Collected X comments so far…”).

7. Review results  
   Open the Output tab. You’ll see one row per comment. Replies are embedded under reply.

8. Export  
   Use the dataset’s Export button to download as CSV, JSON, or Excel and feed your analytics or reporting workflow.

Pro Tip: Chain this run in Apify to schedule daily comment captures, or connect the dataset to your BI tool to keep sentiment dashboards fresh.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening & sentiment analysis | Track audience reactions at scale to measure sentiment on public posts and videos using a reliable Facebook comment extractor. |
| Community management & moderation | Surface recent and high-engagement comments first with sort controls to streamline moderation workflows. |
| Competitor content research | Collect comments from competitor posts to understand themes, reactions, and engagement drivers. |
| Campaign performance analysis | Extract comments from Facebook posts tied to campaigns to quantify feedback and reactions over time. |
| Academic & market research | Build clean datasets of public discourse from pages and videos for qualitative and quantitative studies. |
| Automation & enrichment | Use this Facebook comments export tool within Apify workflows to enrich CRMs or tagging pipelines. |

### Why choose Facebook Comments Scraper?

This Facebook comments scraping tool focuses on precision, automation, and reliability for production use.

- 🎯 Accurate, structured data: Clean fields for text, authors, timestamps, reactions, and reply threads.
- 🌍 Public-only scope: Works with publicly accessible posts, pages, and videos—no login or cookies.
- 📈 Scales to large threads: Handles pagination and batching to scrape Facebook comments at volume.
- 🧩 Flexible exports: Export Facebook comments to CSV, JSON, or Excel for analytics and reporting.
- 🛡️ Built-in resilience: Automatic residential proxy routing reduces blocking for consistent runs.
- 🔧 Developer-friendly on Apify: Runs as a managed actor with logs, storage, and scheduling.
- 🚫 More reliable than extensions: Avoids brittle browser add-ons and unstable tools for long-running jobs.

Bottom line: It’s a production-grade Facebook post comments scraper for teams that need repeatable, high-quality extraction.

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

Yes—when done responsibly. This actor collects data from publicly available Facebook posts, pages, and videos.

Guidelines for compliant use:
- Scrape only publicly visible content; do not attempt to access private or gated data.
- Follow Facebook’s Terms of Service and respect platform rate limits.
- Ensure your usage complies with data protection laws (e.g., GDPR, CCPA) as applicable to your use case.
- Use the data ethically and avoid spam or misuse.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
  ],
  "maxComments": 20,
  "maxRepliesPerComment": 2,
  "commentsSortOrder": "all",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter details:

- startUrls (array, required): Paste one or more Facebook post/video URLs to scrape comments from. Default: none.
- maxComments (integer, optional): Maximum comments to fetch per post. Default: 20.
- maxRepliesPerComment (integer, optional): Max replies per comment (use a high number to fetch all). Default: 2.
- commentsSortOrder (string, optional): How to order comments: most\_relevant, newest, or original order. Allowed: "most\_relevant", "newest", "all". Default: "all".
- proxyConfiguration (object, optional): Ignored. Actor always uses residential proxy automatically. Default: none (UI may show a prefill of {"useApifyProxy": false}).

#### Example JSON output

A successful comment item with embedded replies:

```json
{
  "facebookUrl": "https://www.facebook.com/.../posts/pfbid0BbK...",
  "commentUrl": "https://www.facebook.com/.../comment_id=987654321098765",
  "id": "987654321098765",
  "feedbackId": "ZmVlZGJhY2sABCDEF12345",
  "date": "2026-03-24T15:12:03+00:00",
  "text": "This is incredible news—congrats!",
  "profilePicture": "https://scontent.xx.fbcdn.net/v/t39.30808-6/...",
  "profileId": "100089123456789",
  "profileName": "Jane Doe",
  "likesCount": "12",
  "commentsCount": 2,
  "reply": [
    {
      "facebookUrl": "https://www.facebook.com/.../posts/pfbid0BbK...",
      "commentUrl": "https://www.facebook.com/.../comment_id=987654321111111",
      "id": "987654321111111",
      "feedbackId": "ZmVlZGJhY2sREPLYID123",
      "date": "2026-03-24T15:20:10+00:00",
      "text": "Agree 100%!",
      "profilePicture": "https://scontent.xx.fbcdn.net/v/t39.30808-6/...",
      "profileId": "100077777777777",
      "profileName": "John Smith",
      "likesCount": "3",
      "commentsCount": 0,
      "reply": [],
      "threadingDepth": 1,
      "facebookId": "1234567890123457",
      "inputUrl": "https://www.facebook.com/.../posts/pfbid0BbK..."
    }
  ],
  "threadingDepth": 0,
  "facebookId": "1234567890123456",
  "inputUrl": "https://www.facebook.com/.../posts/pfbid0BbK...",
  "expansionToken": "AQ6...token",
  "profileUrl": "https://www.facebook.com/janedoe",
  "pageAdLibrary": {
    "is_business_page_active": true,
    "id": "123456789"
  },
  "url_key": "pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl",
  "full_url": "https://www.facebook.com/.../posts/pfbid0BbK..."
}
```

An error item (pushed if a post cannot be processed):

```json
{
  "url_key": "pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl",
  "full_url": "https://www.facebook.com/.../posts/pfbid0BbK...",
  "error": "Failed to extract doc_id or feedback_id",
  "comments": []
}
```

Notes:

- likesCount is returned as a string in the output.
- Optional fields such as profileUrl, profilePicture, expansionToken, and pageAdLibrary may be missing when not available.

### FAQ

#### Do I need a Facebook login or cookies to run this?

No. The scraper targets publicly available posts, pages, and videos only, and it doesn’t require login or cookies. It’s a safe Facebook comments API alternative for public data.

#### Can I sort comments by relevance or recency?

Yes. Set commentsSortOrder to most\_relevant, newest, or all to control how the tool will scrape Facebook comments and order them.

#### How many comments and replies can I extract?

You control depth and volume via maxComments (per post) and maxRepliesPerComment (per comment). Increase these limits to collect more data, especially for high-engagement posts.

#### What export formats are supported?

You can export Facebook comments to CSV, JSON, or Excel directly from the Apify dataset. This makes it easy to download Facebook comments for analysis.

#### Does it work on Facebook pages and videos?

Yes. It’s designed for public Facebook posts, pages, and videos. It functions as a flexible Facebook post comments scraper and Facebook page comments scraper.

#### How does proxy handling work?

The actor always uses Apify Residential proxies automatically to reduce blocking. The proxyConfiguration input is ignored intentionally for reliability.

#### What fields are included in replies?

Replies include the same structured fields as comments (e.g., text, profileName, date, likesCount) and are nested under the reply array of the parent comment.

#### Is this suitable for automation or pipelines?

Yes. As an Apify actor, it’s production-ready for scheduling and workflows, letting you automate Facebook comments extraction and keep datasets up to date.

### Closing CTA / Final thoughts

Facebook Comments Scraper is built to extract structured comment threads from public Facebook posts, pages, and videos at scale. With automatic residential proxies, sorting controls, and clean exports, it’s ideal for social listening, research, community management, and analytics. Marketers, developers, analysts, and researchers can run bulk jobs, export Facebook comments to CSV/JSON/Excel, and operationalize insights fast. Start extracting smarter conversations from Facebook and turn them into actionable, analysis-ready datasets today.

# Actor input Schema

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

Paste one or more Facebook post/video URLs to scrape comments from.

## `maxComments` (type: `integer`):

Maximum comments to fetch per post.

## `maxRepliesPerComment` (type: `integer`):

Max replies per comment (use a high number to fetch all).

## `commentsSortOrder` (type: `string`):

How to order comments: most\_relevant, newest, or original order.

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

Ignored. Actor always uses residential proxy automatically.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
  ],
  "maxComments": 20,
  "maxRepliesPerComment": 2,
  "commentsSortOrder": "all",
  "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 = {
    "startUrls": [
        "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments Scraper",
        "description": "💬 Facebook Comments Scraper extracts comments from public Facebook posts, pages & videos—replies, reactions, timestamps, authors—fast and at scale. 🔍 Export CSV/JSON. 📊 Ideal for social listening, sentiment, research, community management & competitor insights. ⚡️",
        "version": "0.1",
        "x-build-id": "Hd5eNBbqsbsVl0tnh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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": "🔗 Facebook Post URLs",
                        "type": "array",
                        "description": "Paste one or more Facebook post/video URLs to scrape comments from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxComments": {
                        "title": "💬 Max Comments",
                        "type": "integer",
                        "description": "Maximum comments to fetch per post.",
                        "default": 20
                    },
                    "maxRepliesPerComment": {
                        "title": "↩️ Max Replies Per Comment",
                        "type": "integer",
                        "description": "Max replies per comment (use a high number to fetch all).",
                        "default": 2
                    },
                    "commentsSortOrder": {
                        "title": "📊 Sort Order",
                        "enum": [
                            "most_relevant",
                            "newest",
                            "all"
                        ],
                        "type": "string",
                        "description": "How to order comments: most_relevant, newest, or original order.",
                        "default": "all"
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration (optional)",
                        "type": "object",
                        "description": "Ignored. Actor always uses residential proxy automatically."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
