# Pinterest Ads Scraper (`scraper-engine/pinterest-ads-scraper`) Actor

📌 Pinterest Ads Scraper (pinterest-ads-scraper) extracts ad creatives, titles, pins, destination URLs, advertiser, impressions & dates from Pinterest — fast. 🚀 Export to CSV/JSON, monitor competitors, spot trends, and optimize campaigns. Ideal for marketers, agencies & e‑commerce. ⚙️ API-ready.

- **URL**: https://apify.com/scraper-engine/pinterest-ads-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Automation, E-commerce, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 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.

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 Scraper

The Pinterest Ads Scraper is a fast, API-ready Apify actor that collects public ad data from Pinterest’s Ads Library by date range and country. It solves the time-consuming challenge of manually researching Pinterest campaigns by automating bulk discovery and per-ad detail extraction — perfect for marketers, developers, data analysts, and researchers. As a Pinterest ad scraper and Pinterest ad library scraper, it enables scalable competitor tracking, creative analysis, and reporting workflows across markets.

### What is Pinterest Ads Scraper?

Pinterest Ads Scraper is a production-ready tool that fetches promoted Pins from Pinterest’s public Ads Library for a chosen country and date range, then saves structured ad details to a dataset for export. It helps teams replace manual research with an automated Pinterest ads spy tool and Pinterest ad creatives scraper workflow, unlocking faster Pinterest competitor ads analysis and trend tracking at scale.

- Built for marketers, agencies, analysts, and developers who need repeatable Pinterest ads research.
- Enables large-scale discovery, monitoring, and export of Pinterest ad data for reporting and optimization.

### What data / output can you get?

Each dataset record represents a single ad (Pin) with a unique ID and a comprehensive ad_details object from Pinterest’s Ads Library.

| Data type | Description | Example value |
| --- | --- | --- |
| pin_id | Unique identifier of the promoted Pin | “1234567890123456789” |
| ad_details.advertiser_names | List of advertiser display names | ["Acme Co."] |
| ad_details.start_date | Ad start date | “2026-03-05” |
| ad_details.end_date | Ad end date | “2026-03-12” |
| ad_details.countries | Targeted countries (ISO codes) | ["FR","BE"] |
| ad_details.user_count_by_country | Audience counts by country | {"FR": 125000, "BE": 18000} |
| ad_details.image_link | Primary image URL of the creative | "https://i.pinimg.com/.../creative.jpg" |
| ad_details.pin_data.title | Pin title text | “Spring Collection Sale” |
| ad_details.pin_data.details | Pin details/description | “Up to 50% off on selected styles.” |
| ad_details.pin_data | Additional Pin metadata payload | { ... } |

Notes:
- ad_details is passed through from Pinterest’s public Ads Library and may vary per ad. Some nested keys can be missing depending on the campaign.
- Export your dataset to CSV, JSON, or Excel directly from Apify to power BI dashboards, creative reviews, or archives.

### Key features

- ⚡️ Bold-scale discovery & detail collection — Efficient two-phase flow: bulk fetch discovers ads, then individual fetch saves rich details. Concurrency set to 5 with batch size 10 for speed and stability.
- 🎯 Precise market & time filters — Filter by country and date range to focus your Pinterest ad intelligence platform on the campaigns that matter.
- 🧠 Smart retries & stability — Automatic retries with incremental delay (up to 3 attempts) help overcome transient network or rate conditions.
- 🧹 Duplicate-safe saves — Built-in deduplication ensures each ad is captured once even across paginated results.
- 📥 Real-time streaming — Ads are pushed to the dataset as they’re collected, enabling live review and incremental exports.
- 📦 Flexible export — Download results as CSV, JSON, or Excel from the Apify dataset UI for analysis, reporting, and archives.
- 🌐 Optional proxy support — Enable proxyConfiguration if you experience access issues for more robust collection.
- 🔌 API-ready — Orchestrate this Pinterest ads crawler from your stack using the Apify API for pipelines and automation.

### How to use Pinterest Ads Scraper - step by step

1. Sign in to your Apify account.
2. Open the Pinterest Ads Scraper actor.
3. Set start_date and end_date in YYYY-MM-DD format (e.g., “2026-03-01” to “2026-03-14”).
4. Select the country you want to analyze (e.g., France). The actor will collect ads shown in that market.
5. (Optional) Adjust resultsLimit to control how many ads to fetch (1–10,000; default 100).
6. (Optional) Enable proxyConfiguration if you encounter access issues (useApifyProxy).
7. Click Start. You’ll see logs like “Discovering ads …” and “Collected …” as the Pinterest promoted pins scraper saves items in real time.
8. Download your results from the run’s Dataset tab in CSV, JSON, or Excel — or pull them via the Apify API for downstream analysis.

Pro Tip: Use a small resultsLimit (e.g., 25) to preview your Pinterest ads research tool setup, then increase it for full-scale runs.

### Use cases

| Use case name | Description |
| --- | --- |
| Pinterest competitor ads analysis | Track competitor creatives and messaging by country and date range to inform your positioning and offers. |
| Creative testing & benchmarking | Compare titles, formats, and visuals with a Pinterest ad creatives scraper to inspire new tests. |
| Market entry research | Evaluate ad activity in a target country before investing in campaigns. |
| Campaign monitoring | Schedule periodic runs to scrape Pinterest sponsored posts and observe changes in creative or targeting over time. |
| E‑commerce trend insights | Analyze seasonal themes and promotions to guide merchandising and pricing decisions. |
| BI & dashboard pipelines (API) | Feed the Pinterest ads data extractor into your warehouse and dashboards for ongoing reporting. |
| Academic & policy research | Study public ad activity across countries and dates using a structured Pinterest ad library scraper dataset. |

### Why choose Pinterest Ads Scraper?

The Pinterest Ads Scraper prioritizes precision, automation, and reliability for production workflows.

- 🎯 Accurate, focused extraction from Pinterest’s public Ads Library endpoints.
- ⚡ Fast, concurrent collection (5 parallel requests, batch size 10) with built-in retry logic.
- 📈 Scales to large pulls with resultsLimit up to 10,000 records.
- 🔌 API-ready output with straightforward CSV/JSON/Excel exports from Apify datasets.
- 🧰 Optional proxy for resilient access in stricter environments.
- 🛡️ Stable infrastructure — avoids fragile browser extensions and manual copy-paste.
- 🧾 Clear country and date filters for targeted Pinterest ads spy tool workflows.

In short: a reliable, production-grade Pinterest ads scraper tool for automated, structured insights.

### Is it legal / ethical to use Pinterest Ads Scraper?

Yes — when done responsibly. This actor collects data from Pinterest’s public Ads Library endpoints and does not access private or authenticated content.

Guidelines:
- Only use data that is publicly available.
- Comply with applicable regulations (e.g., GDPR, CCPA) and platform terms.
- Avoid scraping personal or sensitive information.
- Use the data for analysis and research — not for spam or misuse.
- Consult your legal team for edge cases or jurisdiction-specific questions.

### Input parameters & output format

#### Example JSON input
```json
{
  "start_date": "2026-03-01",
  "end_date": "2026-03-14",
  "country": "France",
  "resultsLimit": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

- start\_date (string)
  - Description: First day of the period (YYYY-MM-DD). Required.
  - Default: "2026-03-01"
  - Required: Yes
- end\_date (string)
  - Description: Last day of the period (YYYY-MM-DD). Required.
  - Default: "2026-03-14"
  - Required: Yes
- country (string)
  - Description: Choose the market you want to analyze — ads shown in this country will be collected.
  - Default: "France"
  - Required: Yes
- resultsLimit (integer)
  - Description: Maximum number of ads to fetch (1–10,000).
  - Default: 100
  - Required: No
- proxyConfiguration (object)
  - Description: Enable if you experience access issues. Most users can leave this disabled.
  - Default: {"useApifyProxy": false} (prefill)
  - Required: No

#### Example JSON output

```json
{
  "pin_id": "1234567890123456789",
  "ad_details": {
    "advertiser_names": ["Acme Co."],
    "start_date": "2026-03-05",
    "end_date": "2026-03-12",
    "countries": ["FR", "BE"],
    "user_count_by_country": {
      "FR": 125000,
      "BE": 18000
    },
    "image_link": "https://i.pinimg.com/.../creative.jpg",
    "pin_data": {
      "title": "Spring Collection Sale",
      "details": "Up to 50% off on selected styles."
    }
  }
}
```

Notes:

- Records are pushed in real time via Actor.push\_data with fields pin\_id and ad\_details.
- ad\_details is returned as provided by Pinterest’s Ads Library; nested fields may vary by ad and may be absent in some cases.

### FAQ

#### Is there a free tier or trial?

✅ Yes. You can run the Pinterest Ads Scraper on Apify’s platform with pay‑as‑you‑go usage. Start with small resultsLimit values to estimate costs.

#### Do I need to log in to Pinterest or provide cookies?

❌ No. The scraper uses Pinterest’s public Ads Library endpoints and does not require login or cookies.

#### Can I use this with Python or an API?

💻 Yes. The actor is API‑ready, and you can orchestrate runs and download datasets via the Apify API from Python or any language.

#### How many ads can I scrape in one run?

📈 You can configure resultsLimit from 1 to 10,000. The actor runs 5 concurrent requests with batch size 10 for efficient collection.

#### Which countries are supported?

🌍 You select a country from the predefined list (e.g., France, United States, United Kingdom, Germany, Spain, and more). Ads shown in that market will be collected for your date range.

#### What ad data does it return?

🧩 Each record includes a pin\_id and an ad\_details object from Pinterest’s Ads Library. ad\_details typically includes advertiser\_names, start\_date, end\_date, countries, user\_count\_by\_country, image\_link, and pin\_data (title, details, etc.).

#### Does it support proxies?

🔒 Yes. Enable proxyConfiguration if you experience access issues. By default, useApifyProxy is set to false.

#### Can I scrape Pinterest sponsored posts for competitor analysis?

✅ Yes. This Pinterest ads monitoring tool is ideal for Pinterest competitor ads analysis and research, enabling you to track creatives by country and date range.

### Closing CTA / Final thoughts

Pinterest Ads Scraper is built for structured, scalable Pinterest ad intelligence and monitoring. It delivers fast bulk discovery with per-ad detail, clean dataset exports, and optional proxy support — ideal for marketers, agencies, developers, and researchers.

Use it to export campaigns to CSV/JSON, power dashboards, or automate pipelines via the Apify API. Start running your Pinterest ads spy tool at scale and extract smarter insights for better creative and strategy decisions.

# Actor input Schema

## `start_date` (type: `string`):

First day of the period (YYYY-MM-DD). Required.

## `end_date` (type: `string`):

Last day of the period (YYYY-MM-DD). Required.

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

Choose the market you want to analyze—ads shown in this country will be collected

## `resultsLimit` (type: `integer`):

Maximum number of ads to fetch (1–10,000)

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

Enable if you experience access issues. Most users can leave this disabled.

## Actor input object example

```json
{
  "start_date": "2026-03-01",
  "end_date": "2026-03-14",
  "country": "France",
  "resultsLimit": 100,
  "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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/pinterest-ads-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 = { "proxyConfiguration": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/pinterest-ads-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 '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/pinterest-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Ads Scraper",
        "description": "📌 Pinterest Ads Scraper (pinterest-ads-scraper) extracts ad creatives, titles, pins, destination URLs, advertiser, impressions & dates from Pinterest — fast. 🚀 Export to CSV/JSON, monitor competitors, spot trends, and optimize campaigns. Ideal for marketers, agencies & e‑commerce. ⚙️ API-ready.",
        "version": "0.2",
        "x-build-id": "KIVpITbAnIbUsrdK7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~pinterest-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-pinterest-ads-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/scraper-engine~pinterest-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-pinterest-ads-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/scraper-engine~pinterest-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-pinterest-ads-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": [
                    "start_date",
                    "end_date",
                    "country"
                ],
                "properties": {
                    "start_date": {
                        "title": "📅 Start Date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "First day of the period (YYYY-MM-DD). Required.",
                        "default": "2026-03-01"
                    },
                    "end_date": {
                        "title": "📅 End Date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Last day of the period (YYYY-MM-DD). Required.",
                        "default": "2026-03-14"
                    },
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "Austria",
                            "Belgium",
                            "Brazil",
                            "Bulgaria",
                            "Croatia",
                            "Cyprus",
                            "Czech Republic",
                            "Denmark",
                            "Estonia",
                            "Finland",
                            "France",
                            "Germany",
                            "Greece",
                            "Hungary",
                            "Ireland",
                            "Italy",
                            "Latvia",
                            "Lithuania",
                            "Luxembourg",
                            "Malta",
                            "Netherlands",
                            "Poland",
                            "Portugal",
                            "Romania",
                            "Slovakia",
                            "Slovenia",
                            "Spain",
                            "Sweden",
                            "Turkey",
                            "United Kingdom",
                            "United States"
                        ],
                        "type": "string",
                        "description": "Choose the market you want to analyze—ads shown in this country will be collected",
                        "default": "France"
                    },
                    "resultsLimit": {
                        "title": "🔢 Results Limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of ads to fetch (1–10,000)",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (Optional)",
                        "type": "object",
                        "description": "Enable if you experience access issues. Most users can leave this disabled."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
