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

Pinterest Email Scraper helps you collect business and creator emails directly from Pinterest accounts. Use the data for social commerce sales, influencer outreach, and supplier communication.

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

## Pricing

$14.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** Email Scraper 📱

The **Pinterest** Email Scraper enables users to **extract** various types of **data** from **Pinterest** profiles. This includes email addresses, usernames, profile URLs, and other relevant **contact** information.

By automating the **data** collection process, the tool helps users save time and focus on their core tasks. The scraper is designed to provide accurate and reliable results, ensuring that the **extract**ed **data** is useful for marketing, networking, or research purposes.

With its advanced features, users can customize the scraping process to target specific profiles or niches. This makes the **Pinterest** Email Scraper a versatile solution for businesses and individuals looking to harness the potential of **Pinterest** **data**.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses from Pinterest profiles for direct communication. |
| Usernames | Collect usernames associated with Pinterest accounts for identification. |
| Profile URLs | Retrieve profile links to access user pages directly. |
| Follower count | Gather follower statistics to identify popular profiles. |
| Bio information | Extract bio details to understand user interests and expertise. |
| Website links | Scrape links to external websites shared on Pinterest profiles. |
| Location data | Collect location details if available on user profiles. |
| Profile images | Download profile pictures for visual identification. |

### 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 to save time and effort
- ⭐ **Customizable** scraping options to target specific niches or demographics
- ⭐ **Accurate** and reliable data collection for marketing and networking purposes
- ⭐ User-friendly interface designed for both beginners and advanced users
- ⭐ **Advanced** filtering options to refine search results and extract relevant data
- ⭐ **High**-speed scraping capabilities to process large volumes of data quickly
- ⭐ Export data in multiple formats such as CSV or JSON for easy integration
- ⭐ **Regular** updates to ensure compatibility with **Pinterest**s latest features
- ⭐ **Secure** and ethical scraping practices to protect user data and comply with regulations
- ⭐ Detailed documentation and customer support for seamless user experience

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

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

1. ✅ **Sign up** for an account to access the **Pinterest** Email Scraper
2. ✅ Log in to the platform and navigate to the scraper dashboard
3. ✅ Enter your target keywords or profile URLs to define your scraping criteria
4. ✅ Customize the scraping settings such as filters and output format
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once the scraping is complete review the extracted data for accuracy
7. ✅ **Export** the data to your preferred format such as CSV or JSON
8. ✅ Use the extracted data for lead generation marketing or research purposes
9. ✅ Adjust your scraping parameters as needed for future projects
10. ✅ Contact support if you encounter any issues or need assistance

### Use Cases 🎯

Lead Generation
🎯 Build targeted email lists for marketing campaigns
🎯 Connect with potential clients or collaborators on **Pinterest**

Market Research
🎯 **Analyze** user profiles to understand industry trends
🎯 Gather data for competitor analysis and strategy development

Recruitment
🎯 **Identify** and contact creative professionals for job opportunities
🎯 Build a database of potential candidates from **Pinterest** profiles

Networking
🎯 Connect with influencers and thought leaders in your niche
🎯 Expand your professional network using **Pinterest** contact information

Content Collaboration
🎯 Reach out to content creators for partnerships
🎯 Discover and connect with like-minded individuals on **Pinterest**

### Why choose us? 💎

The **Pinterest** Email Scraper is designed to provide a seamless and efficient data extraction experience. Our tool is equipped with **advanced** features that ensure accuracy and reliability in every scraping session.

With a **user-friendly** interface, even beginners can quickly learn to use the scraper effectively. We prioritize security and compliance, ensuring that all data is collected ethically and in line with legal standards.

Our team is dedicated to providing **regular** updates to keep the scraper compatible with **Pinterest**'s platform changes. By choosing us, you gain access to a powerful tool that saves time and enhances productivity.

Whether you are a marketer, recruiter, or researcher, our scraper is tailored to meet your specific needs. With excellent customer support and detailed documentation, we ensure that you have all the resources needed to succeed.

Trust the **Pinterest** Email Scraper for your data extraction needs and unlock the potential of **Pinterest** for your business or personal projects.

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

The **Pinterest** Email Scraper is built to handle projects of all sizes, from small-scale data collection to **large-scale** scraping operations. Its high-speed scraping capabilities ensure that even **extensive** datasets can be processed **efficient**ly.

The tool is designed to scale with your needs, allowing you to customize settings for specific projects or industries. Whether you are extracting data from a few profiles or thousands, the scraper delivers consistent and accurate results.

Our robust infrastructure supports simultaneous scraping tasks, enabling users to manage multiple projects without delays. With regular updates and optimizations, the scraper remains reliable as your data extraction requirements grow.

The **Pinterest** Email Scraper is the ideal solution for businesses and individuals looking to scale their data collection efforts on **Pinterest**.

### **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
⚖️ **Ensure** compliance with **Pinterest**s terms of service when using the scraper
⚖️ **Use** the extracted data only for ethical and legal purposes
⚖️ **Obtain** user consent before contacting them using scraped email addresses
⚖️ **Avoid** scraping sensitive or private information from **Pinterest** profiles
⚖️ **Do not** use the scraper for spamming or unsolicited marketing activities
⚖️ **Adhere** to data protection regulations such as GDPR or CCPA when handling extracted data
⚖️ **Use** the scraper responsibly to maintain the integrity of **Pinterest**s platform
⚖️ Regularly review legal guidelines to stay updated on data scraping regulations

### 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 the Pinterest **Email Scraper**?

The Pinterest Email Scraper is a tool designed to extract email addresses and other data from Pinterest profiles for marketing, networking, or research purposes.

#### How does the scraper work?

The scraper uses advanced algorithms to collect **publicly available** data from Pinterest profiles based on your specified criteria.

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

**Yes**, the scraper is legal when used in **compliance** with Pinterest's terms of service and data protection regulations.

#### What data can I **extract** using this tool?

You can extract email addresses, usernames, profile URLs, follower counts, bio information, website links, location data, and profile images.

#### Can I customize the scraping process?

**Yes**, the scraper allows you to customize settings such as filters, keywords, and output formats to meet your specific needs.

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

**Yes**, the Pinterest Email Scraper is designed to handle both small and large-scale data extraction tasks efficiently.

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

You can export the data in multiple formats, such as **CSV** or **JSON**, for easy integration with other tools or systems.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Email Scraper",
        "description": "Pinterest Email Scraper helps you collect business and creator emails directly from Pinterest accounts. Use the data for social commerce sales, influencer outreach, and supplier communication.",
        "version": "0.1",
        "x-build-id": "Cwb3PaJZbflUsA9eM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~pinterest-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~pinterest-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~pinterest-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```