# Pinterest Ads Library Scraper (`automation-lab/pinterest-ads-library-scraper`) Actor

Scrape public Pinterest Ads Repository creatives, advertisers, dates, markets, landing URLs, and audience disclosure metadata.

- **URL**: https://apify.com/automation-lab/pinterest-ads-library-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **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.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 Ads Library Scraper

Scrape the public Pinterest Ads Repository and export ad creatives, landing URLs, countries, dates, and transparency metadata for competitor research.

### What does Pinterest Ads Library Scraper do?

Pinterest Ads Library Scraper turns the public Pinterest Ads Repository into a structured dataset.

It opens the official repository UI, applies your filters, captures the public ad-library network responses, paginates through results, and saves one dataset row per ad.

Use it to monitor creatives, advertiser activity, landing domains, country coverage, audience disclosures, and ad run dates.

### Who is it for?

#### Performance marketers and growth teams

Use the scraper to build a repeatable swipe file of Pinterest ad creatives by market, category, and landing domain. A weekly run helps you spot fresh hooks, seasonal offers, creative formats, and competitor landing-page changes before they show up in paid-search or social reports.

#### Competitive-intelligence and ecommerce operators

Track which brands are active in each Pinterest repository country, which products they promote, and where the ads send shoppers. Export landing domains, creative images, dates, and country coverage to compare positioning across markets or to enrich an internal competitor database.

#### Agencies and reporting teams

Schedule country or category searches for each client, send rows to Google Sheets or a warehouse, and turn the dataset into recurring creative-review decks. The stable fields make it easy to deduplicate by `adId` and highlight newly discovered ads between reporting periods.

#### Compliance and transparency researchers

Collect public ad-transparency records from Pinterest's official repository for audits, disclosure checks, and market research. The actor preserves missing public fields as `null` or empty arrays so downstream analysis can distinguish unavailable data from extracted values.

### Why use this actor?

- It works with the official public Pinterest Ads Repository.
- It exports clean JSON, CSV, Excel, HTML, XML, and RSS through Apify datasets.
- It captures creative URLs, landing domains, dates, countries, and demographic fields when Pinterest returns them.
- It paginates automatically up to your requested `maxItems`.
- It is designed for recurring monitoring workflows.

### What data can you extract?

| Field | Description |
|---|---|
| `adId` | Pinterest ad / pin identifier |
| `advertiserNames` | Advertiser names returned by the repository |
| `title` | Creative title |
| `description` | Creative text or pin description |
| `creativeType` | `image`, `video`, `carousel`, or `unknown` |
| `imageUrl` | Public creative image URL |
| `videoUrl` | Public creative video URL when available |
| `landingUrl` | Destination URL when Pinterest exposes it |
| `landingDomain` | Destination domain |
| `countries` | Countries where the ad was shown |
| `startDate` | Ad start date |
| `endDate` | Ad end date |
| `ageBuckets` | Audience age buckets |
| `genders` | Audience gender buckets |
| `userCountByCountry` | Public reach range by country |
| `euUserCount` | EU reach range when available |
| `sourceUrl` | Pinterest repository source URL |

### How much does it cost to scrape Pinterest ads?

This actor uses pay-per-event pricing: a small run-start fee plus one `result` event for every Pinterest ad saved to the dataset. You only pay the per-ad event when the actor actually exports a row.

Current configured pricing for the private build is:

| Event | Price |
|---|---:|
| Run started (`start`) | $0.005 per run |
| Result extracted (`result`, FREE tier) | $0.00025683 per ad |
| Result extracted (`result`, BRONZE tier) | $0.00022333 per ad |
| Result extracted (`result`, SILVER tier) | $0.00017419 per ad |
| Result extracted (`result`, GOLD tier) | $0.000134 per ad |
| Result extracted (`result`, PLATINUM tier) | $0.000089331 per ad |
| Result extracted (`result`, DIAMOND tier) | $0.000062531 per ad |

Examples before Apify platform fees or future pricing changes:

- 50 exported ads on BRONZE: about $0.0162 (`$0.005 + 50 × $0.00022333`).
- 100 exported ads on BRONZE: about $0.0273.
- 500 exported ads on BRONZE: about $0.1167.

Exact live prices are always shown on the Apify Store pricing tab. If Pinterest returns no rows for a narrow filter, only the run-start event is charged.

### Input overview

| Input | Type | Required | Description |
|---|---|---:|---|
| `country` | string | yes | Repository country code such as `DE`, `FR`, `IT`, `ES`, `NL`, `BR`, or `TR` |
| `advertiserName` | string | no | Optional advertiser-name filter |
| `adCategory` | string | no | Optional Pinterest ad category |
| `gender` | string | no | Optional audience gender filter |
| `ageBucket` | string | no | Optional age bucket filter |
| `maxItems` | integer | yes | Maximum ads to save |

### Example input

```json
{
  "country": "DE",
  "maxItems": 50
}
````

### Advertiser monitoring example

```json
{
  "country": "DE",
  "advertiserName": "Meyer-Stuttgart",
  "maxItems": 50
}
```

### Category research example

```json
{
  "country": "FR",
  "adCategory": "BEAUTY",
  "maxItems": 100
}
```

### Output example

```json
{
  "adId": "954903927262465448",
  "advertiserNames": [],
  "title": "Unsere Sommer-Buchtipps",
  "description": "Packst du für den Sommerurlaub...",
  "creativeType": "image",
  "imageUrl": "https://i.pinimg.com/474x/...jpg",
  "videoUrl": null,
  "landingUrl": "https://www.example.com/page",
  "landingDomain": "example.com",
  "countries": ["Germany"],
  "startDate": "2026-06-23",
  "endDate": "2026-07-04",
  "ageBuckets": ["18+"],
  "genders": ["UNSPECIFIED", "FEMALE", "MALE"],
  "sourceUrl": "https://ads.pinterest.com/ads-repository/954903927262465448",
  "scrapedAt": "2026-07-07T07:06:29.537Z"
}
```

### How to run

1. Open the actor on Apify.
2. Choose a repository country.
3. Optionally add an advertiser name, category, gender, or age filter.
4. Set `maxItems`.
5. Click **Start**.
6. Export results from the default dataset.

### Tips for best results

- Start with `maxItems: 50` to validate a filter.
- Use a country supported by Pinterest's public repository UI.
- Leave `advertiserName` empty for broad market research.
- Add `adCategory` when you need a cleaner niche dataset.
- Run the same input daily or weekly to monitor new creatives.

### Supported country codes

The repository UI currently exposes countries such as Austria, Belgium, Brazil, Bulgaria, Croatia, Cyprus, Czech Republic, Denmark, Estonia, Finland, France, Germany, Greece, Hungary, Ireland, Italy, Latvia, Lithuania, Luxembourg, Malta, Netherlands, Norway, Poland, Portugal, Romania, Slovakia, Slovenia, Spain, Sweden, and Turkey.

Use the corresponding input codes: `AT`, `BE`, `BR`, `BG`, `HR`, `CY`, `CZ`, `DK`, `EE`, `FI`, `FR`, `DE`, `GR`, `HU`, `IE`, `IT`, `LV`, `LT`, `LU`, `MT`, `NL`, `NO`, `PL`, `PT`, `RO`, `SK`, `SI`, `ES`, `SE`, `TR`.

### Integrations

- Send dataset rows to Google Sheets for weekly creative reviews.
- Store landing domains in a data warehouse for competitor tracking.
- Trigger Slack alerts when new advertisers appear.
- Enrich landing domains with SEO or technology-stack data.
- Combine with other ad-library scrapers for cross-platform creative intelligence.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pinterest-ads-library-scraper').call({
  country: 'DE',
  maxItems: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/pinterest-ads-library-scraper').call({
    'country': 'DE',
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~pinterest-ads-library-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"country":"DE","maxItems":50}'
```

### MCP usage

Use this actor from MCP-compatible tools via Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/pinterest-ads-library-scraper
```

Claude Code setup command:

```bash
claude mcp add apify-pinterest-ads --transport http --url "https://mcp.apify.com/?tools=automation-lab/pinterest-ads-library-scraper"
```

Claude Desktop JSON config example:

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

Cursor setup:

1. Open **Cursor Settings → MCP**.
2. Add a new HTTP MCP server named `apify-pinterest-ads`.
3. Use this URL: `https://mcp.apify.com/?tools=automation-lab/pinterest-ads-library-scraper`.
4. Save, reconnect the server, and select the Pinterest Ads Library Scraper tool in chat.

VS Code setup:

1. Install an MCP-compatible extension such as GitHub Copilot Chat with MCP support.
2. Add an HTTP MCP server named `apify-pinterest-ads`.
3. Set the server URL to `https://mcp.apify.com/?tools=automation-lab/pinterest-ads-library-scraper`.
4. Reload VS Code if needed, then ask the tool to run with a country and `maxItems` input.

Claude Desktop setup:

1. Open Claude Desktop settings and edit the MCP server configuration.
2. Add the JSON config above under `mcpServers`.
3. Restart Claude Desktop so the Apify MCP server is discovered.
4. In a new chat, ask Claude to use `automation-lab/pinterest-ads-library-scraper` with your selected input.

#### MCP example prompts

Example prompts showing MCP usage after adding the Apify MCP server:

- "Use the Apify MCP Pinterest Ads Library Scraper tool for Germany and summarize the most common landing domains."
- "Run the MCP tool to scrape 100 French beauty Pinterest ads and group creatives by advertiser."
- "Use the Pinterest ads MCP scraper to monitor this advertiser's ads and highlight new creative angles."

### Claude Desktop workflow

Add the Apify MCP server, enable the `automation-lab/pinterest-ads-library-scraper` tool, and ask Claude Desktop to collect recent ads for your selected market.

### Data quality notes

Pinterest sometimes returns `null` advertiser names in list responses even when a filter is active.

When a field is not present in the public response, the actor leaves it as `null` or an empty array instead of inventing values.

### Troubleshooting: no results

If a run returns zero ads, try a broader country/category combination or remove the advertiser filter.

Some countries and categories have fewer active ads in the selected date window.

### Troubleshooting: country not available

Pinterest's repository does not expose every global country in the public UI.

Use one of the supported country codes listed above.

### Legality and responsible use

This actor extracts public transparency information from the public Pinterest Ads Repository.

You should use the data responsibly, respect applicable laws, and avoid collecting or using personal data in ways that violate regulations or platform terms.

### FAQ

#### Is it legal to scrape Pinterest Ads Repository?

This actor is intended for public ad-transparency research, competitor monitoring, and compliance workflows. You are responsible for using exported data lawfully and respecting applicable terms.

#### Why are advertiser names sometimes empty?

Pinterest may omit advertiser names in list responses even when other ad metadata is present. The actor preserves the public response instead of guessing.

#### Can I monitor one advertiser?

Yes. Use `advertiserName` with a supported country code, then schedule the actor daily or weekly and compare new `adId` values over time.

### Related scrapers

- https://apify.com/automation-lab/facebook-ads-library-scraper
- https://apify.com/automation-lab/google-ads-transparency-scraper
- https://apify.com/automation-lab/linkedin-ads-library-scraper
- https://apify.com/automation-lab/tiktok-ads-library-scraper

### Changelog

- Initial version: public Pinterest Ads Repository extraction with filters, pagination, creative fields, landing domains, dates, countries, and disclosure metadata.

### Support

If you need another Pinterest repository field or a different monitoring workflow, open an issue on the actor page with your target input and expected output.

# Actor input Schema

## `country` (type: `string`):

Pinterest Ads Repository country code. The repository currently covers EU/EEA countries plus Brazil and Turkey; use values such as DE, FR, IT, ES, NL, BR, or TR.

## `advertiserName` (type: `string`):

Optional exact advertiser-name filter. Leave empty to scrape all ads matching the country/category filters.

## `adCategory` (type: `string`):

Optional Pinterest ad category filter.

## `gender` (type: `string`):

Optional audience gender filter from the public repository UI.

## `ageBucket` (type: `string`):

Optional age range filter from the public repository UI.

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

Maximum number of ad records to save. Each repository page contains about 24 ads.

## Actor input object example

```json
{
  "country": "DE",
  "advertiserName": "",
  "adCategory": "ALL",
  "gender": "ALL",
  "ageBucket": "ALL",
  "maxItems": 20
}
```

# 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 = {
    "country": "DE",
    "advertiserName": "",
    "adCategory": "ALL",
    "gender": "ALL",
    "ageBucket": "ALL",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pinterest-ads-library-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 = {
    "country": "DE",
    "advertiserName": "",
    "adCategory": "ALL",
    "gender": "ALL",
    "ageBucket": "ALL",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pinterest-ads-library-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 '{
  "country": "DE",
  "advertiserName": "",
  "adCategory": "ALL",
  "gender": "ALL",
  "ageBucket": "ALL",
  "maxItems": 20
}' |
apify call automation-lab/pinterest-ads-library-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Ads Library Scraper",
        "description": "Scrape public Pinterest Ads Repository creatives, advertisers, dates, markets, landing URLs, and audience disclosure metadata.",
        "version": "0.1",
        "x-build-id": "kTnsf0mKiEczsZLmu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pinterest-ads-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pinterest-ads-library-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~pinterest-ads-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pinterest-ads-library-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~pinterest-ads-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pinterest-ads-library-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": [
                    "country",
                    "maxItems"
                ],
                "properties": {
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "AT",
                            "BE",
                            "BR",
                            "BG",
                            "HR",
                            "CY",
                            "CZ",
                            "DK",
                            "EE",
                            "FI",
                            "FR",
                            "DE",
                            "GR",
                            "HU",
                            "IE",
                            "IT",
                            "LV",
                            "LT",
                            "LU",
                            "MT",
                            "NL",
                            "NO",
                            "PL",
                            "PT",
                            "RO",
                            "SK",
                            "SI",
                            "ES",
                            "SE",
                            "TR"
                        ],
                        "type": "string",
                        "description": "Pinterest Ads Repository country code. The repository currently covers EU/EEA countries plus Brazil and Turkey; use values such as DE, FR, IT, ES, NL, BR, or TR.",
                        "default": "DE"
                    },
                    "advertiserName": {
                        "title": "🏷️ Advertiser name",
                        "type": "string",
                        "description": "Optional exact advertiser-name filter. Leave empty to scrape all ads matching the country/category filters.",
                        "default": ""
                    },
                    "adCategory": {
                        "title": "📌 Ad category",
                        "enum": [
                            "ALL",
                            "ANIMALS",
                            "ARCHITECTURE",
                            "ART",
                            "BEAUTY",
                            "CHILDRENS_FASHION",
                            "DESIGN",
                            "DIY_AND_CRAFTS",
                            "EDUCATION",
                            "ELECTRONICS",
                            "ENTERTAINMENT",
                            "EVENT_PLANNING",
                            "FINANCE",
                            "FOOD_AND_DRINKS",
                            "GARDENING",
                            "HEALTH",
                            "HOME_DECOR",
                            "MENS_FASHION",
                            "OTHER",
                            "PARENTING",
                            "QUOTES",
                            "SPORT",
                            "TRAVEL",
                            "VEHICLES",
                            "WEDDING",
                            "WOMENS_FASHION"
                        ],
                        "type": "string",
                        "description": "Optional Pinterest ad category filter.",
                        "default": "ALL"
                    },
                    "gender": {
                        "title": "👤 Gender",
                        "enum": [
                            "ALL",
                            "FEMALE",
                            "MALE",
                            "UNSPECIFIED"
                        ],
                        "type": "string",
                        "description": "Optional audience gender filter from the public repository UI.",
                        "default": "ALL"
                    },
                    "ageBucket": {
                        "title": "🎂 Age bucket",
                        "enum": [
                            "ALL",
                            "AGE_18_24",
                            "AGE_25_34",
                            "AGE_35_44",
                            "AGE_45_49",
                            "AGE_50_54",
                            "AGE_55_64",
                            "AGE_65_PLUS"
                        ],
                        "type": "string",
                        "description": "Optional age range filter from the public repository UI.",
                        "default": "ALL"
                    },
                    "maxItems": {
                        "title": "Maximum ads",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of ad records to save. Each repository page contains about 24 ads.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
