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

🔍 Facebook Comments Scraper extracts public comment data fast—capturing text, usernames, timestamps & engagement. Perfect for brand research, sentiment analysis, and market insights. 🚀 Easy to use, reliable results.

- **URL**: https://apify.com/scraperoka/facebook-comments-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.

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 🚀

Manually copying comment threads from Facebook posts is slow, inconsistent, and impossible to scale. **Facebook Comments Scraper** automatically collects comment text, engagement metrics, and timestamps from Facebook post URLs—ideal for marketers, researchers, and growth teams who need comment data in bulk. Use **Facebook Comments Scraper** to scrape Facebook comments, extract Facebook comment text, and build datasets from comment collectors or Facebook comment analytics workflows in a single run, often in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "facebookUrl": "https://www.facebook.com/examplepage/posts/123456789012345",
  "commentUrl": "https://www.facebook.com/examplepage/posts/123456789012345?comment_id=987654321098765",
  "commentId": "987654321098765",
  "id": "1234567890987654321",
  "feedbackId": "ZmVlZGJhY2s6NjM3NTIxOTM0MjU1MjExMg==",
  "date": "2025-06-01T09:14:22.000Z",
  "text": "Really helpful—thanks for sharing! 🙌",
  "profilePicture": "https://example.com/profile.jpg",
  "profileId": "111222333444",
  "profileName": "Jane Doe",
  "likesCount": "12",
  "commentsCount": 3,
  "comments": [],
  "threadingDepth": 0,
  "facebookId": "555666777888",
  "postTitle": "Example post title text",
  "inputUrl": "https://www.facebook.com/examplepage/posts/123456789012345",
  "pageAdLibrary": {
    "is_business_page_active": false,
    "id": "999888777666"
  }
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `facebookUrl` | string | The Facebook post URL the comment belongs to |
| `commentUrl` | string | null | A direct link to the specific comment when available |
| `commentId` | string | null | The comment identifier, useful for deduplication |
| `id` | string | null | The internal relay ID associated with the comment node |
| `feedbackId` | string | null | The feedback identifier used for pagination context |
| `date` | string | null | Timestamp in Zulu/ISO format for when the comment was created |
| `text` | string | null | The actual Facebook comment text (the core field for analytics) |
| `profilePicture` | string | null | Author profile picture URI (helps with enrichment) |
| `profileId` | string | null | Author profile ID for linking back to user records |
| `profileName` | string | null | Display name of the commenter |
| `likesCount` | string | Like/reactor count for engagement scoring (stored as a string) |
| `commentsCount` | number | Reply count shown at the comment level |
| `comments` | array | Nested comments container (empty in the provided extraction structure) |
| `threadingDepth` | number | Threading depth value (0 in this extracted output structure) |
| `facebookId` | string | null | Post-level identifier value (where available) |
| `postTitle` | string | null | The post title text extracted along with the thread |
| `inputUrl` | string | The original URL you provided as the scrape target |
| `pageAdLibrary` | object | null | Page/group context captured alongside comment extraction |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Facebook Comments Scraper?

There are a lot of ways to pull data from Facebook — here’s what sets Facebook Comments Scraper apart.

#### Scrape comments from Facebook posts with structured output

Facebook Comments Scraper returns clean, integration-ready JSON objects with comment text, author details, timestamps, and engagement fields. If you’re building a Facebook post comments scraper pipeline, you’ll get consistent records ready for analysis or storage.

#### Flexible ranking modes for different analysis needs

Choose how comments are ordered using the built-in `commentsMode` setting. Whether you need the full set (`All`) or a focus on a specific view, Facebook comments mining tool workflows stay straightforward.

#### Resilient pagination and batch collection

The actor continues collecting comments across multiple pages until your limits are met. It also uses resilience patterns for request handling so you can run larger comment scraping software jobs with fewer interruptions.

#### Supports scaling with built-in proxy configuration

When reliability matters (for large batches or repeated runs), Facebook Comments Scraper supports proxy configuration to help you keep scraping stable.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    },
    {
      "url": "https://www.facebook.com/examplepage/posts/123456789012345"
    }
  ],
  "resultsAmount": 50,
  "includeReplies": false,
  "commentsMode": "All",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `startUrls` | ✅ | List of Facebook post URLs to scrape (each item can be an object with `url`) |
| `resultsAmount` | ⬜ | Maximum comments to scrape per URL |
| `includeReplies` | ⬜ | If enabled, replies to comments will also be scraped |
| `commentsMode` | ⬜ | Ranking mode for comments: `Most relevant`, `Newest`, or `All` |
| `proxyConfiguration` | ⬜ | Proxy settings for the run (optional, defaults to enabled Apify Proxy behavior if you don’t override it) |
| `↳ proxy support` | ⬜ | Whether to route requests through Apify Proxy |
| `↳ proxy support` | ⬜ | Proxy group(s) to use when proxying is enabled |

***

### Core Capabilities

#### Comment text extraction for Facebook comment analytics

Facebook Comments Scraper extracts the comment `text` field along with author metadata and timestamps. This makes it a practical Facebook comment extractor for sentiment analysis, thematic categorization, and engagement reporting.

#### Track engagement: likes and reply counts

Each record includes `likesCount` and `commentsCount` (reply count at the comment level). With this, your Facebook comments API scraper output can support ranking, quality scoring, and workload estimation.

#### Clean author identity fields

You get `profileName`, `profileId`, and `profilePicture` (when available), so you can connect comment authors to other datasets. This is especially useful for Facebook comments download tool workflows where you enrich and deduplicate across runs.

#### Ordering control with commentsMode

Set `commentsMode` to choose the ranking behavior for comments as they’re collected. This supports both broad scraping and more targeted Facebook comments mining tool use cases.

#### Captures post context alongside comments

Output records include fields like `facebookUrl`, `inputUrl`, and `postTitle` when available. That context makes scrape Facebook comments outputs easier to interpret and join back to campaigns.

***

### Who Gets the Most Out of This

Here's how different teams put Facebook Comments Scraper to work:

**Social media marketers** — Use it as a tool to scrape Facebook comments from top-performing posts, then analyze what resonates by pulling comment text and engagement into your reporting dataset.

**Community managers** — Build a comment collector dataset to review recurring questions, objections, and feedback themes across posts without manually copying threads.

**Lead generation researchers** — Pair scraped comment insights with your existing outreach criteria, using author identity fields and timestamps to time engagement follow-ups based on activity patterns.

**Data analysts and growth researchers** — Use the structured output fields (likes, reply counts, dates, and comment text) to run trend analysis, moderation prioritization, and content performance scoring.

**Automation engineers** — Integrate the Facebook post comments scraper output into pipelines for scheduled runs, enrichment, and downstream systems using the Apify dataset as the source of truth.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Facebook Comments Scraper from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open Facebook Comments Scraper.
2. **Enter your inputs** — add your Facebook post URLs in `startUrls`, and optionally set `resultsAmount`, `includeReplies`, and `commentsMode`.
3. **Configure proxy settings** — if you expect heavy volume or want extra reliability, enable the actor’s proxy configuration option in the UI.
4. **Hit Run and watch the live log** — monitor progress as comments are collected across your provided URLs.
5. **View results in the dataset tab** — each collected comment record is stored in the Apify dataset as structured JSON.
6. **Export as JSON, CSV, or Excel** — download directly from the dataset tab for use in your dashboards, CRM imports, or analysis tools.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Facebook Comments Scraper plugs directly into your existing workflow.

You can export results in the Apify dashboard from the dataset tab as JSON, CSV, or Excel. If you use tools like Sheets or Airtable, export and import is the simplest route, while no-code options can also automate movement of scraped comments into your systems.

For programmatic usage, you can access the output via the Apify API (see [apify.com/docs/api](https://apify.com/docs/api)). You can also use webhooks and connect workflows with Zapier or Make to push results to your CRM, Slack, or other downstream tools.

***

### Pricing & Free Trial

Facebook Comments Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free allowance for several test runs and validate that your comment scraping results match your needs.

When you scale up, Apify pricing is based on compute usage, and you typically pay for platform compute rather than a per-row fee. For exact current costs and plan details, check the pricing page on [apify.com](https://apify.com).

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Request resilience | Uses retries and fallback handling to reduce run failures |
| Stable comment collection | Continues collecting across pagination until your `resultsAmount` limit is reached |
| Proxy support | Optional proxy configuration helps improve reliability for sustained scraping |
| Output consistency | Each run writes structured comment records to the Apify dataset |
| Error tolerance | Runs are designed to avoid total failure when individual requests encounter issues |

**Limitations:** Facebook Comments Scraper works with publicly accessible content available for scraping. If the page content limits access or is not available in the expected public view, fewer records may be returned. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Facebook Comments Scraper?

Apify provides a free tier for actors, which is a good way to validate Facebook comments scraping output before scaling. Availability and included credits depend on your Apify account and current platform rules.

#### Do I need to log in to Facebook to use this?

No. Facebook Comments Scraper is designed to work with publicly accessible Facebook post pages using the URLs you provide in `startUrls`.

#### How accurate is the data from Facebook Comments Scraper?

Accuracy depends on what is available in the public post comments for the URLs you provide. The actor extracts comment text and associated metadata that are present in the publicly available content.

#### How many results can I get per run?

You control volume with `resultsAmount`, which sets the maximum comments to scrape per URL. If you add multiple URLs in `startUrls`, the actor processes each and caps comments per target.

#### How often is the data updated / how fresh is it?

Data freshness is based on when you run the actor. For the most up-to-date comments, run Facebook Comments Scraper again on your desired schedule.

#### Is this legal? Does it comply with GDPR / CCPA?

This actor extracts **publicly available data** from Facebook posts that are accessible without login. Compliance with GDPR, CCPA, and any applicable platform rules is ultimately your responsibility when storing or processing comment data.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the dataset directly from the Apify dashboard as JSON, CSV, or Excel. From there, you can import into Google Sheets or any other spreadsheet/BI tool that accepts CSV or Excel.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actor runs using Apify’s scheduling capabilities, so Facebook comments scraper jobs run automatically at the cadence you choose.

#### Can I access this via API?

Yes. You can use the Apify API to trigger runs and fetch dataset results programmatically. See [apify.com/docs/api](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

The actor is designed to be resilient and continues collecting where possible. Some errors may be handled gracefully so the overall run can still complete and store whatever results were captured.

***

### Need Help or Have a Request?

Got a question about Facebook Comments Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests and feedback, and we actively maintain this actor to improve Facebook comment scraping reliability.

If you want enhancements like additional dataset fields or different export-ready formatting, email us with your use case.

***

### Disclaimer & Responsible Use

*Facebook Comments Scraper is the fastest, most reliable way to scrape and structure Facebook comment text at scale — start your free run today.*

This actor collects **publicly available data** from Facebook post pages. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, and any applicable platform rules when you store, process, or reuse scraped data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of Facebook post URLs to scrape.

## `resultsAmount` (type: `integer`):

Maximum comments to scrape per URL.

## `includeReplies` (type: `boolean`):

If enabled, replies to comments will also be scraped.

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

Ranking mode for comments.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    }
  ],
  "resultsAmount": 50,
  "includeReplies": false,
  "commentsMode": "All"
}
```

# 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/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/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/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/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/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    }
  ]
}' |
apify call scraperoka/facebook-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 public comment data fast—capturing text, usernames, timestamps & engagement. Perfect for brand research, sentiment analysis, and market insights. 🚀 Easy to use, reliable results.",
        "version": "0.1",
        "x-build-id": "KnmV6k3nsrNrtoebc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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 URLs",
                        "type": "array",
                        "description": "List of Facebook post URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "resultsAmount": {
                        "title": "Results amount",
                        "type": "integer",
                        "description": "Maximum comments to scrape per URL.",
                        "default": 50
                    },
                    "includeReplies": {
                        "title": "Include comment replies",
                        "type": "boolean",
                        "description": "If enabled, replies to comments will also be scraped.",
                        "default": false
                    },
                    "commentsMode": {
                        "title": "Comments mode",
                        "enum": [
                            "Most relevant",
                            "Newest",
                            "All"
                        ],
                        "type": "string",
                        "description": "Ranking mode for comments.",
                        "default": "All"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
