# Yelp Business Scraper (`glassventures/yelp-business-scraper`) Actor

Extract business listings, ratings, reviews, contact info, and hours from Yelp. Export to JSON, CSV, Excel.

- **URL**: https://apify.com/glassventures/yelp-business-scraper.md
- **Developed by:** [Glass Ventures](https://apify.com/glassventures) (community)
- **Categories:** AI, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Extract business listings, ratings, reviews, contact info, hours, and location data from Yelp search results and business pages.

### What does Yelp Business Scraper do?

Yelp Business Scraper is a powerful data extraction tool that collects structured business information from Yelp.com. It can scrape search results for any business type in any location, or extract detailed data from individual business pages.

The actor navigates Yelp search results and business detail pages, extracting comprehensive data including business name, rating, review count, price range, categories, full address, phone number, website, GPS coordinates, business hours, photos, and optionally the top reviews. All data is exported in a clean, structured format.

Whether you need restaurant data for market analysis, local business contact info for lead generation, or competitor research data, this scraper handles pagination automatically and delivers results in JSON, CSV, or Excel format.

### Use Cases

- **Market researchers** -- Analyze business density, ratings, and pricing across locations to identify market opportunities
- **Data analysts** -- Build datasets of local businesses for geographic analysis, sentiment analysis, or trend research
- **Business owners** -- Monitor competitors' ratings, review counts, and pricing in your area
- **Lead generation** -- Extract business contact info (phone, website, address) for outreach campaigns
- **Developers** -- Feed Yelp business data into applications, dashboards, or CRM systems via API

### Features

- Search by business type and location (e.g., "pizza" in "Chicago, IL")
- Scrape individual business pages via direct URLs
- Extract JSON-LD structured data for maximum accuracy
- Optional review extraction from business pages
- Automatic pagination through search results
- Proxy support with automatic session rotation
- Handles anti-bot detection with session management
- Exports to JSON, CSV, Excel, or connect via API
- Resume support for interrupted runs

### How much will it cost?

| Results | Estimated Cost |
|---------|---------------|
| 100     | ~$0.50        |
| 1,000   | ~$4.00        |
| 10,000  | ~$35.00       |

| Cost Component | Per 1,000 Results |
|----------------|-------------------|
| Platform compute | ~$1.50 |
| Proxy (residential) | ~$2.50 |
| **Total** | **~$4.00** |

### How to use

1. Go to the Yelp Business Scraper page on Apify Store
2. Click "Start" or "Try for free"
3. Enter search terms (e.g., "restaurants") and locations (e.g., "San Francisco, CA"), or paste Yelp URLs directly
4. Set the maximum number of items to scrape
5. Click "Start" and wait for the results

### Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| startUrls | array | Yelp URLs to scrape (search or business pages) | - |
| searchTerms | array | Business types or keywords to search for | - |
| locations | array | Locations to search in (e.g., "New York, NY") | San Francisco, CA |
| includeReviews | boolean | Extract top reviews from each business page | false |
| maxItems | number | Maximum number of businesses to scrape | 100 |
| maxConcurrency | number | Parallel page processing limit | 8 |
| proxyConfig | object | Proxy settings (residential recommended) | Apify Proxy |

### Output

The actor produces a dataset with the following fields:

```json
{
    "businessName": "House of Prime Rib",
    "url": "https://www.yelp.com/biz/house-of-prime-rib-san-francisco",
    "rating": 4.5,
    "reviewCount": 8234,
    "priceRange": "$$$",
    "categories": ["Steakhouses", "American (Traditional)"],
    "address": "1906 Van Ness Ave",
    "city": "San Francisco",
    "state": "CA",
    "zipCode": "94109",
    "phone": "(415) 885-4605",
    "website": "https://houseofprimerib.net",
    "latitude": 37.7935,
    "longitude": -122.4225,
    "hours": {
        "Monday": "4:00 PM - 10:00 PM",
        "Tuesday": "4:00 PM - 10:00 PM"
    },
    "photos": ["https://s3-media0.fl.yelpcdn.com/bphoto/..."],
    "isOpen": true,
    "claimedStatus": true,
    "scrapedAt": "2026-04-23T10:30:00.000Z"
}
````

| Field | Type | Description |
|-------|------|-------------|
| businessName | string | Name of the business |
| url | string | Yelp business page URL |
| rating | number | Average star rating (1-5) |
| reviewCount | number | Total number of reviews |
| priceRange | string | Price level ($, $$, $$$, $$$$) |
| categories | array | Business categories |
| address | string | Street address |
| city | string | City name |
| state | string | State/region |
| zipCode | string | Postal code |
| phone | string | Phone number |
| website | string | Business website URL |
| latitude | number | Geographic latitude |
| longitude | number | Geographic longitude |
| hours | object | Business hours by day |
| photos | array | Photo URLs |
| isOpen | boolean | Whether the business is currently open |
| claimedStatus | boolean | Whether the business is claimed on Yelp |
| scrapedAt | string | ISO 8601 scrape timestamp |

### Integrations

Connect Yelp Business Scraper with other tools:

- **Apify API** -- REST API for programmatic access
- **Webhooks** -- get notified when a run finishes
- **Zapier / Make** -- connect to 5,000+ apps
- **Google Sheets** -- export directly to spreadsheets

#### API Example (Node.js)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('YOUR_USERNAME/yelp-business-scraper').call({
    searchTerms: ['restaurants'],
    locations: ['San Francisco, CA'],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### API Example (Python)

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('YOUR_USERNAME/yelp-business-scraper').call(run_input={
    'searchTerms': ['restaurants'],
    'locations': ['San Francisco, CA'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### API Example (cURL)

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~yelp-business-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"searchTerms": ["restaurants"], "locations": ["San Francisco, CA"], "maxItems": 100}'
```

### Tips and tricks

- Start with a small `maxItems` (10-20) to test before running large scrapes
- Use residential proxies for best results -- Yelp has moderate anti-bot protection
- Combine multiple search terms with multiple locations to cover wide areas efficiently
- Set `includeReviews` to true only when needed, as it increases processing time
- Business pages have the richest data via JSON-LD; search pages are used for discovery

### FAQ

**Q: Does this actor require login credentials?**
A: No. All data is extracted from publicly available Yelp pages.

**Q: How fast is the scraping?**
A: Approximately 50-100 businesses per minute with residential proxies and default concurrency.

**Q: What should I do if I get blocked?**
A: Switch to residential proxies in the Proxy Configuration settings and reduce maxConcurrency to 3-5.

**Q: Can I scrape reviews?**
A: Yes, enable the "Include Reviews" option to extract the top reviews shown on each business page.

**Q: Does it handle pagination?**
A: Yes, the actor automatically paginates through search results until maxItems is reached or no more results are available.

### Is it legal to scrape Yelp?

Web scraping of publicly available data is generally legal based on precedents like the LinkedIn v. HiQ Labs case. This actor only accesses publicly available data. Always review and respect the target site's Terms of Service and robots.txt. For more information, see [Apify's blog on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

- [Google Maps Scraper](https://apify.com/compass/google-maps-scraper)
- [TripAdvisor Scraper](https://apify.com/compass/tripadvisor-scraper)
- [Yellow Pages Scraper](https://apify.com/compass/yellow-pages-scraper)

### Limitations

- Review extraction is limited to the reviews displayed on the first page of each business
- Business hours may not be available for all listings
- Some fields (website, coordinates) depend on the business having complete Yelp profiles
- Rate limiting may slow down large scrapes; use residential proxies for best performance

### Changelog

- **v0.1** (2026-04-23) -- Initial release

# Actor input Schema

## `startUrls` (type: `array`):

List of Yelp URLs to scrape. Can be search pages or direct business page URLs (e.g. https://www.yelp.com/biz/...).

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

Business types or keywords to search for (e.g. 'pizza', 'plumber', 'coffee shop').

## `locations` (type: `array`):

Locations to search in. Used with Search Terms (e.g. 'New York, NY', 'Los Angeles, CA').

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

Whether to extract the top reviews shown on each business page.

## `maxItems` (type: `integer`):

Maximum number of business listings to scrape. Use 0 or leave empty for unlimited.

## `maxConcurrency` (type: `integer`):

Maximum number of pages processed in parallel.

## `debugMode` (type: `boolean`):

Enables verbose logging and saves HTML snapshots on errors.

## `extendOutputFunction` (type: `string`):

A JavaScript function to customize each output item. Receives { data, $, request }.

## `proxyConfig` (type: `object`):

Select proxies to be used. Residential proxies recommended for Yelp.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=San+Francisco%2C+CA"
    }
  ],
  "searchTerms": [
    "restaurants"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "includeReviews": false,
  "maxItems": 100,
  "maxConcurrency": 8,
  "debugMode": false,
  "extendOutputFunction": "async ({ data, $ }) => {\n    return data;\n}",
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=San+Francisco%2C+CA"
        }
    ],
    "searchTerms": [
        "restaurants"
    ],
    "locations": [
        "San Francisco, CA"
    ],
    "extendOutputFunction": async ({ data, $ }) => {
        return data;
    },
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glassventures/yelp-business-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 = {
    "startUrls": [{ "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=San+Francisco%2C+CA" }],
    "searchTerms": ["restaurants"],
    "locations": ["San Francisco, CA"],
    "extendOutputFunction": """async ({ data, $ }) => {
    return data;
}""",
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("glassventures/yelp-business-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 '{
  "startUrls": [
    {
      "url": "https://www.yelp.com/search?find_desc=restaurants&find_loc=San+Francisco%2C+CA"
    }
  ],
  "searchTerms": [
    "restaurants"
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "extendOutputFunction": "async ({ data, $ }) => {\\n    return data;\\n}",
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call glassventures/yelp-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Business Scraper",
        "description": "Extract business listings, ratings, reviews, contact info, and hours from Yelp. Export to JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "LNivtLK3zOKIEH2v4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/glassventures~yelp-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-glassventures-yelp-business-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/glassventures~yelp-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-glassventures-yelp-business-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/glassventures~yelp-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-glassventures-yelp-business-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Yelp URLs to scrape. Can be search pages or direct business page URLs (e.g. https://www.yelp.com/biz/...).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Business types or keywords to search for (e.g. 'pizza', 'plumber', 'coffee shop').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to search in. Used with Search Terms (e.g. 'New York, NY', 'Los Angeles, CA').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Whether to extract the top reviews shown on each business page.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of business listings to scrape. Use 0 or leave empty for unlimited.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages processed in parallel.",
                        "default": 8
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Enables verbose logging and saves HTML snapshots on errors.",
                        "default": false
                    },
                    "extendOutputFunction": {
                        "title": "Extend Output Function",
                        "type": "string",
                        "description": "A JavaScript function to customize each output item. Receives { data, $, request }."
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to be used. Residential proxies recommended for Yelp."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```