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

Collect comments and replies from public Facebook post links with configurable sorting, reply depth, and date range filters. Returns clean structured JSON with post details, reactions, shares, comments, and nested replies for analytics, monitoring, and research.

- **URL**: https://apify.com/calm\_builder/facebook-comments-scraper.md
- **Developed by:** [Coder](https://apify.com/calm_builder) (community)
- **Categories:** Automation, Social media, Developer tools
- **Stats:** 11 total users, 8 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 each comment scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 comments and replies from public Facebook post links in a clean, structured JSON format.

This Actor is designed for people who want a simple way to collect Facebook post discussions for research, monitoring, analytics, moderation workflows, archiving, or AI-ready datasets. Each output record represents one Facebook post and includes post-level details together with a nested comments tree.

### What This Actor Does

- Collects comments from one or more public Facebook post URLs
- Supports multiple comment sorting modes
- Supports optional date-range filtering
- Optionally collects replies
- Supports reply depth `1` or `2`
- Returns one dataset item per input post
- Produces user-friendly JSON with post details at the top level and nested comments under `comments`

### Best For

- Social listening and brand monitoring
- Competitor research
- Audience research and sentiment review
- Comment moderation pipelines
- Dataset preparation for LLM and NLP workflows
- Archiving public discussions from Facebook posts

### Input

Provide one or more public Facebook post links and choose how much discussion data to collect.

#### Input fields

- `Facebook post links`
  Add one or more public Facebook post URLs.

- `Comments count to fetch`
  Maximum number of top-level comments to collect for each post.

- `Add replies`
  Turn reply collection on or off.

- `Reply depth`
  Choose:
  - `Level 1`
    Collect direct replies to top-level comments.
  - `Level 2`
    Collect direct replies and nested replies one level deeper when available.

- `Replies count each level`
  Maximum number of replies to keep at each reply level.

- `Comments sorting`
  Choose:
  - `All comments`
  - `Most relevant`
  - `Newest`

- `Date range for comments`
  Optional filter for recent comments and replies.
  Accepted styles:
  - `2026-04-01`
  - `1 day`
  - `2 weeks`
  - `3 months`
  - `1 year`

If a date range is provided, the Actor automatically uses `Newest` sorting to make recent-comment filtering work correctly.

### Output

Each dataset item represents one Facebook post.

The output contains:

- top-level post details
- engagement data such as reactions and shares
- top-level attachments when available
- a nested comments tree under `comments.items`

### Output shape

Each result record follows this general structure:

```json
{
  "inputUrl": "https://www.facebook.com/example/posts/...",
  "postUrl": "https://www.facebook.com/example/posts/...",
  "postId": "1599471641539370",
  "authorName": "Example Author",
  "authorId": "100044296486382",
  "authorUrl": "https://www.facebook.com/example",
  "authorType": "User",
  "createdAt": "2026-04-09T16:32:07+00:00",
  "text": "Post text",
  "textFull": "Post text",
  "topLevelAttachments": [],
  "attachmentCount": 0,
  "attachmentsMayBePartial": true,
  "commentCount": 16920,
  "reactionCount": 289870,
  "topReactions": [
    {
      "type": "like",
      "name": "Like",
      "count": 183395
    }
  ],
  "shareCount": 2702,
  "shareCountLabel": "2.7K",
  "sortBy": "all_comments",
  "comments": {
    "items": []
  }
}
````

### Comment fields

Each top-level comment and reply can include:

- `id`
- `url`
- `depth`
- `parentCommentId`
- `createdAt`
- `text`
- `authorName`
- `authorId`
- `authorUrl`
- `authorType`
- `authorProfilePicture`
- `authorVerified`
- `reactionCount`
- `topReactions`
- `replyCount`
- `attachments`
- `replies`

### Example: Top-Level Comments Only

Use this when you want only the main comments and no replies.

#### Suggested input

- `Add replies`: `false`
- `Reply depth`: `Level 1`
- `Comments count to fetch`: `20`

#### Example output shape

```json
{
  "inputUrl": "https://www.facebook.com/Cristiano/posts/pfbid0vfFdv8NWUm6qSmFsJjnL9snyFAPsSPvJzSXLmdHQ3JZgjD3JF6mQTEA2YrEMqh6fl",
  "postUrl": "https://www.facebook.com/Cristiano/posts/pfbid0vfFdv8NWUm6qSmFsJjnL9snyFAPsSPvJzSXLmdHQ3JZgjD3JF6mQTEA2YrEMqh6fl",
  "postId": "1599471641539370",
  "authorName": "Cristiano Ronaldo",
  "commentCount": 16920,
  "reactionCount": 289870,
  "shareCount": 2702,
  "sortBy": "all_comments",
  "comments": {
    "items": [
      {
        "id": "951288517597139",
        "depth": 0,
        "text": "Please give me 1% of your football knowledge...",
        "authorName": "Snr Nelson",
        "replyCount": 9
      }
    ]
  }
}
```

### Example: Level 1 Replies

Use this when you want direct replies to top-level comments.

#### Suggested input

- `Add replies`: `true`
- `Reply depth`: `Level 1`
- `Replies count each level`: `5`

#### Example output shape

```json
{
  "id": "951288517597139",
  "depth": 0,
  "text": "Please give me 1% of your football knowledge...",
  "authorName": "Snr Nelson",
  "replyCount": 9,
  "replies": [
    {
      "id": "1999023817367454",
      "depth": 1,
      "parentCommentId": "951288517597139",
      "text": "Snr Nelson you work harder than he had done",
      "authorName": "Trîplē Hay",
      "replyCount": 0
    }
  ]
}
```

### Example: Level 2 Replies

Use this when you want nested discussion threads reconstructed one level deeper.

#### Suggested input

- `Add replies`: `true`
- `Reply depth`: `Level 2`
- `Replies count each level`: `5`

#### Example output shape

```json
{
  "id": "951288517597139",
  "depth": 0,
  "text": "Please give me 1% of your football knowledge...",
  "replies": [
    {
      "id": "962518329647471",
      "depth": 1,
      "parentCommentId": "951288517597139",
      "text": "yess i agree...",
      "replies": [
        {
          "id": "940132731958438",
          "depth": 2,
          "parentCommentId": "962518329647471",
          "text": "and messi never lost UCL final...",
          "authorName": "Mohale Malatji"
        }
      ]
    }
  ]
}
```

### Sorting Options

The Actor supports:

- `All comments`
  Useful when you want a broader view of available comments.

- `Most relevant`
  Useful when you want the default Facebook-style ranking.

- `Newest`
  Best for recent-comment tracking and date-based filtering.

### Date Range Filtering

Date filtering applies to comments and replies.

Supported examples:

- `2026-04-01`
- `1 day`
- `7 days`
- `2 weeks`
- `3 months`
- `1 year`

When a date range is set:

- sorting is automatically switched to `Newest`
- only comments and replies within the selected range are kept

### Multiple URLs

You can submit multiple Facebook post links in one run.

The Actor returns:

- one dataset item per post URL
- each item with its own post data and nested comments tree

This makes it easy to process batches of posts in a single run while keeping each result clearly separated.

### Attachments

The Actor can return attachment data when available.

#### Post-level attachment fields

- `topLevelAttachments`
- `attachmentCount`
- `attachmentsMayBePartial`

#### Comment/reply attachment fields

- `type`
- `styleType`
- `url`
- `title`
- `label`
- `image`
- `viewerImage`
- `animatedImage`
- `playableUrl`
- `provider`
- `packName`
- `packId`

This can be useful for comments that include stickers, GIF-style assets, images, or other supported attachment types.

### Typical Use Cases

#### Collect only top-level comments

Recommended when:

- you want the fastest output
- replies are not needed
- you are creating simple monitoring dashboards

#### Collect comments with direct replies

Recommended when:

- you want conversation context
- you need direct audience responses
- you want a good balance between depth and speed

#### Collect comments with nested reply threads

Recommended when:

- thread structure matters
- you want to analyze back-and-forth conversations
- you are building richer moderation or analytics workflows

### Notes

- This Actor is intended for public Facebook post links.
- Output shape may vary slightly depending on what is publicly available for a given post.
- Some posts may have no comments, limited replies, or limited attachment data.

### Dataset-Friendly Design

This Actor is designed to be easy to use in downstream systems.

Why the output is useful:

- one clean record per post
- nested reply structure preserved
- user-friendly top-level post fields
- stable comment identifiers and URLs
- reaction summaries ready for analytics

### Example Workflows

- Track comments on campaign posts every day
- Monitor recent replies on breaking-news posts
- Export nested discussions for moderation review
- Feed structured Facebook discussion data into AI pipelines

### Need Consistent Filtering?

For best results:

- use `Newest` when freshness matters
- use a date range when you only need recent activity
- disable replies when you only need top-level discussion
- use `Level 1` replies for lighter runs
- use `Level 2` only when nested thread structure matters

### Legal and Responsible Use

Use this Actor responsibly and make sure your usage complies with the terms and policies that apply to your use case, your jurisdiction, and the target platform.

# Actor input Schema

## `postUrls` (type: `array`):

Add one public Facebook post link per row. You can provide multiple post links in a single run.

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

Maximum number of top-level comments to collect for each provided post link.

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

Collect replies for each selected top-level comment. Turn this off to collect top-level comments only.

## `replyDepth` (type: `string`):

Choose how many reply levels to include. Level 1 is faster. Level 2 may take longer.

## `maxRepliesPerLevel` (type: `integer`):

Maximum number of direct replies to keep at each reply level for every selected thread.

## `commentsSortBy` (type: `string`):

Choose how Facebook comments should be ordered before scraping. If a date range is provided, the Actor automatically uses Newest.

## `commentsDateRange` (type: `string`):

Optional publish-time filter for comments and replies. Use an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. When set, comment sorting is automatically switched to Newest. Leave empty to disable date filtering.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.facebook.com/Cristiano/posts/pfbid02seJDCEPPoHUmcP2XMQL1aKUijVK2WF9gAJGcNHx2GxpkukG4B6BPW7YxCgGoBx66l"
  ],
  "maxComments": 10,
  "includeReplies": false,
  "replyDepth": "1",
  "maxRepliesPerLevel": 2,
  "commentsSortBy": "all_comments",
  "commentsDateRange": ""
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "postUrls": [
        "https://www.facebook.com/Cristiano/posts/pfbid02seJDCEPPoHUmcP2XMQL1aKUijVK2WF9gAJGcNHx2GxpkukG4B6BPW7YxCgGoBx66l"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("calm_builder/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 = { "postUrls": ["https://www.facebook.com/Cristiano/posts/pfbid02seJDCEPPoHUmcP2XMQL1aKUijVK2WF9gAJGcNHx2GxpkukG4B6BPW7YxCgGoBx66l"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments Scraper",
        "description": "Collect comments and replies from public Facebook post links with configurable sorting, reply depth, and date range filters. Returns clean structured JSON with post details, reactions, shares, comments, and nested replies for analytics, monitoring, and research.",
        "version": "0.0",
        "x-build-id": "PWSaEcDzveEurQqji"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/calm_builder~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-calm_builder-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/calm_builder~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-calm_builder-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/calm_builder~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-calm_builder-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": [
                    "postUrls",
                    "maxComments",
                    "includeReplies",
                    "replyDepth",
                    "maxRepliesPerLevel",
                    "commentsSortBy"
                ],
                "properties": {
                    "postUrls": {
                        "title": "Facebook post links",
                        "type": "array",
                        "description": "Add one public Facebook post link per row. You can provide multiple post links in a single run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxComments": {
                        "title": "Comments count to fetch",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to collect for each provided post link.",
                        "default": 10
                    },
                    "includeReplies": {
                        "title": "Add replies",
                        "type": "boolean",
                        "description": "Collect replies for each selected top-level comment. Turn this off to collect top-level comments only.",
                        "default": false
                    },
                    "replyDepth": {
                        "title": "Reply depth",
                        "enum": [
                            "1",
                            "2"
                        ],
                        "type": "string",
                        "description": "Choose how many reply levels to include. Level 1 is faster. Level 2 may take longer.",
                        "default": "1"
                    },
                    "maxRepliesPerLevel": {
                        "title": "Replies count each level",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of direct replies to keep at each reply level for every selected thread.",
                        "default": 2
                    },
                    "commentsSortBy": {
                        "title": "Comments sorting",
                        "enum": [
                            "all_comments",
                            "most_relevant",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Choose how Facebook comments should be ordered before scraping. If a date range is provided, the Actor automatically uses Newest.",
                        "default": "all_comments"
                    },
                    "commentsDateRange": {
                        "title": "Date range for comments",
                        "pattern": "^$|^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional publish-time filter for comments and replies. Use an absolute date (`YYYY-MM-DD`) or a relative value such as `1 day`, `2 weeks`, `3 months`, or `1 year`. When set, comment sorting is automatically switched to Newest. Leave empty to disable date filtering.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
