# Pinterest Email Scraper (`scrapebase/pinterest-email-scraper`) Actor

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

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### **Pinterest** Email Scraper 📱

**Pinterest** Email Scraper provides access to a variety of **data** points that can be **extract**ed from **Pinterest** profiles and posts. These include email addresses, profile names, and other **contact** information that users publicly share.

The scraper ensures that only publicly available **data** is collected, adhering to legal and ethical guidelines. Extracting **Pinterest** user **emails** helps businesses and individuals connect with their target audience effectively.

Additionally, users can gather supplementary **data** such as profile URLs and follower counts to better understand their outreach targets. This tool is ideal for those looking for a comprehensive **Pinterest** **data** scraping solution.

Pinterest Email Scraper is a powerful tool designed to automate the process of extracting email addresses from Pinterest profiles and posts. It enables businesses and individuals to gather contact information efficiently for marketing and outreach purposes.

With Pinterest email extraction tools, users can save time and effort by automating the tedious task of manually searching for contact details. This scraper simplifies the process while ensuring high accuracy and reliability.

Scraping emails from Pinterest can be invaluable for businesses looking to connect with influencers, potential customers, or collaborators. Pinterest Email Scraper helps unlock valuable data for targeted campaigns and networking.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Publicly available email addresses shared by Pinterest users. |
| Profile names | Names of Pinterest profiles associated with the extracted emails. |
| Profile URLs | Direct links to the Pinterest profiles of users. |
| Follower counts | Number of followers associated with a specific Pinterest profile. |
| Post URLs | Links to posts where contact information may be found. |
| Bio descriptions | Publicly visible bio information from Pinterest profiles. |
| Website links | Links to external websites shared in Pinterest profiles. |
| Location data | Public location details shared by Pinterest users in their profiles. |

### Key Features of **Pinterest** Email Scraper

Here are the **standout features** that make the **Pinterest** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** email extraction from **Pinterest** profiles and posts
- ⭐ **High** accuracy in identifying publicly available contact information
- ⭐ Ability to scrape supplementary data like profile URLs and follower counts
- ⭐ User-friendly interface for easy setup and operation
- ⭐ **Customizable** scraping options to target specific data points
- ⭐ Compliance with legal and ethical guidelines for data collection
- ⭐ **Fast** and efficient scraping process to save time and resources
- ⭐ Detailed reporting and export options for extracted data
- ⭐ **Secure** data handling to protect user privacy and information
- ⭐ Scalable solution suitable for both small and large-scale data scraping needs

### How to use **Pinterest** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Pinterest** emails today:

1. ✅ **Sign up** or **log in** to the **Pinterest** Email Scraper platform
2. ✅ **Select** your scraping preferences including target profiles or posts
3. ✅ **Input** relevant keywords or URLs to specify your scraping targets
4. ✅ **Configure** the scraper settings for data types you want to extract
5. ✅ **Start** the scraper and monitor the progress in real-time
6. ✅ **Review** the extracted data in the dashboard once the process is complete
7. ✅ **Export** the data to your preferred format such as CSV or Excel
8. ✅ Use the extracted information for marketing outreach or analysis

### Use Cases 🎯

Influencer Outreach
🎯 Connect with **Pinterest** influencers by extracting their contact information
🎯 Build partnerships for marketing campaigns using accurate email data

Customer Acquisition
🎯 **Identify** potential customers by scraping emails from relevant **Pinterest** profiles
🎯 **Use** harvested data to create targeted email marketing campaigns

Market Research
🎯 **Analyze** **Pinterest** profiles and follower counts for industry insights
🎯 Gather data to understand trends and user behavior on **Pinterest**

Networking and Collaboration
🎯 **Find** collaborators by extracting contact information from **Pinterest** profiles
🎯 Reach out to professionals and businesses for joint projects or partnerships

### Why choose us? 💎

**Pinterest** Email Scraper stands out as the **best** **Pinterest** email extraction tool due to its reliability and efficiency. It provides users with a streamlined solution for gathering contact information from **Pinterest** profiles and posts.

Our scraper is designed to ensure high accuracy, extracting only publicly available data while adhering to legal guidelines. Businesses and individuals can save time and resources by automating the process of email harvesting.

With customizable scraping options, users can target specific data points that are most relevant to their needs. Our software is **user-friendly** and offers detailed reporting and export options for seamless integration into your workflow.

Whether you are looking to scrape emails from **Pinterest** for marketing, networking, or research, our tool is the ideal choice. It combines speed, security, and scalability to deliver exceptional results for all users.

### **Pinterest** Email Scraper Scalability 📈

**Pinterest** Email Scraper is built to handle data scraping needs of all sizes, making it a scalable solution for businesses and individuals. Whether you need to extract a few emails or thousands, our tool can **efficient**ly manage the process without compromising accuracy.

The scraper is designed to adapt to varying workloads, ensuring consistent performance even for **large-scale** projects. With **advanced** features like **customizable** scraping options, users can focus on specific data points while maintaining scalability.

Our software supports **seamless** data export and integration, making it suitable for diverse applications. By leveraging the scalability of **Pinterest** Email Scraper, users can grow their outreach and marketing efforts without limitations.

### **Pinterest** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Pinterest** is **legal** as long as you follow **ethical** and **compliant** practices. The **Pinterest** Email Scraper extracts only **publicly available** information from **public** **Pinterest** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Only** scrape publicly available data shared by **Pinterest** users
⚖️ **Do not** use the scraper to extract private or sensitive information
⚖️ **Ensure** compliance with **Pinterest**s terms of service and data usage policies
⚖️ **Use** the extracted data responsibly and avoid spamming recipients
⚖️ **Obtain** consent before using harvested email addresses for marketing purposes
⚖️ Regularly review legal regulations related to data scraping in your region
⚖️ **Do not** resell or distribute scraped data without proper authorization
⚖️ Respect user privacy and avoid scraping data from restricted profiles

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Pinterest Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Pinterest",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails 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 Email 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",
    "email": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

#### What is Pinterest **Email Scraper**?

Pinterest Email Scraper is an **automated** tool for extracting email addresses and other contact information from Pinterest profiles and posts.

#### Is Pinterest **Email Scraper** **legal** to use?

**Yes**, as long as you only scrape **publicly available** data and comply with Pinterest’s terms of service and legal guidelines.

#### What data can I **extract** using Pinterest **Email Scraper**?

You can extract email addresses, profile names, URLs, follower counts, bio descriptions, website links, and location data.

#### How accurate is the data **extract**ion process?

Pinterest Email Scraper ensures high accuracy by targeting publicly shared information and **filtering** irrelevant data.

#### Can I customize the scraping options?

**Yes**, the tool allows users to configure settings and target specific data points based on their needs.

#### Is the scraper suitable for **large-scale** projects?

**Yes**, Pinterest Email Scraper is scalable and can handle both small and large-scale data extraction efficiently.

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

You can export the data in various formats, including **CSV** and Excel, directly from the platform.

#### Does the scraper comply with data privacy regulations?

**Yes**, it is designed to comply with legal and ethical guidelines, ensuring user privacy and data security.

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

**Yes**, the tool is ideal for extracting contact information from influencers on Pinterest for outreach purposes.

#### What are the system requirements for using Pinterest **Email Scraper**?

The scraper is web-based and does not require specific system configurations, making it accessible from any device.

#### Can I scrape **private** profiles with this tool?

**No**, Pinterest Email Scraper only extracts data from **publicly available** profiles and posts.

#### How long does it take to complete the scraping process?

The time required depends on the scope of the project, but the scraper is optimized for fast and efficient data extraction.

#### Is technical support available for the scraper?

**Yes**, our team provides dedicated technical support to help users with any issues or queries.

#### Can I use the tool for market research?

**Yes**, Pinterest Email Scraper is ideal for gathering data for market research and trend analysis.

#### Is there a **limit** to the number of emails I can **extract**?

**No**, the scraper is scalable and can handle unlimited data extraction based on user requirements.

# 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("scrapebase/pinterest-email-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("scrapebase/pinterest-email-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 scrapebase/pinterest-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Email Scraper",
        "version": "0.1",
        "x-build-id": "t8N5DW5HvyvaP8GAm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~pinterest-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-pinterest-email-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/scrapebase~pinterest-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-pinterest-email-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/scrapebase~pinterest-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-pinterest-email-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```