# Yelp Email Scraper Fast Advanced And Cheapest (`solid-scraper/yelp-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Yelp Email Scraper Fast Advanced & Cheapest extracts verified emails from Yelp for targeted lead gen. Save time, find local businesses fast, and boost outreach with affordable accuracy. 🚀 Ideal for sales teams & agencies.

- **URL**: https://apify.com/solid-scraper/yelp-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 - Fast, Advanced and Cheapest 📬

**Yelp Email Scraper - Fast, Advanced and Cheapest** is an Apify actor designed to extract email addresses from Yelp using the keywords and filters you choose. If you’re trying to **extract yelp business emails** for outbound campaigns, build a **yelp lead scraper** workflow, or find a **yelp contact email finder** for local outreach, this tool automates the heavy lifting so you can focus on converting leads. Whether you're a marketer, sales operator, or researcher, it helps turn public Yelp profiles into a usable email list—saving you hours of manual work.

---

### Why choose Yelp Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
|---|---|
| ✅ Keyword + domain filtering | Use targeted terms and email domains (like `@gmail.com`) to improve lead relevance |
| ✅ Location support | Narrow results to a specific location when you want a region-focused yelp business email database |
| ✅ Duplicate protection | Avoid re-collecting the same email across the run using an internal “seen emails” set |
| ✅ Reliability-oriented scraping behavior | Uses built-in pagination and stop conditions to keep runs efficient |
| ✅ Structured dataset output | Pushes consistent rows with `keyword`, `title`, `description`, `url`, and `email` for easy analysis |
| ✅ Scale-ready automation | Works with multiple keywords × multiple email domains, collecting up to your requested max |

---

### Key features

- 🔎 **Email extraction from publicly available sources**: Extracts email addresses from Yelp based on your selected keywords and email-domain filters  
- 🧩 **Flexible input for lead targeting**: Choose keywords, optional `location`, and a list of `customDomains` to shape results for your **bulk yelp email scraper** use case  
- 🛡️ **Duplicate-aware collection**: Keeps a “seen emails” memory so results stay unique across the run  
- 🔄 **Runs efficiently with stop conditions**: Stops when your `maxEmails` is reached (or when results stop yielding new emails)  
- 💾 **Incremental dataset saving**: Pushes each found email record into the dataset as it’s discovered  
- 📊 **Clean, table-friendly output**: Produces rows designed for table display and downstream export into JSON/CSV workflows  
- 🌐 **Multi-keyword coverage**: Iterates across your keywords and custom domains to support **yelp sales leads email** discovery at scale  

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "San Francisco, CA",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
````

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `keywords` | ✅ Yes | A list of keywords or queries to search for on Yelp (e.g., job titles like “manager” or “founder”) |
| `location` | ❌ No | Location to filter results. Leave empty if you don’t want location constraints |
| `customDomains` | ❌ No | A list of email domains to prefer (e.g., `@gmail.com`, `@yahoo.com`). Used to guide which emails are captured |
| `maxEmails` | ❌ No | Maximum number of unique emails to collect. The scraper stops once this limit is reached. Higher limits can take longer and still don’t guarantee reaching the exact number |

***

### Output

The actor saves the scraped results into the **Yelp Emails Dataset** in JSON format (pushed incrementally during the run).

Sample output row:

```json
{
  "network": "Yelp.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | The source network label (always `Yelp.com`) |
| `keyword` | string | The keyword currently being used for extraction |
| `title` | string | The result title text associated with the found item |
| `description` | string | Text extracted from the item content where the email was found |
| `url` | string | The link associated with the found item |
| `email` | string | The extracted email address |
| `error_message` | ❌ Not provided | This actor’s dataset rows (as defined by the pushed fields) do not include an `error_message` field |

> Export tip: after the run, you can export the dataset to **JSON or CSV** from the Apify Console output tab.

***

### How to use Yelp Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and open the Actors area.

2. **Find the actor**\
   Search for **Yelp Email Scraper - Fast, Advanced and Cheapest** and open its details page.

3. **Go to the Input section**\
   Use the built-in form (or upload an `input.json`) to configure your extraction.

4. **Set your `keywords`**\
   Enter a list like `["manager", "founder"]` depending on the kind of leads you want—this is the primary driver for **yelp lead scraper** results.

5. **Optionally set `location`**\
   If you want **local business yelp email list** results for a specific area, add a location. Leave blank for broader coverage.

6. **Optionally set `customDomains`**\
   Provide email domains you want to prioritize (for example `@gmail.com`, `@yahoo.com`). This is central to **yelp contact email finder** targeting.

7. **Optionally set `maxEmails`**\
   Set the maximum number of unique emails to collect. The run stops when the limit is reached (or earlier if results stop producing new emails).

8. **Run and monitor logs**\
   During execution, you’ll see progress in the logs and records being pushed into the dataset incrementally.

9. **Open the dataset and export**\
   After completion, open the **Yelp Emails Dataset** in the OUTPUT tab and export your results (JSON/CSV).

No coding required—get accurate results in minutes with **Yelp Email Scraper - Fast, Advanced and Cheapest**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for better lead relevance**: **Yelp Email Scraper - Fast, Advanced and Cheapest** is designed to work best when you use targeted keywords and specific email domains (like `@gmail.com`)—ideal for “extract yelp business emails” workflows.
- ✅ **Input normalization for keywords**: If `keywords` is passed as a string, it will be normalized into a list internally (so you can pass a single keyword without breaking the run).
- 🧾 **Real-time structured saving**: Each discovered lead row is pushed immediately, helping you avoid losing progress in longer runs used for **yelp outreach email list builder** pipelines.
- 🕒 **Efficient stopping behavior**: The actor stops once your requested `maxEmails` is reached or when it determines it’s no longer finding new emails—helpful for controlling scraping time.

***

### Best use cases

- 📈 **Sales teams building local outbound**: Collect a **yelp outreach email list builder** dataset of yelp sales leads email contacts for faster prospecting
- 🗺️ **Regional lead generation**: Use `location` + keyword targeting to create a local business yelp email list for specific markets
- 🧑‍💼 **Founder and manager prospecting**: Use job-title style keywords (e.g., “manager”, “founder”) to find decision-maker emails with a yelp email extraction tool approach
- 🏪 **Location-based research**: Compare contact email availability across niches by exporting the dataset and analyzing coverage by keyword and domain
- 🧰 **CRM enrichment pipelines**: Feed the resulting JSON rows (keyword, title, url, email) into an ETL process to enrich contacts automatically
- 🧾 **B2B list building**: Prefer business domains by configuring `customDomains` to strengthen a yelp business email database for outreach sequences

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` (array of strings)
  - ✅ `location` (string)
  - ✅ `customDomains` (array of strings like `@gmail.com`)
  - ✅ `maxEmails` (integer; supports values up to `10000`)

- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping (configuration is handled by the actor)

- **Retry Mechanism**
  - ✅ Includes resilience logic and stop conditions for efficiency during multi-page scraping

- **Dataset Structure**
  - ✅ Dataset: **Yelp Emails Dataset**
  - ✅ Rows are pushed with: `keyword`, `title`, `description`, `url`, `email` (plus `network` in the pushed row)

- **Rate Limits & Performance**
  - ✅ Performance depends on the size of your keyword/domain combinations and your `maxEmails` limit
  - ✅ Larger limits can take longer, and results don’t always reach the target count

- **Limitations**
  - ❌ Results depend on what emails are publicly available and discoverable from the extracted pages/content
  - ❌ If no new emails are being found, the actor may stop before reaching `maxEmails`

***

### FAQ

#### How do I get the best results with Yelp Email Scraper - Fast, Advanced and Cheapest?

✅ For best accuracy, use targeted `keywords` (like role titles) and set `customDomains` to the email types you want (for example `@gmail.com`). If you get limited results, broaden keywords, add related terms, or include more email domains.

#### Do I need to provide a location?

❌ No. `location` is optional. If you want a region-specific yelp lead scraper workflow, add a location; otherwise, leave it empty to allow broader coverage for your yelp business email database.

#### What does `maxEmails` mean?

🎯 `maxEmails` is the maximum number of emails the scraper will collect. The actor stops once the limit is reached, but it does not guarantee that it will reach the requested number—results depend on what’s available.

#### Is the output data saved incrementally?

✅ Yes. As emails are found, the actor pushes each result row to the dataset immediately, which helps for longer runs and reduces the risk of losing progress.

#### What fields will I get in the dataset?

✅ Each pushed row includes `network`, `keyword`, `title`, `description`, `url`, and `email`. The dataset is designed to be table-friendly and easy to export.

#### Can I use this for bulk yelp email scraper or automated lead generation?

✅ Yes. The actor is built for automation and supports multiple keywords and multiple `customDomains`, making it suitable for building a bulk yelp email scraper dataset for CRM import and outreach.

#### What about data removal or correction requests?

If you need assistance related to data removal or changes, contact <dataforleads@gmail.com>.

***

### Support & feature requests

Have questions or want to improve your **Yelp Email Scraper - Fast, Advanced and Cheapest** setup? We’d love to hear from you.

- 💡 **Feature Requests**: Suggest enhancements like custom export formats, additional dataset fields, or improved email filtering logic for yelp outreach email list builder workflows.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this Yelp email extraction tool.

***

- *Yelp Email Scraper - Fast, Advanced and Cheapest is the most comprehensive, SEO-optimized way to build a high-signal email list from Yelp at scale.*
- *Get started now and turn public web data into actionable outreach leads.*

***

### Disclaimer

This tool only accesses **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content.

It is the user’s responsibility to comply with applicable laws and regulations (for example, GDPR and CCPA), as well as platform terms of service and spam/anti-abuse requirements. Always use **Yelp Email Scraper - Fast, Advanced and Cheapest** responsibly, ethically, and for legitimate purposes.

For data removal requests, contact <dataforleads@gmail.com>.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/yelp-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/yelp-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call solid-scraper/yelp-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Yelp Email Scraper Fast Advanced & Cheapest extracts verified emails from Yelp for targeted lead gen. Save time, find local businesses fast, and boost outreach with affordable accuracy. 🚀 Ideal for sales teams & agencies.",
        "version": "1.0",
        "x-build-id": "PlW92hi0JVGOY4lbd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~yelp-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-yelp-email-scraper-fast-advanced-and-cheapest",
                "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/solid-scraper~yelp-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-yelp-email-scraper-fast-advanced-and-cheapest",
                "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/solid-scraper~yelp-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-yelp-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
