# Yelp Email Scraper (`api-empire/yelp-email-scraper`) Actor

Automate email extraction from Yelp with Yelp Email Scraper. The actor scans business listings and pulls available contact emails into structured datasets. Perfect for CRM enrichment and automated lead pipelines.

- **URL**: https://apify.com/api-empire/yelp-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 3 total users, 0 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

### **Yelp** Email Scraper 📱

**Yelp** Email Scraper allows users to **extract** a wide range of **data** from **Yelp** business listings. This includes essential **contact** information such as email addresses, phone numbers, and website links.

The tool also retrieves business names, categories, and location details, providing a comprehensive **data**set for analysis or outreach. By automating the **data** **extract**ion process, **Yelp** Email Scraper saves time and ensures accuracy, making it an invaluable tool for businesses and marketers.

It is designed to handle large-scale **data** scraping tasks while maintaining high precision and reliability. With this tool, you can gather actionable insights and build robust **contact** **data**bases for your marketing or research needs.

Yelp Email Scraper is a powerful tool designed to help you extract email addresses and other contact information from Yelp business listings efficiently. It simplifies the process of gathering leads and building contact databases for your business or marketing campaigns.

With Yelp Email Scraper, you can automate the extraction of valuable data from Yelp, saving you time and effort. This tool is perfect for businesses looking to connect with potential clients or partners listed on Yelp.

Yelp is a treasure trove of business information, and this scraper ensures you can access the data you need without manual effort. It is a reliable and efficient solution for data extraction from Yelp's vast directory.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extract email addresses associated with Yelp business listings. |
| Business Name | Retrieve the names of businesses listed on Yelp. |
| Phone Number | Collect phone numbers provided by businesses on Yelp. |
| Website URL | Extract website links listed on business profiles. |
| Business Category | Identify the category or industry of each business. |
| Address | Retrieve the physical address of businesses listed on Yelp. |
| Ratings and Reviews | Gather ratings and review counts for businesses. |
| Operating Hours | Extract the hours of operation listed by businesses. |

### Key Features of **Yelp** Email Scraper

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

- ⭐ Automates the extraction of email addresses and contact details from **Yelp**
- ⭐ Supports bulk data scraping for large-scale lead generation campaigns
- ⭐ Provides accurate and up-to-date business information including emails and phone numbers
- ⭐ **Customizable** search parameters to target specific industries or locations
- ⭐ User-friendly interface for ease of use even for non-technical users
- ⭐ **High**-speed data scraping to save time and maximize efficiency
- ⭐ Exports data in multiple formats such as CSV or JSON for easy integration
- ⭐ Offers advanced filtering options to refine search results and extract relevant data
- ⭐ Ensures compliance with legal and ethical data scraping practices
- ⭐ **Regular** updates to maintain compatibility with **Yelp**s platform

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

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

1. ✅ **Sign up** or **log in**to the **Yelp** Email Scraper platform
2. ✅ Enter your target keywords or business categories in the search field
3. ✅ Specify the location or region you want to target for data extraction
4. ✅ Customize additional filters such as ratings reviews or business categories if needed
5. ✅ **Start** the scraping process by clicking the Extract Data button
6. ✅ Wait for the tool to collect the required data from **Yelp** listings
7. ✅ **Review** the extracted data in the preview panel to ensure accuracy
8. ✅ **Export** the data to your preferred format such as CSV or JSON for further use
9. ✅ Use the extracted data for marketing research or lead generation purposes
10. ✅ Repeat the process as needed for different categories or locations

### Use Cases 🎯

Lead Generation
🎯 Extract email addresses and contact details for potential clients
🎯 Build a targeted email list for marketing campaigns

Market Research
🎯 **Analyze** business categories and locations for market trends
🎯 Gather data to understand competitor distribution and presence

Business Outreach
🎯 **Identify** and contact potential business partners on **Yelp**
🎯 Expand your professional network by reaching out to businesses

Data Enrichment
🎯 Enhance existing databases with updated email and contact information
🎯 Verify and validate business details for accuracy

### Why choose us? 💎

**Yelp** Email Scraper stands out as a **reliable** and efficient tool for data extraction from **Yelp**. Our platform is designed to simplify the process of gathering business information, making it accessible to users of all technical backgrounds.

With its **user-friendly** interface and **advanced** features, you can extract data quickly and accurately. We prioritize data quality and ensure that the information you collect is up-to-date and relevant.

Our tool is highly customizable, allowing you to tailor your searches to specific industries, locations, or criteria. Unlike other **Yelp** scraping software, our solution is optimized for speed and scalability, making it suitable for both small businesses and large enterprises.

We also ensure compliance with legal and ethical standards, so you can use our tool with confidence. Whether you're looking to generate leads, conduct market research, or enrich your business data, **Yelp** Email Scraper is the perfect choice.

Trust our **reliable** and efficient tool to help you achieve your business goals.

### **Yelp** Email Scraper Scalability 📈

**Yelp** Email Scraper is designed to handle data extraction tasks of any size, making it a scalable solution for businesses of all types. Whether you need to extract a few dozen contacts or thousands of business details, our tool can handle the workload **efficient**ly.

With **advanced** algorithms and optimized performance, **Yelp** Email Scraper ensures fast and accurate data collection, even for **large-scale** projects. The tool is built to accommodate growing business needs, allowing you to expand your data extraction efforts as your requirements evolve.

By offering **customizable** search parameters and export options, our solution provides the flexibility needed to scale your operations **seamless**ly. Trust **Yelp** Email Scraper to grow with your business and support your data-driven strategies.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Yelp**s terms of service when using the **Yelp** Email Scraper
⚖️ **Do not** use the extracted data for spamming or unsolicited communications
⚖️ Verify the accuracy of the extracted data before using it for business purposes
⚖️ **Obtain** proper consent before contacting individuals or businesses via email
⚖️ **Use** the tool only for lawful purposes and in accordance with applicable regulations
⚖️ **Avoid** scraping sensitive or confidential information from **Yelp** listings
⚖️ Respect the privacy of businesses and individuals when using the extracted data
⚖️ Regularly review and adhere to changes in **Yelp**s data usage policies

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Yelp Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Yelp",
  "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 (Yelp) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Yelp",
    "keyword": "Yelp 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 Yelp as the source |
| keyword | Keyword that triggered the result (Yelp Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Yelp profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Yelp **Email Scraper**?

Yelp Email Scraper is a tool designed to extract email addresses and other business information from Yelp listings quickly and efficiently.

#### Can I use Yelp **Email Scraper** for **lead generation**?

**Yes**, Yelp Email Scraper is ideal for generating leads by extracting contact details from Yelp business listings.

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

You can extract email addresses, phone numbers, business names, website URLs, categories, addresses, ratings, and operating hours.

#### Is Yelp **Email Scraper** easy to use?

**Yes**, Yelp Email Scraper features a **user-friendly** interface that makes it accessible to users of all technical levels.

#### Can I customize my data **extract**ion parameters?

**Yes**, you can customize search parameters such as location, category, and additional filters to refine your results.

#### Is the **extract**ed data accurate?

Yelp Email Scraper is designed to provide accurate and up-to-date data from Yelp listings.

#### In what formats can I **export** the **extract**ed data?

You can export the extracted data in formats like **CSV** or **JSON** for easy integration and analysis.

#### Is Yelp **Email Scraper** compliant with **legal** guidelines?

**Yes**, the tool is designed to comply with legal and ethical data scraping practices, but users must also adhere to Yelp's terms of service.

#### Can I scrape data from multiple locations simultaneously?

**Yes**, Yelp Email Scraper supports multi-location data extraction to save time and effort.

#### Is there a **limit** to the amount of data I can scrape?

The tool is scalable and can handle large-scale data extraction tasks, but users should ensure **compliance** with applicable regulations.

# Actor input Schema

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

📌 Enter search terms like 'marketing', 'founder', 'business'. Each keyword is searched separately — add as many as you need! 🎯

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

📍 Select the platform to scrape. Currently: **Yelp** — more platforms coming soon! 🚀

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

🌍 Optional: Narrow results by city/region (e.g. London, New York, San Francisco). Leave empty for global search 🌎

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

✉️ Optional: Filter emails by domain (e.g. @gmail.com, @outlook.com). Leave empty to collect from all domains 📬

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

🎯 Limit emails per keyword (1–5000). Control run size & cost. Default: 5 ✨

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

🔧 **Legacy:** GOOGLE\_SERP proxy with 3 retries — reliable & optimized for Google on Apify 🛡️

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

🌐 Uses GOOGLE\_SERP proxy (3 retries). Custom config optional — leave default for best results ✅

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "business"
  ],
  "platform": "Yelp",
  "location": "",
  "emailDomains": [
    ""
  ],
  "maxEmails": 5,
  "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": [
        "founder",
        "business"
    ],
    "emailDomains": [
        ""
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/yelp-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": [
        "founder",
        "business",
    ],
    "emailDomains": [""],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/yelp-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": [
    "founder",
    "business"
  ],
  "emailDomains": [
    ""
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/yelp-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Email Scraper",
        "description": "Automate email extraction from Yelp with Yelp Email Scraper. The actor scans business listings and pulls available contact emails into structured datasets. Perfect for CRM enrichment and automated lead pipelines.",
        "version": "0.1",
        "x-build-id": "GnRKxbXdaS4oCtBJa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~yelp-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-yelp-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/api-empire~yelp-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-yelp-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/api-empire~yelp-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-yelp-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": "🔑 Search Keywords",
                        "type": "array",
                        "description": "📌 Enter search terms like 'marketing', 'founder', 'business'. Each keyword is searched separately — add as many as you need! 🎯",
                        "default": [
                            "founder",
                            "business"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "🌐 Target Platform",
                        "enum": [
                            "Yelp"
                        ],
                        "type": "string",
                        "description": "📍 Select the platform to scrape. Currently: **Yelp** — more platforms coming soon! 🚀",
                        "default": "Yelp"
                    },
                    "location": {
                        "title": "📍 Location Filter",
                        "type": "string",
                        "description": "🌍 Optional: Narrow results by city/region (e.g. London, New York, San Francisco). Leave empty for global search 🌎",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "📧 Email Domains Filter",
                        "type": "array",
                        "description": "✉️ Optional: Filter emails by domain (e.g. @gmail.com, @outlook.com). Leave empty to collect from all domains 📬",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "📊 Max Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎯 Limit emails per keyword (1–5000). Control run size & cost. Default: 5 ✨",
                        "default": 5
                    },
                    "engine": {
                        "title": "⚙️ Scraping Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "🔧 **Legacy:** GOOGLE_SERP proxy with 3 retries — reliable & optimized for Google on Apify 🛡️",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Settings",
                        "type": "object",
                        "description": "🌐 Uses GOOGLE_SERP proxy (3 retries). Custom config optional — leave default for best results ✅"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```