# Substack Comments Scraper (`automation-lab/substack-comments-scraper`) Actor

Extract public Substack comments and nested replies with author, timestamp, reaction, and thread metadata.

- **URL**: https://apify.com/automation-lab/substack-comments-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Substack Comments Scraper

Extract public Substack comments and nested replies into a clean, analysis-ready dataset. Add one or many post URLs and receive comment text, thread relationships, authors, timestamps, reactions, and direct source links.

Use the results for audience research, creator intelligence, sentiment pipelines, community monitoring, or newsletter feedback analysis—without manually expanding discussion threads.

### What does Substack Comments Scraper do?

The Actor resolves each public Substack post URL to its internal post identifier and reads the public discussion endpoint used by the website.

It saves every publicly available comment and reply as a separate row.

Each row retains its parent comment and depth, so you can reconstruct conversations or analyze top-level feedback separately.

The scraper uses efficient HTTP requests rather than a browser, keeping runs fast and economical.

### Why scrape Substack comments?

Reader discussions contain product requests, objections, questions, recommendations, and language that rarely appears in newsletter analytics.

Use structured comments to:

- 🧭 discover recurring audience needs
- 💬 compare feedback across posts
- 📈 monitor engagement over time
- 🔎 find quotes, questions, and topic ideas
- 🧪 feed sentiment and topic-classification workflows
- 🗂️ archive public discussions for research

### Who is it for?

#### Newsletter operators

Track what readers ask for and which topics create meaningful discussion.

#### Audience-research teams

Combine feedback from multiple posts and classify themes in spreadsheets, notebooks, or BI tools.

#### Creator intelligence vendors

Collect consistent public engagement records across publications for creator and community analysis.

#### Researchers

Preserve public conversation structure, authorship, dates, and reaction metadata in machine-readable form.

#### Developers

Use the API, webhooks, or MCP to make Substack discussion data part of an automated pipeline.

### Key features

- Multiple public post URLs per run
- Top-level comments and nested replies
- Parent IDs and explicit thread depth
- Plain text and structured body JSON
- Author names, handles, profiles, and photos
- Published and edited timestamps
- Reaction totals and emoji breakdowns
- Reply counts and deletion state
- Direct post and comment URLs
- Configurable limits and ordering
- JSON, CSV, Excel, XML, and RSS exports
- HTTP-first extraction with bounded retries

### Input

The input form contains four fields.

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Public Substack post or `/comments` URLs |
| `maxCommentsPerPost` | integer | `100` | Maximum rows saved for each post |
| `includeReplies` | boolean | `true` | Include replies embedded in discussion threads |
| `sort` | string | `best` | Request `best`, `newest`, or `oldest` order |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google" },
    { "url": "https://www.lennysnewsletter.com/p/a-visual-guide-to-getting-out-of" }
  ],
  "maxCommentsPerPost": 200,
  "includeReplies": true,
  "sort": "newest"
}
````

Regular post URLs and URLs ending in `/comments` are both accepted.

### Output data

Every dataset row represents one comment or reply.

| Field | Description |
|---|---|
| `commentId` | Substack comment identifier |
| `parentCommentId` | Parent ID for a reply, otherwise `null` |
| `depth` | Thread depth, starting at `0` |
| `postId` | Internal Substack post identifier |
| `publicationId` | Internal publication identifier |
| `postUrl` | Canonical source post URL |
| `commentUrl` | Direct discussion anchor URL |
| `text` | Plain comment text |
| `bodyJson` | Structured editor document |
| `authorName` | Public display name |
| `authorHandle` | Public handle |
| `authorProfileUrl` | Public Substack profile URL |
| `authorPhotoUrl` | Public profile image URL |
| `publishedAt` | Comment creation timestamp |
| `editedAt` | Last edit timestamp when available |
| `reactionCount` | Total public reactions |
| `reactions` | Counts grouped by reaction symbol |
| `replyCount` | Number of public child replies |
| `deleted` | Whether Substack marks the record deleted |
| `scrapedAt` | Extraction timestamp |

### Example output

```json
{
  "commentId": 123456789,
  "parentCommentId": null,
  "depth": 0,
  "postId": 165204731,
  "publicationId": 10845,
  "text": "This was a useful breakdown.",
  "authorName": "Example Reader",
  "authorHandle": "example-reader",
  "reactionCount": 4,
  "reactions": { "❤": 4 },
  "replyCount": 2,
  "deleted": false,
  "publishedAt": "2026-01-15T10:30:00.000Z"
}
```

### How to scrape Substack comments

1. Open the Actor input page.
2. Paste one or more public Substack post URLs.
3. Choose the maximum comments per post.
4. Keep **Include nested replies** enabled for complete threads.
5. Select the preferred comment order.
6. Click **Start**.
7. Export the resulting dataset in your preferred format.

### How much does it cost to extract Substack comments?

The Actor uses pay-per-event pricing.

A small start fee covers URL resolution and run initialization. Each saved comment or reply is then charged as one result event. Subscription tiers receive decreasing per-result prices.

The pricing table below uses the current per-comment rates. The final charge is the $0.005 start fee plus the number of comments and replies saved multiplied by your tier's item price.

| Apify tier | Price per saved comment or reply | Example calculation for 100 comments |
|---|---:|---|
| Free | $0.000047465 | start fee + 100 item events ≈ 0.97465 cents |
| Bronze | $0.000041274 | start fee + 100 item events ≈ 0.91274 cents |
| Silver | $0.000032194 | start fee + 100 item events ≈ 0.82194 cents |
| Gold | $0.000024764 | start fee + 100 item events ≈ 0.74764 cents |
| Platinum | $0.000016510 | start fee + 100 item events ≈ 0.66510 cents |
| Diamond | $0.000011557 | start fee + 100 item events ≈ 0.61557 cents |

For example, a Bronze run that saves 100 comments costs about **0.91274 cents**: the $0.005 start fee plus 100 item events at the Bronze rate. A 1,000-comment Bronze run costs about 4.63 cents. Limits are maximums, so a post with fewer public comments costs less. Check the Actor pricing tab before running for the authoritative live prices.

### Thread reconstruction

Top-level comments have `parentCommentId: null` and `depth: 0`.

Replies contain the parent comment ID and a depth greater than zero.

To rebuild a tree, group rows by `postId`, index them by `commentId`, and attach each reply to `parentCommentId`.

For flat sentiment analysis, simply treat every row independently.

### Comment ordering

Choose `best` to follow Substack's relevance ordering.

Choose `newest` for monitoring recent reader feedback.

Choose `oldest` for chronological archives.

Ordering is requested from Substack; nested replies retain their thread relationship.

### Tips for reliable runs

- Use canonical public post URLs.
- Start with 20–100 comments per post.
- Split very large URL lists into scheduled batches.
- Keep replies enabled when conversation context matters.
- Deduplicate recurring runs by `commentId`.
- Store `scrapedAt` when comparing snapshots.
- Review logs for posts with restricted discussions.

### Public-data scope and limitations

The Actor only extracts discussions available through public Substack pages and public web responses.

Subscriber-only, private, removed, geographically blocked, or login-restricted discussions may return no records.

Some posts show an engagement count while withholding comments from anonymous visitors. The Actor does not bypass access controls or request user credentials.

Substack can change its web response structure. The scraper uses retries and clear per-post logs, but upstream changes can temporarily affect extraction.

### Integrations

#### Google Sheets

Send finished datasets to a spreadsheet for tagging reader questions, requests, and sentiment.

#### Slack

Use an Actor webhook to notify a channel when a scheduled run finds new comments.

#### Zapier or Make

Trigger downstream CRM, research, or content-planning workflows after each successful run.

#### Data warehouses

Export JSON or CSV to BigQuery, Snowflake, S3, or your internal analytics pipeline.

#### AI analysis

Pass `text`, `reactionCount`, and thread fields to an LLM for topic clustering, summaries, or intent classification.

### Scheduling and monitoring

Create an Apify schedule to run the Actor hourly, daily, or weekly.

For incremental monitoring, retain previous `commentId` values and keep only unseen IDs after each run.

Use the `newest` sort order and a practical per-post limit to minimize repeat processing.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/substack-comments-scraper').call({
  startUrls: [{ url: 'https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google' }],
  maxCommentsPerPost: 100,
  includeReplies: true,
  sort: 'newest'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/substack-comments-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google'}],
    'maxCommentsPerPost': 100,
    'includeReplies': True,
    'sort': 'newest',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~substack-comments-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google"}],"maxCommentsPerPost":100,"includeReplies":true}'
```

### Use with Apify MCP and Claude

The Actor is available through Apify's hosted MCP server at:

```text
https://mcp.apify.com?tools=automation-lab/substack-comments-scraper
```

#### Claude Code MCP setup

Run this command once, then start a new Claude Code session:

```bash
claude mcp add --transport http apify-substack-comments 'https://mcp.apify.com?tools=automation-lab/substack-comments-scraper'
```

#### Claude Desktop, Cursor, and VS Code MCP setup

Add this server to the app's MCP JSON configuration. Claude Desktop uses `claude_desktop_config.json`; Cursor and VS Code accept the same `mcpServers` entry in their MCP settings:

```json
{
  "mcpServers": {
    "apify-substack-comments": {
      "url": "https://mcp.apify.com?tools=automation-lab/substack-comments-scraper"
    }
  }
}
```

Restart the client after saving the configuration. If your client asks for Apify authorization, complete the browser sign-in flow.

Example prompts for this actor:

- “Run the Substack Comments Scraper on `https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google`, return the newest 100 comments, and include nested replies.”
- “Extract public comments from these three Substack post URLs, then summarize recurring product requests and cite each comment URL.”
- “Group the scraped replies by `parentCommentId` and identify top-level questions that have no author response.”
- “Compare `reactionCount` and reply depth across these newsletter discussions and list the most engaged threads.”

### Export formats

The default Apify dataset supports JSON, JSONL, CSV, Excel, XML, HTML, and RSS exports.

Use the overview view for a concise table, or request raw dataset items to retain `bodyJson` and the complete reaction object.

### Data quality notes

Author fields can be absent when an account is removed or a comment is anonymized.

Edited timestamps are optional.

Deleted comments can have empty text.

Reaction symbols vary by publication and over time.

Reply counts can include replies that are no longer publicly accessible.

### Error handling

A failed post is logged with its URL and reason while other input URLs continue processing.

Invalid non-Substack URLs are rejected per item.

HTTP errors are retried a bounded number of times.

The Actor exits cleanly after processing all posts so successful results remain available.

### Legality: is scraping Substack comments legal?

This Actor collects publicly visible information. Laws and contractual obligations vary by jurisdiction and use case.

Only process data you are authorized to collect. Respect privacy rights, intellectual property, Substack's terms, publication rules, and applicable data-protection law.

Avoid using personal data for harassment, discrimination, spam, or other harmful purposes.

### Troubleshooting

#### Why did a post return zero comments?

The discussion may be empty, subscriber-only, removed, or unavailable to anonymous visitors. Open the post in a logged-out browser to verify public access.

#### Why are fewer rows returned than the visible count?

Some visible counts include comments withheld by access rules or removed records. Increase `maxCommentsPerPost` and keep replies enabled, but the Actor only returns publicly accessible rows.

#### Why does a reply have depth greater than one?

Substack supports nested discussion branches. Use `parentCommentId` to locate the immediate parent.

#### How do I avoid duplicates in scheduled runs?

Use `commentId` as the stable deduplication key within your destination system.

### Related Substack actors

- [Substack Scraper](https://apify.com/automation-lab/substack-scraper) — extract posts, content, and broader publication data.
- [Substack People Scraper](https://apify.com/automation-lab/substack-people-scraper) — collect public writer and profile data.
- [Substack Leaderboard Scraper](https://apify.com/automation-lab/substack-leaderboard-scraper) — analyze publication rankings and categories.

Choose this Actor when comments, replies, reactions, and discussion structure are the primary output.

### FAQ

#### Can it scrape any Substack publication?

It supports public posts on `*.substack.com` domains and custom publication domains whose URLs use Substack's `/p/` post structure.

#### Does it require my Substack account?

No. The public scope uses no user credentials.

#### Are nested replies included?

Yes, by default. Disable `includeReplies` when only top-level comments are needed.

#### Can I process multiple posts?

Yes. Add multiple entries to `startUrls`; the per-post limit applies independently.

#### Can I download CSV or Excel?

Yes. Choose CSV or Excel from the dataset export menu after the run.

#### Can I run it on a schedule?

Yes. Use Apify schedules and webhooks for recurring comment monitoring.

#### What identifies a unique comment?

Use `commentId`. Combine it with `postId` if your storage model requires a compound key.

#### Does it scrape private discussions?

No. Private and access-restricted comments are intentionally outside scope.

### Support

If a public post fails unexpectedly, include the post URL, run ID, and relevant log message in your support request. This makes it easier to distinguish an upstream access restriction from a parser change.

# Actor input Schema

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

Public Substack post URLs. Regular post URLs and /comments URLs are supported.

## `maxCommentsPerPost` (type: `integer`):

Maximum comment and reply records saved for each post.

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

Save replies embedded in each public discussion thread.

## `sort` (type: `string`):

Choose the ordering requested from Substack.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google"
    }
  ],
  "maxCommentsPerPost": 20,
  "includeReplies": true,
  "sort": "best"
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.lennysnewsletter.com/p/new-a-free-year-of-cursor-google"
        }
    ],
    "maxCommentsPerPost": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/substack-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.lennysnewsletter.com/p/new-a-free-year-of-cursor-google" }],
    "maxCommentsPerPost": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/substack-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.lennysnewsletter.com/p/new-a-free-year-of-cursor-google"
    }
  ],
  "maxCommentsPerPost": 20
}' |
apify call automation-lab/substack-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Substack Comments Scraper",
        "description": "Extract public Substack comments and nested replies with author, timestamp, reaction, and thread metadata.",
        "version": "0.1",
        "x-build-id": "oAoDxvWBsJU7snczj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~substack-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-substack-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/automation-lab~substack-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-substack-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/automation-lab~substack-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-substack-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": "📝 Substack post URLs",
                        "type": "array",
                        "description": "Public Substack post URLs. Regular post URLs and /comments URLs are supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum comment and reply records saved for each post.",
                        "default": 100
                    },
                    "includeReplies": {
                        "title": "Include nested replies",
                        "type": "boolean",
                        "description": "Save replies embedded in each public discussion thread.",
                        "default": true
                    },
                    "sort": {
                        "title": "Comment order",
                        "enum": [
                            "best",
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Choose the ordering requested from Substack.",
                        "default": "best"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
