# Yelp Scraper — Business Reviews, Ratings & Contact Info (`junipr/yelp-scraper`) Actor

Scrape Yelp business listings by search query and location. Extract reviews, ratings, contact info, hours, photos, and more. Filter by category, price range, and rating. Export structured JSON data.

- **URL**: https://apify.com/junipr/yelp-scraper.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.60 / 1,000 business scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Business Scraper

The first dedicated Yelp scraping tool on Apify. Extract complete business data from Yelp including reviews, business hours, menus, photos, amenities, and contact information. Search by location, category, price level, or provide direct business URLs for targeted extraction.

### What can it do?

Yelp Business Scraper lets you extract structured data from any Yelp business listing at scale. Key capabilities:

- **Location-based search** — Search by city, state, ZIP code, or geographic coordinates with configurable radius
- **Category filtering** — Filter by Yelp category aliases (restaurants, plumbers, dentists, etc.)
- **Review extraction** — Pull reviews with author info, ratings, dates, reaction counts, and owner responses
- **Menu data** — Extract full restaurant menus with item names, prices, and descriptions
- **Business hours** — Get weekly schedules in structured format
- **Photo URLs** — Collect business photo URLs from listings
- **Amenities and highlights** — Delivery, takeout, parking, Wi-Fi, outdoor seating, and more
- **Price and sort filters** — Filter by price level ($-$$$$) and sort by rating, review count, or distance
- **Closed business detection** — Flags permanently closed businesses automatically

### What data can you extract from Yelp?

| Field | Description |
|-------|-------------|
| `name` | Business name |
| `phone` | Phone number |
| `website` | Business website URL |
| `address` | Full structured address (street, city, state, ZIP, country) |
| `coordinates` | Latitude and longitude |
| `rating` | Average star rating (1-5) |
| `reviewCount` | Total number of reviews |
| `priceRange` | Price level ($, $$, $$$, $$$$) |
| `categories` | Business categories with aliases |
| `hours` | Weekly business hours (open/close times) |
| `photos` | Photo URLs from the business page |
| `menu` | Menu sections with items, prices, descriptions |
| `reviews` | Individual reviews with author, rating, date, text, reactions |
| `amenities` | Delivery, takeout, parking, Wi-Fi, and more |
| `highlights` | Business highlights (Outdoor Seating, Accepts Credit Cards, etc.) |
| `ratingDistribution` | Breakdown of reviews by star level |
| `neighborhoods` | Neighborhood names |
| `isClaimed` | Whether the business is claimed on Yelp |
| `permanentlyClosed` | Whether the business is permanently closed |

### How to use

1. **Search by location** — Enter a search term and location to find businesses:
```json
{
  "searchTerms": ["pizza"],
  "location": "San Francisco, CA",
  "maxBusinesses": 50
}
````

2. **Scrape specific businesses** — Provide direct Yelp URLs:

```json
{
  "businessUrls": [
    "https://www.yelp.com/biz/joes-pizza-new-york",
    "https://www.yelp.com/biz/tartine-bakery-san-francisco"
  ]
}
```

3. **Filter by category and price** — Narrow results to specific business types:

```json
{
  "searchTerms": ["restaurants"],
  "location": "Chicago, IL",
  "category": "italian",
  "priceFilter": [2, 3],
  "includeMenu": true
}
```

### Pricing

This actor uses pay-per-event pricing at **$2.60 per 1,000 businesses** ($0.0026 per business). You only pay for successfully scraped businesses — failed requests, 404s, and blocked pages are never charged.

Pricing includes all platform compute costs — no hidden fees.

**Cost examples:**

- 100 businesses for lead gen: $0.30
- 1,000 restaurant listings with reviews: $3.00
- 5,000 businesses for market research: $15.00

For lead generation, extracting 1,000 local business contacts (name, phone, website, address) costs just $3.00 — far less than manual research or enterprise data providers.

### Proxy Requirements

This actor requires residential proxies because Yelp blocks datacenter IP addresses.

- **Paid Apify plan users**: Works automatically with the default residential proxy configuration.
- **Free plan users**: Provide your own residential proxy URL in the Proxy Configuration input field.
- Without a residential proxy, the actor will exit with a clear error message.

### Input and Output examples

**Input:**

```json
{
  "searchTerms": ["best pizza"],
  "location": "New York, NY",
  "maxBusinesses": 10,
  "includeReviews": true,
  "maxReviews": 5,
  "includePhotos": true,
  "includeHours": true
}
```

**Output (single business):**

```json
{
  "url": "https://www.yelp.com/biz/joes-pizza-new-york",
  "businessId": "joes-pizza-new-york",
  "name": "Joe's Pizza",
  "phone": "+12123661182",
  "website": "https://www.joespizzanyc.com",
  "address": {
    "street": "7 Carmine St",
    "city": "New York",
    "state": "NY",
    "zipCode": "10014",
    "country": "US",
    "full": "7 Carmine St, New York, NY 10014"
  },
  "rating": 4.5,
  "reviewCount": 8234,
  "priceRange": "$$",
  "categories": [
    { "alias": "pizza", "title": "Pizza" }
  ],
  "hours": {
    "monday": { "open": "10:00", "close": "02:00" },
    "tuesday": { "open": "10:00", "close": "02:00" }
  },
  "reviews": [
    {
      "author": "Mike S.",
      "rating": 5,
      "date": "2026-02-18",
      "text": "Best pizza in NYC, hands down..."
    }
  ],
  "scrapedAt": "2026-03-11T12:00:00.000Z"
}
```

### Related scrapers by Junipr

- [Yellow Pages Scraper](https://apify.com/junipr/yellow-pages-scraper) — Extract business listings from Yellow Pages
- [Google News Scraper](https://apify.com/junipr/google-news-scraper) — Scrape Google News articles by topic or keyword
- [Contact Info Scraper](https://apify.com/junipr/contact-info-scraper) — Extract emails, phones, and social links from any website
- [Trustpilot Reviews Scraper](https://apify.com/junipr/trustpilot-reviews-scraper) — Scrape Trustpilot business reviews

### FAQ

#### How much does it cost to scrape Yelp?

The actor charges $2.60 per 1,000 businesses scraped. You only pay for successful extractions — blocked requests, 404 errors, and empty results are free. A typical lead generation run of 100 businesses costs about $0.26.

#### Can I get Yelp restaurant menus?

Yes. Set `includeMenu` to `true` in the input. Menu items are extracted with name, price, and description, organized by menu section. Not all restaurants have menus listed on Yelp — when no menu is available, the field returns `null`.

#### Does it extract phone numbers and emails?

Phone numbers are extracted from every business listing that has one. Email addresses are not typically displayed on Yelp business pages, so the `email` field will usually be `null`. For email extraction, combine this actor with our Contact Info Scraper using the extracted website URL.

#### Can I filter by location and category?

Yes. Use the `location` field for city/state/ZIP searches and `category` for Yelp category aliases like "restaurants", "plumbers", or "dentists". You can also use latitude/longitude coordinates with a radius for precise geographic targeting.

#### Is scraping Yelp legal?

Yelp business information (names, addresses, phone numbers, ratings, categories, hours) is publicly available data. However, republishing full review text at scale may raise copyright concerns since reviews are authored by users and licensed to Yelp. We recommend using structured data (ratings, categories, contact info) for lead generation and competitive analysis, and exercising caution with full review text republication. Users are responsible for complying with applicable laws and Yelp's terms of service.

#### How do I use Yelp data for lead generation?

Search by business category and location to build targeted prospect lists. Extract phone numbers, websites, and addresses for outreach. Filter by rating and review count to identify established businesses, or by low review count to find businesses that might benefit from your services. Export to CSV for CRM import.

# Actor input Schema

## `searchTerms` (type: `array`):

Search keywords to find businesses on Yelp (e.g. "pizza", "plumber", "dentist"). Provide at least one search term with a location, or use direct business URLs instead.

## `businessUrls` (type: `array`):

Direct Yelp business page URLs to scrape (e.g. "https://www.yelp.com/biz/joes-pizza-new-york"). Use this instead of search terms to scrape specific businesses.

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

Location to search in (e.g. "San Francisco, CA", "Chicago, IL", "10001"). Required when using search terms.

## `latitude` (type: `number`):

Center latitude for geo-based search. Use with longitude instead of location text.

## `longitude` (type: `number`):

Center longitude for geo-based search. Use with latitude instead of location text.

## `radiusMiles` (type: `number`):

Search radius in miles from the center point when using coordinates.

## `maxBusinesses` (type: `integer`):

Maximum number of businesses to extract from search results.

## `includeReviews` (type: `boolean`):

Extract reviews for each business. Each business page shows up to 10 reviews by default.

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per business. Only visible (non-filtered) reviews are extracted.

## `includePhotos` (type: `boolean`):

Extract photo URLs from each business page.

## `includeMenu` (type: `boolean`):

Extract menu items for restaurants. Only works for businesses that have a menu on Yelp.

## `includeHours` (type: `boolean`):

Extract business hours for each day of the week.

## `sortBy` (type: `string`):

Sort order for search results.

## `priceFilter` (type: `array`):

Filter by price level. 1 = $, 2 = $$, 3 = $$$, 4 = $$$$. Leave empty for all price levels.

## `openNow` (type: `boolean`):

Only return businesses that are currently open.

## `category` (type: `string`):

Filter by Yelp category alias (e.g. "restaurants", "plumbers", "dentists"). See Yelp's category list for valid aliases.

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

Residential proxy is recommended — Yelp blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "searchTerms": [
    "restaurants"
  ],
  "businessUrls": [],
  "location": "New York, NY",
  "latitude": 0,
  "longitude": 0,
  "radiusMiles": 10,
  "maxBusinesses": 100,
  "includeReviews": true,
  "maxReviews": 10,
  "includePhotos": true,
  "includeMenu": false,
  "includeHours": true,
  "sortBy": "best_match",
  "priceFilter": [],
  "openNow": false,
  "category": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Yelp business listings with full details including reviews, hours, photos, menus, and amenities.

# 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 = {
    "searchTerms": [
        "restaurants"
    ],
    "location": "New York, NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/yelp-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 = {
    "searchTerms": ["restaurants"],
    "location": "New York, NY",
}

# Run the Actor and wait for it to finish
run = client.actor("junipr/yelp-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 '{
  "searchTerms": [
    "restaurants"
  ],
  "location": "New York, NY"
}' |
apify call junipr/yelp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Scraper — Business Reviews, Ratings & Contact Info",
        "description": "Scrape Yelp business listings by search query and location. Extract reviews, ratings, contact info, hours, photos, and more. Filter by category, price range, and rating. Export structured JSON data.",
        "version": "1.0",
        "x-build-id": "7pHY0Kw0gnnkA2LcJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~yelp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-yelp-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/junipr~yelp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-yelp-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/junipr~yelp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-yelp-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Search keywords to find businesses on Yelp (e.g. \"pizza\", \"plumber\", \"dentist\"). Provide at least one search term with a location, or use direct business URLs instead.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "restaurants"
                        ]
                    },
                    "businessUrls": {
                        "title": "Business URLs",
                        "type": "array",
                        "description": "Direct Yelp business page URLs to scrape (e.g. \"https://www.yelp.com/biz/joes-pizza-new-york\"). Use this instead of search terms to scrape specific businesses.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search in (e.g. \"San Francisco, CA\", \"Chicago, IL\", \"10001\"). Required when using search terms.",
                        "default": "New York, NY"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Center latitude for geo-based search. Use with longitude instead of location text.",
                        "default": 0
                    },
                    "longitude": {
                        "title": "Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Center longitude for geo-based search. Use with latitude instead of location text.",
                        "default": 0
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "number",
                        "description": "Search radius in miles from the center point when using coordinates.",
                        "default": 10
                    },
                    "maxBusinesses": {
                        "title": "Max Businesses",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of businesses to extract from search results.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract reviews for each business. Each business page shows up to 10 reviews by default.",
                        "default": true
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Business",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per business. Only visible (non-filtered) reviews are extracted.",
                        "default": 10
                    },
                    "includePhotos": {
                        "title": "Include Photos",
                        "type": "boolean",
                        "description": "Extract photo URLs from each business page.",
                        "default": true
                    },
                    "includeMenu": {
                        "title": "Include Menu",
                        "type": "boolean",
                        "description": "Extract menu items for restaurants. Only works for businesses that have a menu on Yelp.",
                        "default": false
                    },
                    "includeHours": {
                        "title": "Include Hours",
                        "type": "boolean",
                        "description": "Extract business hours for each day of the week.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "best_match",
                            "rating",
                            "review_count",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "best_match"
                    },
                    "priceFilter": {
                        "title": "Price Filter",
                        "type": "array",
                        "description": "Filter by price level. 1 = $, 2 = $$, 3 = $$$, 4 = $$$$. Leave empty for all price levels.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 4
                        },
                        "default": []
                    },
                    "openNow": {
                        "title": "Open Now",
                        "type": "boolean",
                        "description": "Only return businesses that are currently open.",
                        "default": false
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter by Yelp category alias (e.g. \"restaurants\", \"plumbers\", \"dentists\"). See Yelp's category list for valid aliases.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended — Yelp blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
