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

Yelp Email Scraper extracts business emails, contact details, phone numbers, websites, ratings, reviews, addresses, categories, and profile URLs from Yelp listings. Ideal for lead generation, local business research, sales prospecting, marketing campaigns, and data enrichment.

- **URL**: https://apify.com/scrapebridge/yelp-email-scraper.md
- **Developed by:** [Scrape Bridge](https://apify.com/scrapebridge) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Yelp Email Scraper ⚡

Getting emails from Yelp can feel endless—copying contact details one profile at a time doesn’t scale when you need leads fast. **Yelp Email Scraper** automatically collects email addresses associated with your chosen keywords from Yelp profiles, so you can build a targeted yelp email list without manual work. It’s a practical yelp email scraper for sales teams, researchers, and marketers who want to scrape yelp emails at scale and turn public web data into outreach-ready leads.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "network": "Yelp.com",
  "keyword": "founder",
  "title": "No title",
  "description": "No data",
  "url": "https://www.yelp.com/biz/example-business",
  "email": "contact@gmail.com",
  "proxyGroups": ["legacy"],
  "charged_event_name": "result"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Identifies the source network for easier dataset filtering. |
| `keyword` | string | Shows which keyword produced the result, so you can evaluate lead relevance. |
| `title` | string | The title associated with the matched listing/page content. |
| `description` | string | The text used to find the email address (useful for QA and context). |
| `url` | string | The page URL tied to the extracted contact data. |
| `email` | string | The email address extracted from the Yelp-related content. |
| `proxyGroups` | array | Proxy configuration info used for the run (useful for troubleshooting and repeatability). |
| `status` | string | (If your dataset includes run-level status in your workflow.) Helps you spot failed/empty outcomes when integrating exports. |
| `error_message` | string | (If your dataset includes error details in your workflow.) Useful when you need to handle partial runs in automation. |
| `charged_event_name` | string | Indicates the event name used when pushing records (`"result"`). |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["founder", "marketing"],
  "location": "San Francisco, CA",
  "platform": "Yelp",
  "customDomains": ["@gmail.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for (drives which Yelp-related bios and posts are targeted). |
| `location` | ⬜ | Location to filter search results. Leave empty for no location filtering. |
| `platform` | ⬜ | Select platform. This actor supports `Yelp`. |
| `customDomains` | ⬜ | List of email domains to focus on (for example, `@gmail.com` to target those addresses). |
| `maxEmails` | ⬜ | Caps how many emails the scraper will collect before stopping (helps control scraping time and cost). |
| `engine` | ⬜ | Choose scraping engine: `legacy` or `cost-effective`. |
| `↳ proxyConfiguration` | ⬜ | Configure proxies for this Actor (use Apify Proxy if you want built-in proxy routing). |

***

### What It Does

Yelp Email Scraper pulls email contacts from Yelp-related public web content using your keyword and domain targeting.

#### Extracts Yelp contact emails by keyword

You provide `keywords`, and the actor uses them to find email addresses connected to Yelp bios and posts related to those terms. This makes it useful as a yelp business email extractor when you need leads tied to specific niches.

#### Filters to the email domains you actually want

Use `customDomains` to focus on the kinds of email addresses you’re targeting (for example, pulling only `@gmail.com`). This is helpful when you’re using a yelp contact email scraper to build a cleaner yelp email list for outreach.

#### Stops safely when you hit your cap

Set `maxEmails` to control how many emails you want per run. The actor stops once the limit is reached (and higher limits increase the chance of finding more, but don’t guarantee reaching the number).

#### Supports proxy configuration for reliability

The actor includes proxy configuration support so you can run more reliably at scale. If you’re running a bulk yelp email scraping tool campaign, you can tune proxy settings via `proxyConfiguration`.

#### Handles empty/brittle result pages with resilience

When pages return empty results, the actor includes retries and stopping logic so your run can recover when possible and avoid wasting time indefinitely. This makes Yelp Email Scraper a practical option for scrape yelp emails workflows that need consistent output.

Overall, Yelp Email Scraper helps you turn Yelp-related public information into a usable set of email leads—fast.

***

### Why Yelp Email Scraper?

There are plenty of ways to pull data from Yelp—here’s why Yelp Email Scraper stands out.

#### Keyword-and-domain targeting that fits lead workflows

Instead of dumping irrelevant contacts, Yelp Email Scraper is built around your `keywords` and `customDomains`. That means you get results closer to what you’d want in a yelp leads email scraper or yelp email extraction tool workflow.

#### Built-in run controls to keep cost predictable

With `maxEmails`, you can constrain how much work the actor does per run. This is a straightforward way to manage yelp data mining email jobs without losing control of runtime.

#### Resilient behavior for longer batches

The actor uses pagination and stopping rules and includes logic to deal with empty results, so you can attempt larger searches without manually babysitting the process. That’s especially useful when you’re using a yelp email scraper for outreach list building.

***

### Real-World Use Cases

Here's how different teams put Yelp Email Scraper to work:

**Sales Teams**\
A sales manager needs a list of founder and marketing contacts for local businesses in a specific city. They run Yelp Email Scraper with `keywords`, filter with `customDomains`, and set `maxEmails` to match their daily outreach quota—so they can move from prospecting to sending faster.

**Marketing Agencies**\
An agency building campaigns for multiple clients wants yelp business email extractor data that matches niche positioning. They extract emails tied to the client’s keywords and export the dataset into their reporting workflow, reducing time spent on manual prospect research.

**Freelance Researchers**\
A researcher assembling a dataset on local service providers wants repeatable outputs with clear fields like `email`, `url`, and `keyword`. They run Yelp Email Scraper for different keyword groups, then analyze which terms return the most contactable leads.

**Data Analysts & Enrichment Teams**\
An analyst wants to correlate email availability with themes like “founder” or “marketing” across Yelp-related listings. They export results and use `keyword` to segment performance, while `customDomains` helps them evaluate domain patterns.

**Automation Specialists (Developers)**\
A developer integrates the actor into a pipeline that refreshes lead datasets on a schedule. They trigger runs via the Apify API, store the dataset records, and feed `url` + `email` into their downstream enrichment and CRM steps.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to the actor page on Apify: <https://console.apify.com>.
2. **Enter your inputs** — set `keywords` (required), optionally add `location`, `customDomains`, and `maxEmails`.
3. **Pick your engine** — choose `engine` as `legacy` or `cost-effective` depending on your preference.
4. **Configure proxies (optional)** — use `proxyConfiguration` if you need more reliable large-batch runs.
5. **Start the run and watch the live log** — monitor progress as records are pushed to the dataset.
6. **Open the Dataset tab** — view results immediately as they appear.
7. **Export in your preferred format** — download from the Apify dashboard as JSON, CSV, or Excel.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Yelp Email Scraper fits directly into your existing workflow.

You can export the dataset from the Apify dashboard as JSON, CSV, or Excel. If you’re building a yelp email list for reporting or outreach, this keeps the transition from scraping to analysis smooth.

For automation, you can connect your runs to your stack using Apify’s API access patterns, webhook-style integrations, and no-code tools like Zapier or Make. This makes it easy to refresh your yelp contact email scraper output on a schedule and push it into your CRM or spreadsheet.

***

### Pricing

Yelp Email Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier usage typically includes `$5` platform credits on sign-up, enough for several real test runs.

For heavier workloads, you can scale using Apify’s pay-as-you-go model billed per Actor compute unit (CU). For current subscription options and limits, check the Apify pricing page and upgrade when your projects require more throughput.

Start free at <https://apify.com> — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Pagination across multiple result pages | Continues searching through pages until it hits stop conditions. |
| Empty result pages | Includes retries and stopping logic to avoid endless runs. |
| Email limits | Stops once `maxEmails` is reached to keep runs bounded. |
| Proxy configuration support | You can provide `proxyConfiguration` for more reliable runs. |
| Partial progress | Records are pushed as they’re found during the run. |

Limitations: Yelp Email Scraper extracts emails from publicly available Yelp-related content. It can only collect emails that appear in the accessible public text it targets; if there are few or no matching emails for your `keywords` and `customDomains`, you may see low results. Private or login-gated content is not accessible via this actor.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes, Apify offers a free tier so you can test Yelp Email Scraper without a credit card. You’ll get platform credits to run your first jobs and validate output quality.

#### Do I need to log in or create an account on Yelp?

No. Yelp Email Scraper is designed to work with publicly available sources and doesn’t require you to provide login credentials.

#### How accurate is the extracted data?

Accuracy depends on what email addresses are actually present in the public content the actor reads. Yelp Email Scraper extracts email addresses and stores them with context fields like `description`, `title`, and `url`.

#### How many results can I get per run?

You control output size with `maxEmails`. The actor will stop once the limit is reached, and it may return fewer emails if matching contacts are not found.

#### How fresh is the data?

Results reflect what’s publicly visible when you run the actor. If Yelp content changes, subsequent runs can return different sets of emails.

#### Is this legal? Does it comply with GDPR / CCPA?

This actor uses publicly available data, but whether your use complies with GDPR, CCPA, and applicable spam/direct marketing rules is your responsibility. Use the data ethically and only for lawful purposes.

#### Can I export to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, then import into Google Sheets or your preferred tool.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify actors to run automatically using Apify’s scheduling options. This is useful if you want to refresh a yelp email list on a regular cadence.

#### Can I access results via the API?

Yes. You can trigger runs programmatically and access dataset outputs using Apify’s API capabilities.

#### What happens when the actor encounters an error?

If pages return empty or fail, the actor includes retries and stopping logic to keep runs resilient. If pushing individual records fails for any reason, those errors are logged so you can diagnose and rerun if needed.

***

### Get Help & Use Responsibly

Got a question about Yelp Email Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>, and we’ll help. We’re happy to hear ideas like additional output fields for analytics or improved filtering options for different outreach workflows.

***

**Yelp Email Scraper collects publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You’re responsible for using the results in compliance with GDPR, CCPA, platform Terms of Service, and all applicable local regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

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

Select platform.

## `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.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Yelp",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebridge/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",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Email Scraper",
        "description": "Yelp Email Scraper extracts business emails, contact details, phone numbers, websites, ratings, reviews, addresses, categories, and profile URLs from Yelp listings. Ideal for lead generation, local business research, sales prospecting, marketing campaigns, and data enrichment.",
        "version": "0.0",
        "x-build-id": "aWUDF1r30jrm0MIWL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebridge~yelp-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebridge-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/scrapebridge~yelp-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebridge-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/scrapebridge~yelp-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebridge-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": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Yelp"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Yelp"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
