# Pinterest Lead Scraper (`simpleapi/pinterest-lead-scraper`) Actor

Pinterest Lead Scraper extracts targeted leads from Pinterest profiles, boards, and pins. Collect usernames, bios, follower counts, profile links, and engagement data to discover influencers, potential customers, or businesses in your niche for outreach, research, and marketing campaigns. 📌📊

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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** Lead Scraper 📱

**Pinterest** Lead Scraper allows users to **extract** various types of **data** from **Pinterest** profiles. It focuses on gathering lead addresses, which are essential for direct communication and outreach.

In addition to **leads**, the scraper can collect other relevant details from profiles to enhance user insights. This tool is designed to ensure accuracy and reliability while maintaining compliance with legal and ethical standards.

Extracted **data** can be used for marketing, networking, and collaboration purposes. The scraper's automation capabilities make it a valuable asset for businesses and professionals seeking to streamline their **data** collection processes.

Pinterest Lead Scraper is a powerful tool designed to help users extract lead addresses from Pinterest profiles efficiently. It enables businesses and marketers to connect with Pinterest users for networking and outreach purposes.

Using a Pinterest lead extraction tool simplifies the process of gathering contact information from Pinterest profiles. This automated solution saves time and effort compared to manual lead collection methods.

Scraping leads from Pinterest can help businesses build targeted lead lists for marketing campaigns. The Pinterest Lead Finder ensures accuracy and reliability in extracting user contact details.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extracts lead addresses from Pinterest profiles for direct communication. |
| Profile Name | Captures the name of the Pinterest user for identification purposes. |
| Profile URL | Retrieves the URL of the Pinterest profile for reference and verification. |
| Follower Count | Collects the number of followers to assess the user's influence. |
| Profile Description | Extracts the bio or description from the Pinterest profile for context. |
| Pin Count | Gathers the number of pins shared by the user for content analysis. |
| Board Names | Retrieves the names of boards created by the user for topic identification. |
| Board URLs | Captures URLs of boards for further exploration and data collection. |

### Key Features of **Pinterest** Lead Scraper

Here are the **standout features** that make the **Pinterest** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of lead addresses from **Pinterest** profiles
- ⭐ **Accurate** data collection with minimal errors and duplicates
- ⭐ Ability to scrape multiple profiles simultaneously for efficiency
- ⭐ **Customizable** scraping options to target specific data types
- ⭐ **Secure** and compliant data extraction processes
- ⭐ User-friendly interface for easy operation and setup
- ⭐ **Integration** capabilities with third-party tools and platforms
- ⭐ Scalable solutions for small businesses and large enterprises
- ⭐ Detailed reporting and export options for collected data
- ⭐ **Regular** updates to ensure compatibility with **Pinterest**s platform

### How to use **Pinterest** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Pinterest** leads today:

1. ✅ **Sign up** for an account on the **Pinterest** Lead Scraper platform
2. ✅ Log in to your account and navigate to the dashboard
3. ✅ Enter the **Pinterest** profile URLs or keywords you want to scrape
4. ✅ **Select** the data types you wish to extract such as lead addresses or profile names
5. ✅ **Configure** any additional settings such as scraping limits or filters
6. ✅ **Start** the scraping process by clicking the Run button
7. ✅ Monitor the progress of the scraping task in the dashboard
8. ✅ Download the extracted data in your preferred format such as CSV or Excel

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted lead lists for promotional campaigns
🎯 Reach out to **Pinterest** users interested in specific niches

Influencer Outreach
🎯 Connect with **Pinterest** influencers for collaborations
🎯 **Identify** users with high follower counts for partnerships

Networking Opportunities
🎯 Gather contact information for professional networking
🎯 Expand your outreach to potential collaborators on **Pinterest**

Market Research
🎯 **Analyze** **Pinterest** profiles for consumer insights
🎯 Understand user preferences and trends through data collection

### Why choose us? 💎

**Pinterest** Lead Scraper is the **best** **Pinterest** lead harvesting software for professionals and businesses. Our tool is designed to provide accurate and **reliable** data extraction from **Pinterest** profiles.

With **advanced** automation features, users can save time and effort while collecting valuable contact information. We prioritize compliance with legal and ethical guidelines to ensure safe and responsible scraping practices.

Our **user-friendly** interface makes it easy for anyone to set up and run scraping tasks without technical expertise. Additionally, we offer **scalable** solutions that cater to the needs of both small businesses and large enterprises.

Regular updates and customer support ensure that our tool remains effective and compatible with **Pinterest**'s platform. Choose our **Pinterest** lead extraction tool to streamline your data collection processes and achieve your outreach goals efficiently.

### **Pinterest** Lead Scraper Scalability 📈

The **Pinterest** Lead Scraper is designed to scale with your business needs. Whether you're a small business or a large enterprise, our tool can handle scraping tasks of varying sizes.

With features like batch processing and simultaneous scraping, users can collect data from multiple profiles **efficient**ly. Our platform supports high-volume data extraction without compromising accuracy or reliability.

The **customizable** settings allow users to tailor the scraping process to their specific requirements. Additionally, integration capabilities with third-party tools ensure **seamless** workflows for larger operations.

Our automated **Pinterest** lead scraper is built to accommodate growth and adapt to changing demands, making it a valuable asset for businesses of all sizes.

### **Pinterest** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Pinterest** is **legal** as long as you follow **ethical** and **compliant** practices. The **Pinterest** Lead Scraper extracts only **publicly available** information from **public** **Pinterest** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Pinterest**s terms of service when using the scraper
⚖️ **Obtain** consent from users before utilizing their contact information for outreach
⚖️ **Avoid** scraping data from private profiles or restricted content
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ **Do not** resell or distribute the collected data without proper authorization
⚖️ **Adhere** to local and international data protection laws such as GDPR
⚖️ Regularly review **Pinterest**s policies to stay updated on scraping regulations
⚖️ Implement security measures to protect the extracted data from unauthorized access

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Pinterest Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Pinterest",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Pinterest) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Pinterest",
    "keyword": "Pinterest Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Pinterest as the source |
| keyword | Keyword that triggered the result (Pinterest Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Pinterest profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Pinterest **Lead Scraper**?

Pinterest Lead Scraper is a tool designed to extract lead addresses and other data from Pinterest profiles.

#### How does Pinterest lead **extract**ion tool work?

The tool uses **automated** processes to scrape data from Pinterest profiles based on user-defined parameters.

#### Can I scrape leads from Pinterest **legal**ly?

**Yes**, as long as you comply with Pinterest's terms of service and obtain user consent where required.

#### What data can I **extract** using Pinterest Lead Finder?

You can extract lead addresses, profile names, URLs, follower counts, and more.

#### Is the Pinterest contact scraper easy to use?

**Yes**, the tool features a **user-friendly** interface for easy setup and operation.

#### Can I use the scraper for influencer outreach?

**Yes**, the scraper is ideal for connecting with influencers and assessing their profiles.

#### Does the tool support high-volume scraping?

**Yes**, the scraper is scalable and supports high-volume data extraction tasks.

#### How do I download the **extract**ed data?

You can export the data in formats like **CSV** or Excel directly from the dashboard.

#### Is Pinterest lead harvesting software **secure**?

**Yes**, the tool implements security measures to protect your data and ensure **compliance**.

#### What are the benefits of using an automated Pinterest lead scraper?

It saves time, improves accuracy, and streamlines the data collection process for outreach and marketing.

### What are other Pinterest scraping tools?

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

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

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Pinterest (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Pinterest profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Pinterest",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/pinterest-lead-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/pinterest-lead-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/pinterest-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Lead Scraper",
        "description": "Pinterest Lead Scraper extracts targeted leads from Pinterest profiles, boards, and pins. Collect usernames, bios, follower counts, profile links, and engagement data to discover influencers, potential customers, or businesses in your niche for outreach, research, and marketing campaigns. 📌📊",
        "version": "0.1",
        "x-build-id": "U80vGkUBXiR5DfTEe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~pinterest-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-pinterest-lead-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/simpleapi~pinterest-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-pinterest-lead-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/simpleapi~pinterest-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-pinterest-lead-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Pinterest (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Pinterest profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Pinterest"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Pinterest"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
