# 📌 Pinterest Comment Scraper (`scrapier/pinterest-comment-scraper`) Actor

🚀 Extract comments, likes & user data from Pinterest pins at scale. Supports bulk URLs, 22 regions 🌍, smart proxy fallback (no proxy → datacenter → residential), live saving & retry logic. Perfect for social listening, content analysis & competitor research.

- **URL**: https://apify.com/scrapier/pinterest-comment-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 84.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 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

### 📌 Pinterest Comment Scraper

The 📌 Pinterest Comment Scraper is a production-ready Apify actor that extracts comments, likes, and user data from Pinterest pins at scale. It solves the challenge of collecting rich comment threads reliably by using smart proxy fallback, live dataset saving, and robust retry logic. Designed for marketers, developers, data analysts, and researchers, this Pinterest comment extractor helps you scrape Pinterest comments from bulk pin URLs, acting as a Pinterest comments API alternative for scalable workflows. Run it across regions/domains to power social listening, content analysis, and competitor research at scale.

### What data / output can you get?

Below are real output fields pushed to the Apify dataset for each item. Values reflect the actual JSON structure produced by the actor.

| Data field | Description | Example value |
| --- | --- | --- |
| pinUrl | Full URL of the pin | https://jp.pinterest.com/pin/636977941054343221/ |
| id | Comment/item ID | 5367431284645738902 |
| type | Item type: aggregatedcomment, userdiditdata, or comment | aggregatedcomment |
| details | Comment text | ¡Me encanta! ❤l |
| node_id | Pinterest node ID for the item | QWdncmVnYXRlZENvbW1lbnQ6NTM2NzQzMTI4NDY0NTczODkwMg== |
| user | User object with profile details | {"username":"angelicachel7","full_name":"Angélica Chel", ...} |
| like_count | Number of likes | 0 |
| helpful_count | Number of helpful votes | 0 |
| liked_by_me | Whether the current client liked the item | false |
| marked_helpful_by_me | Whether the current client marked the item helpful | false |
| comment_count | Nested comment count (if available) | 0 |
| image_signatures | Signatures used to construct image URLs | [] |
| images | Image objects with originals, 550x, 150x150 | [] |
| videos | Video metadata (if present) | [] |
| tags | Additional tags (if present) | [] |
| done_at | Timestamp for the item | Sun, 02 Jun 2024 22:03:45 +0000 |

Notes:
- Each image (when present) includes three sizes: originals, 550x, 150x150 with url, width, height. If the API omits images, the scraper reconstructs them from image_signatures when possible.
- Export your dataset to JSON or CSV directly from the Apify console.

### Key features

- 🚀 Bulk scraping at scale  
  Process multiple pins in a single run by passing a list of Pinterest pin URLs or numeric IDs. Ideal for a Pinterest pin comments scraper workflow.

- 🛡️ Smart proxy fallback  
  Starts with direct requests for speed. On persistent blocks, it automatically switches to datacenter, then residential proxies, with additional retries on residential.

- ♻️ Robust retry & anti-blocking  
  Up to 3 retries per request with exponential backoff and a random 1–2 second delay between requests to reduce rate limiting.

- 💾 Live saving to dataset  
  Results are pushed in real time via Actor.push_data(), preserving partial data even if the run stops unexpectedly.

- 🧱 Structured, developer-friendly output  
  Consistent JSON with user objects, reaction counts, images array (normalized sizes), and metadata—great for pipelines and analysis.

- 🌍 Regional domain support  
  Scrape across 22 regions by setting the domain (e.g., www.pinterest.com, jp.pinterest.com), making it a versatile Pinterest scraping tool for comments.

- 🔌 Apify-native reliability  
  Built with the Apify SDK + httpx for stability and performance; production-ready infrastructure for automated runs and exports.

### How to use 📌 Pinterest Comment Scraper - step by step

1. Create or log in to your Apify account at https://console.apify.com.
2. Go to Actors and open “📌 Pinterest Comment Scraper” (pinterest-comment-scraper by scrapier).
3. Add input data: paste pin URLs or numeric IDs into urls (request list format supports objects like {"url": "https://www.pinterest.com/pin/123456/"}).
4. Choose your region/domain: set domain (default: www.pinterest.com). For example, jp.pinterest.com for Japan.
5. Set the comment limit per pin: adjust limit (default: 10). Omit it to collect all available items.
6. (Optional) Configure proxy: proxyConfiguration defaults to no proxy; the actor auto-fallbacks to datacenter → residential if persistent blocks occur.
7. Start the run: click Start and monitor logs. You’ll see live entries for each collected item, including user and snippet text.
8. Download results: open the OUTPUT tab to export data as JSON or CSV.

Pro Tip: Feed bulk pins to power a Pinterest comments downloader workflow. Use Apify’s dataset API to pull results into Python notebooks, BI tools, or data pipelines for Pinterest comments export CSV tasks.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening for marketers | Aggregate and analyze comments to track sentiment and themes across campaigns. |
| Content analysis for creators | Measure engagement, helpful votes, and feedback on pins to guide content strategy. |
| Competitor research | Monitor comment threads on competitor pins to uncover audience interests and reactions. |
| Community insights | Map user interactions across many pins to identify advocates and engagement patterns. |
| Academic & research studies | Collect structured comment datasets for sentiment analysis, topic modeling, or trend mining. |
| ETL & data pipelines | Automate Pinterest comment mining tool workflows for enrichment and analytics in your data stack. |

### Why choose 📌 Pinterest Comment Scraper?

This scraper is built for precision, automation, and reliability—outperforming manual copy-paste and fragile browser extensions.

- ✅ Accurate, structured data: Normalized images, consistent user objects, and reaction counts for downstream analytics.
- 🌍 Multi-region domain support: Target 22 Pinterest domains for localized datasets.
- 📦 Batch at scale: Scrape multiple pins in one run for high-throughput projects.
- 💻 Developer-ready: Clean JSON output pushed live via Actor.push_data(), perfect for programmatic pipelines.
- 🛡️ Resilient by design: Smart proxy fallback and controlled pacing reduce blocks and keep data flowing.
- ❌ No browser extension required: A stable Pinterest comments API alternative without a Pinterest comment scraper Chrome extension.
- 💰 Cost-effective workflow: Start fast with direct requests and escalate to proxies only when needed.

In short, it’s a scalable Pinterest data scraper for comments that combines reliability, structured output, and automation-friendly design.

### Is it legal / ethical to use 📌 Pinterest Comment Scraper?

Yes—when used responsibly. This actor collects data from publicly available Pinterest pin pages only and does not access private profiles or password-protected content.

Guidelines for compliant use:
- Scrape only public data you’re permitted to process.
- Respect platform terms and applicable laws (e.g., GDPR, CCPA).
- Avoid spammy or abusive usage of extracted data.
- Consult your legal team for edge cases or regulated use.

### Input parameters & output format

#### Example input
```json
{
  "urls": [
    { "url": "https://www.pinterest.com/pin/636977941054343221/" },
    { "url": "https://jp.pinterest.com/pin/1618549864585211/" }
  ],
  "proxyConfiguration": { "useApifyProxy": false },
  "domain": "www.pinterest.com",
  "limit": 100
}
````

Parameters

- urls (array, required)\
  Description: Paste Pinterest pin links or numeric IDs. Supports bulk input — add multiple pins to scrape in one run. Example: https://www.pinterest.com/pin/123456/\
  Default: none

- domain (string, optional)\
  Description: Pick the Pinterest region. Match the domain where your pins live — e.g., jp.pinterest.com for Japan, uk.pinterest.com for UK.\
  Default: "www.pinterest.com"

- limit (integer, optional)\
  Description: Cap comments per pin. Default: 10. Set higher (e.g., 100+) for full comment extraction. Minimum: 1\
  Default: 10

- proxyConfiguration (object, optional)\
  Description: Optional. Start with no proxy for speed. Auto-fallback: datacenter → residential (3 retries) if blocked.\
  Default: prefill { "useApifyProxy": false }

#### Example output

```json
{
  "pinUrl": "https://jp.pinterest.com/pin/636977941054343221/",
  "node_id": "QWdncmVnYXRlZENvbW1lbnQ6NTM2NzQzMTI4NDY0NTczODkwMg==",
  "helpful_count": 0,
  "tags": [],
  "videos": [],
  "comment_count": 0,
  "marked_helpful_by_me": false,
  "image_signatures": [],
  "user": {
    "node_id": "VXNlcjo5OTY2MzI3Mjk5NDY3NTU3MTA=",
    "first_name": "Angélica",
    "id": "996632729946755710",
    "username": "angelicachel7",
    "type": "user",
    "full_name": "Angélica Chel"
  },
  "like_count": 0,
  "images": [],
  "type": "aggregatedcomment",
  "done_at": "Sun, 02 Jun 2024 22:03:45 +0000",
  "details": "¡Me encanta! ❤l",
  "liked_by_me": false,
  "id": "5367431284645738902"
}
```

Notes:

- The actor outputs items of types aggregatedcomment, userdiditdata, and comment.
- Some fields may be empty when not available (e.g., images, tags, videos). User fields may be present but with empty strings if missing in the source.

### FAQ

#### Do I need a proxy to run this scraper?

✅ No. By default, it starts with direct requests. If Pinterest blocks or rate-limits the requests, it automatically falls back to datacenter and then residential proxies with additional retries.

#### Can I pass numeric pin IDs instead of URLs?

✅ Yes. You can supply either full Pinterest pin URLs or numeric pin IDs in the urls array. The actor will extract the correct ID either way.

#### How many comments per pin can I scrape?

📈 Controlled by the limit parameter (default: 10). Set it higher (e.g., 100+) to extract more items or omit it entirely to collect all available items for that pin.

#### Does it work for different Pinterest regions/domains?

🌍 Yes. Set the domain input to target one of 22 supported regions, such as www.pinterest.com, jp.pinterest.com, uk.pinterest.com, and more.

#### What data fields are included in the output?

🧾 Each dataset item includes pinUrl, id, type, details, user, like\_count, helpful\_count, images (normalized sizes), tags, videos, and timestamps like done\_at. The actor only pushes items whose type is aggregatedcomment, userdiditdata, or comment.

#### Can I export results to CSV or JSON?

💾 Yes. After the run completes, go to the OUTPUT tab in Apify to export your dataset in JSON or CSV formats for use in analytics or downstream tools.

#### Does it need a login or a Chrome extension?

❌ No login and no browser extension are required. The actor uses HTTP requests with smart headers, retry logic, and proxy fallback to collect public data reliably.

#### What happens if a pin has no comments?

ℹ️ The actor still returns available items from the API that match supported types, which may include userdiditdata or other metadata, so you retain structured context even when comment threads are sparse.

### Closing thoughts

The 📌 Pinterest Comment Scraper is built to extract public Pinterest pin comments reliably and at scale. With bulk URL support, smart proxy fallback, and live-saving structured JSON, it’s ideal for marketers, developers, analysts, and researchers. Use it as a Pinterest pin comment extractor to export Pinterest pin comments as JSON or CSV, and integrate results into your pipelines via the Apify platform. Start scraping smarter today and transform comment threads into actionable insights.

### What are other Pinterest scraping tools?

If you want to scrape specific Pinterest data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Pinterest Ads Scraper](https://apify.com/scrapier/pinterest-ads-scraper) | [Pinterest Keywords Discovery](https://apify.com/scrapier/pinterest-keywords-discovery-scraper) |
| [Pinterest Autocomplete Scraper](https://apify.com/scrapier/pinterest-autocomplete-scraper) | [Pinterest Lead Scraper](https://apify.com/scrapier/pinterest-lead-scraper) |
| [Pinterest Boards Scraper](https://apify.com/scrapier/pinterest-boards-scraper) | [Pinterest Phone Number Scraper](https://apify.com/scrapier/pinterest-phone-number-scraper) |
| [Pinterest Email Scraper](https://apify.com/scrapier/pinterest-email-scraper) | [Pinterest Pins/Videos Search Scraper](https://apify.com/scrapier/pinterest-pins-videos-search-scraper) |
| [Pinterest Followers Scraper](https://apify.com/scrapier/pinterest-followers-scraper) | [Pinterest Profile Scraper](https://apify.com/scrapier/pinterest-profile-scraper) |
| [Pinterest Following Scraper](https://apify.com/scrapier/pinterest-following-scraper) | [Pinterest Search Scraper](https://apify.com/scrapier/pinterest-search-scraper) |

# Actor input Schema

## `urls` (type: `array`):

📎 Paste Pinterest pin links or numeric IDs. Supports bulk input — add multiple pins to scrape in one run. Example: https://www.pinterest.com/pin/123456/

## `domain` (type: `string`):

🗺️ Pick the Pinterest region. Match the domain where your pins live — e.g. jp.pinterest.com for Japan, uk.pinterest.com for UK.

## `limit` (type: `integer`):

📊 Cap comments per pin. Default: 10. Set higher (e.g. 100+) for full comment extraction.

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

🛡️ Optional. Start with no proxy for speed. Auto-fallback: datacenter → residential (3 retries) if blocked.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://www.pinterest.com/pin/636977941054343221/"
    }
  ],
  "domain": "www.pinterest.com",
  "limit": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        {
            "url": "https://www.pinterest.com/pin/636977941054343221/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/pinterest-comment-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 = {
    "urls": [{ "url": "https://www.pinterest.com/pin/636977941054343221/" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/pinterest-comment-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 '{
  "urls": [
    {
      "url": "https://www.pinterest.com/pin/636977941054343221/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/pinterest-comment-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📌 Pinterest Comment Scraper",
        "description": "🚀 Extract comments, likes & user data from Pinterest pins at scale. Supports bulk URLs, 22 regions 🌍, smart proxy fallback (no proxy → datacenter → residential), live saving & retry logic. Perfect for social listening, content analysis & competitor research.",
        "version": "0.1",
        "x-build-id": "lyuCfIl1lpUb8SC3Z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~pinterest-comment-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-pinterest-comment-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/scrapier~pinterest-comment-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-pinterest-comment-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/scrapier~pinterest-comment-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-pinterest-comment-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Pin URLs or IDs",
                        "type": "array",
                        "description": "📎 Paste Pinterest pin links or numeric IDs. Supports bulk input — add multiple pins to scrape in one run. Example: https://www.pinterest.com/pin/123456/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domain": {
                        "title": "🌍 Region / Domain",
                        "enum": [
                            "www.pinterest.com",
                            "jp.pinterest.com",
                            "br.pinterest.com",
                            "uk.pinterest.com",
                            "au.pinterest.com",
                            "nz.pinterest.com",
                            "co.pinterest.com",
                            "de.pinterest.com",
                            "fr.pinterest.com",
                            "in.pinterest.com",
                            "es.pinterest.com",
                            "it.pinterest.com",
                            "nl.pinterest.com",
                            "pl.pinterest.com",
                            "ru.pinterest.com",
                            "tr.pinterest.com",
                            "mx.pinterest.com",
                            "ar.pinterest.com",
                            "id.pinterest.com",
                            "ph.pinterest.com",
                            "th.pinterest.com",
                            "kr.pinterest.com"
                        ],
                        "type": "string",
                        "description": "🗺️ Pick the Pinterest region. Match the domain where your pins live — e.g. jp.pinterest.com for Japan, uk.pinterest.com for UK.",
                        "default": "www.pinterest.com"
                    },
                    "limit": {
                        "title": "💬 Comments Limit (per pin)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "📊 Cap comments per pin. Default: 10. Set higher (e.g. 100+) for full comment extraction.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Settings",
                        "type": "object",
                        "description": "🛡️ Optional. Start with no proxy for speed. Auto-fallback: datacenter → residential (3 retries) if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
