# Pinterest Scraper (`techforce.global/pinterest-scraper`) Actor

Scrape Pinterest pins from keyword searches, boards, profiles & pin URLs. Export titles, images, links, videos & pinner data to JSON, CSV or Excel.

- **URL**: https://apify.com/techforce.global/pinterest-scraper.md
- **Developed by:** [Techforce Global](https://apify.com/techforce.global) (community)
- **Categories:** Social media, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.50 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Pinterest Scraper | All-In-One

**Scrape Pinterest pins from keyword searches, boards, profiles, and individual pins — all in one Actor, with built-in Apify Residential proxy support and optional one-click delivery into Notion, Slack, Linear, and other MCP connectors.**

One Actor, four input types. Point it at a search keyword, a board URL, a profile URL, or a single pin URL and get back clean, structured pin data — titles, descriptions, image URLs, board and pinner info, colors, video links, and more.

---

### ⭐ Why This Actor

- **All four input types in one Actor.** Keyword search, board, profile/username, and single pin URL — no juggling multiple tools.
- **Real browser engine.** Pinterest guards its data behind a JavaScript anti-bot check that instantly blocks raw HTTP requests. This Actor drives a real headless Chromium, so the page's own JavaScript loads the pins and we read them straight from the rendered feed. This is what makes it actually work where simple HTTP scrapers return 403s.
- **Residential proxy by default.** Pinterest aggressively blocks datacenter IPs. Apify Residential proxies are pre-configured so runs stay reliable.
- **Rich, flat output.** Every pin comes back as a clean record ready for a spreadsheet, database, or downstream automation.
- **Deliver anywhere.** Optionally push results straight into Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible connector — no glue code.

---

### 📝 Use Cases & ROI

| Use Case | What You Get | The Payoff |
| --- | --- | --- |
| **Content & trend research** | Pull hundreds of pins for a niche keyword in minutes | Spot visual trends without endless manual scrolling |
| **Competitor board analysis** | Scrape a competitor's board or profile in full | See exactly what content and products they push |
| **Mood boards & creative briefs** | Collect image URLs + dominant colors at scale | Hand designers a ready-made palette and reference set |
| **Product & affiliate sourcing** | Extract pin links, images, and descriptions | Build product feeds and catalogs automatically |
| **SEO & marketing intel** | Harvest titles and descriptions across a topic | Mine real language and keywords your audience uses |
| **Automated pipelines** | Ship pins into Notion/Slack/Airtable on every run | Turn a scrape into a living, shared workspace |

---

### 🚀 How to Use

1. Open the Actor and set at least one input:
   - **Search queries** — one or more keywords (e.g. `minimalist kitchen`).
   - **Start URLs** — paste board, profile, or pin URLs. The Actor auto-detects the type.
2. (Optional) Set **Max items** and **Max items per source** to cap the run.
3. Leave **Proxy** on Residential (recommended).
4. (Optional) Pick an **MCP connector** to deliver results into your tools.
5. Click **Start** — pins stream into the dataset and can be exported as JSON, CSV, or Excel.

---

### 🧩 Input Configuration

| Field | Type | Description |
| --- | --- | --- |
| **Search queries** (`searchQueries`) | array | Keywords to search on Pinterest. Each query is scraped as its own pin feed. |
| **Start URLs** (`startUrls`) | array | Pinterest URLs to scrape. Auto-detects type: `/pin/<id>/` scrapes a single pin, a board URL scrapes the whole board, a profile URL scrapes that user's created pins. |
| **Max items** (`maxItems`) | integer | Max total pins across all inputs. `0` = no limit. Default `100`. |
| **Max items per source** (`maxItemsPerSource`) | integer | Max pins per individual query/board/profile. `0` = no per-source limit. |
| **Proxy configuration** (`proxyConfiguration`) | object | Proxy settings. Residential strongly recommended (default). |
| **Deliver to** (`mcpConnector`) | string | Optional MCP connector to deliver pins into. Leave empty to save to the dataset only. |
| **Delivery mode** (`deliveryMode`) | string | `summary`, `chunked`, `perPin`, or `none`. |
| **Connector tool name** (`mcpTool`) | string | Tool to call on the connector (e.g. `send_message` for Slack). |
| **Connector tool arguments** (`mcpArguments`) | object | Arguments passed to the tool. Supports `{placeholders}`. |
| **Message template** (`mcpMessageTemplate`) | string | Optional template rendered as the `{message}` placeholder. |

You need at least one **Search query** or **Start URL** — otherwise there's nothing to scrape.

---

### 📤 Example Output

```json
{
  "pinId": "1125899906842624",
  "title": "Minimalist Home Office Setup",
  "description": "Clean desk ideas for a productive workspace.",
  "pinUrl": "https://www.pinterest.com/pin/1125899906842624/",
  "imageUrl": "https://i.pinimg.com/originals/ab/cd/ef/abcdef.jpg",
  "boardName": "Home Office Ideas",
  "boardUrl": "https://www.pinterest.com/username/home-office-ideas/",
  "pinnerUsername": "username",
  "pinnerFullName": "Jane Doe",
  "dominantColor": "#e8e2d9",
  "isVideo": false,
  "videoUrl": null,
  "createdAt": "2025-03-14T09:12:00",
  "sourceType": "search",
  "sourceInput": "home office ideas"
}
````

***

### 📦 Output Fields

| Field | Description |
| --- | --- |
| `pinId` | Unique Pinterest pin ID. |
| `title` | Pin title. |
| `description` | Pin description text. |
| `pinUrl` | Direct URL to the pin. |
| `imageUrl` | URL of the highest-resolution image. |
| `boardName` | Name of the board the pin belongs to. |
| `boardUrl` | URL of that board. |
| `pinnerUsername` | Username of the person who pinned it. |
| `pinnerFullName` | Display name of the pinner. |
| `dominantColor` | Dominant color of the image (hex). |
| `isVideo` | `true` if the pin is a video. |
| `videoUrl` | Video stream URL when the pin is a video. |
| `images` | All available image sizes/URLs for the pin. |
| `createdAt` | When the pin was created (if available). |
| `sourceType` | `search`, `board`, `profile`, or `pin`. |
| `sourceInput` | The exact query or URL that produced this pin. |

***

### 🔌 Integrations & Delivery

After the dataset is saved, the Actor can optionally deliver your pins straight into a connector you've authorized — **Notion, Slack, Linear, Airtable, Jira, GitHub**, or any MCP-compatible connector. Delivery runs *after* the dataset is saved and never affects the stored results.

**Delivery modes**

- **`summary`** — one call listing all pins. Placeholders: `{pinCount}`, `{pins}`, `{message}`.
- **`chunked`** — splits many pins across a few calls/pages so services like Notion never time out. Adds `{part}` and `{partCount}` on top of the summary placeholders.
- **`perPin`** — one call per pin. Per-pin placeholders: `{pinId}`, `{title}`, `{description}`, `{pinUrl}`, `{imageUrl}`, `{boardName}`, `{boardUrl}`, `{pinnerUsername}`, `{pinnerFullName}`, `{dominantColor}`, `{isVideo}`, `{videoUrl}`, `{createdAt}`, `{sourceType}`, `{sourceInput}`, `{message}`.
- **`none`** — save to the dataset only.

**Example — Slack (`summary` mode)**

Tool: `send_message`

```json
{ "channel": "#pins", "text": "{message}" }
```

Message template:

```
Scraped {pinCount} Pinterest pins:

{pins}
```

**Example — Notion (`perPin` mode)**

Tool: `notion-create-pages`

```json
{
  "parent": { "page_id": "YOUR_PAGE_ID" },
  "pages": [
    {
      "properties": { "title": "{title}" },
      "content": "{pinUrl}\n\n![image]({imageUrl})"
    }
  ]
}
```

> Tip: not sure of the tool name? Run once with a connector selected — the log lists every tool the connector exposes.

***

### 🛠️ How It Works

Pinterest is fully client-side rendered and protects its internal API with a JavaScript anti-bot check, so raw HTTP requests are blocked with a 403. To get real data, this Actor:

1. Launches a real headless Chromium browser (Playwright) through Apify Residential proxy.
2. Loads the search feed, board, profile, or pin page and lets Pinterest's own JavaScript fetch the pins.
3. Reads pin data directly from the rendered DOM and by listening to Pinterest's internal resource responses.
4. Scrolls the feed to load more pins until your limits are reached.
5. Normalizes every pin into a flat, clean record and saves it to the dataset.
6. (Optional) Delivers the saved pins into your chosen MCP connector.

***

### 🆘 Support

Questions, bugs, or a field you wish it captured? Email **bhavin.shah@techforceglobal.com** — happy to help.

#### Need a custom scraping or automation pipeline?

If you need something tailored — a different site, a custom output shape, or an end-to-end automation into your own stack — book a quick intro call: **https://calendly.com/techforce-infotech-pvt-ltd/intro-meeting?month=2026-01**

***

Made with ❤️ by [Techforce](https://www.techforceglobal.com)

***

### ⚠️ Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Pinterest**. "Pinterest" is a registered trademark of Pinterest, Inc. Use this Actor responsibly and in compliance with Pinterest's Terms of Service and all applicable laws. Only scrape publicly available data, and use the results in a lawful manner. You are solely responsible for how you use the data you collect.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Pinterest. Each query is scraped as a separate pin feed.

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

Pinterest URLs to scrape. The Actor auto-detects each URL type: a pin URL (/pin/<id>/) scrapes that single pin, a board URL scrapes all pins in the board, and a profile URL scrapes the user's created pins.

## `maxItems` (type: `integer`):

Maximum total number of pins to scrape across all inputs. Set to 0 for no limit.

## `maxItemsPerSource` (type: `integer`):

Maximum number of pins to scrape per individual search query, board, or profile. Set to 0 for no per-source limit.

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

Proxy settings. Pinterest aggressively blocks datacenter IPs, so Apify Residential proxies are strongly recommended.

## `mcpConnector` (type: `string`):

Optionally deliver the scraped pins into a connector you have authorized — Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible connector. Leave empty to only save the results to the dataset.

## `deliveryMode` (type: `string`):

How to deliver to the connector: 'summary' (one call with all pins listed), 'chunked' (split many pins across a few calls/pages so services like Notion never time out), 'perPin' (one call per pin), or 'none' (save to dataset only).

## `mcpTool` (type: `string`):

Name of the tool to call on the connector (e.g. 'create\_page' for Notion, 'send\_message' for Slack, 'create\_issue' for Jira/GitHub). If unsure, run once with a connector selected — the log lists the connector's available tools.

## `mcpArguments` (type: `object`):

Arguments passed to the connector tool. String values support {placeholders}. In 'perPin' mode, per-pin fields are available: {pinId}, {title}, {description}, {pinUrl}, {imageUrl}, {boardName}, {boardUrl}, {pinnerUsername}, {pinnerFullName}, {dominantColor}, {isVideo}, {videoUrl}, {createdAt}, {sourceType}, {sourceInput} and {message}. In 'summary' mode: {pinCount}, {pins} (a text list of all pins) and {message}. In 'chunked' mode: same as summary but {pins} holds one part of the list and {part}/{partCount} give the 1-based part number and total (put these in the page title, e.g. 'Pinterest pins (part {part}/{partCount})'). Example for Slack: {"channel": "#pins", "text": "{message}"}.

## `mcpMessageTemplate` (type: `string`):

Optional template rendered and exposed as the {message} placeholder in the tool arguments. Summary example: 'Scraped {pinCount} Pinterest pins:\n\n{pins}'. Per-pin example: '{title} — {pinUrl}'.

## Actor input object example

```json
{
  "searchQueries": [
    "minimalist kitchen",
    "travel photography"
  ],
  "startUrls": [],
  "maxItems": 100,
  "maxItemsPerSource": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "deliveryMode": "summary",
  "mcpTool": "",
  "mcpArguments": {},
  "mcpMessageTemplate": ""
}
```

# 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 = {
    "searchQueries": [
        "home office ideas"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("techforce.global/pinterest-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 = {
    "searchQueries": ["home office ideas"],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("techforce.global/pinterest-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 '{
  "searchQueries": [
    "home office ideas"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call techforce.global/pinterest-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Scraper",
        "description": "Scrape Pinterest pins from keyword searches, boards, profiles & pin URLs. Export titles, images, links, videos & pinner data to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "bCF6s2wrC7MKw3ioc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/techforce.global~pinterest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-techforce.global-pinterest-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/techforce.global~pinterest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-techforce.global-pinterest-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/techforce.global~pinterest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-techforce.global-pinterest-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": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Pinterest. Each query is scraped as a separate pin feed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (boards / profiles / pins)",
                        "type": "array",
                        "description": "Pinterest URLs to scrape. The Actor auto-detects each URL type: a pin URL (/pin/<id>/) scrapes that single pin, a board URL scrapes all pins in the board, and a profile URL scrapes the user's created pins.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of pins to scrape across all inputs. Set to 0 for no limit.",
                        "default": 100
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per source",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pins to scrape per individual search query, board, or profile. Set to 0 for no per-source limit.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Pinterest aggressively blocks datacenter IPs, so Apify Residential proxies are strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "mcpConnector": {
                        "title": "Deliver to (MCP connector)",
                        "type": "string",
                        "description": "Optionally deliver the scraped pins into a connector you have authorized — Notion, Slack, Linear, Airtable, Jira, GitHub, or any MCP-compatible connector. Leave empty to only save the results to the dataset."
                    },
                    "deliveryMode": {
                        "title": "Delivery mode",
                        "enum": [
                            "summary",
                            "chunked",
                            "perPin",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to deliver to the connector: 'summary' (one call with all pins listed), 'chunked' (split many pins across a few calls/pages so services like Notion never time out), 'perPin' (one call per pin), or 'none' (save to dataset only).",
                        "default": "summary"
                    },
                    "mcpTool": {
                        "title": "Connector tool name",
                        "type": "string",
                        "description": "Name of the tool to call on the connector (e.g. 'create_page' for Notion, 'send_message' for Slack, 'create_issue' for Jira/GitHub). If unsure, run once with a connector selected — the log lists the connector's available tools.",
                        "default": ""
                    },
                    "mcpArguments": {
                        "title": "Connector tool arguments",
                        "type": "object",
                        "description": "Arguments passed to the connector tool. String values support {placeholders}. In 'perPin' mode, per-pin fields are available: {pinId}, {title}, {description}, {pinUrl}, {imageUrl}, {boardName}, {boardUrl}, {pinnerUsername}, {pinnerFullName}, {dominantColor}, {isVideo}, {videoUrl}, {createdAt}, {sourceType}, {sourceInput} and {message}. In 'summary' mode: {pinCount}, {pins} (a text list of all pins) and {message}. In 'chunked' mode: same as summary but {pins} holds one part of the list and {part}/{partCount} give the 1-based part number and total (put these in the page title, e.g. 'Pinterest pins (part {part}/{partCount})'). Example for Slack: {\"channel\": \"#pins\", \"text\": \"{message}\"}.",
                        "default": {}
                    },
                    "mcpMessageTemplate": {
                        "title": "Message template",
                        "type": "string",
                        "description": "Optional template rendered and exposed as the {message} placeholder in the tool arguments. Summary example: 'Scraped {pinCount} Pinterest pins:\\n\\n{pins}'. Per-pin example: '{title} — {pinUrl}'.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
