# Yellow Pages US Scraper (`giga_data/yellow-pages-us-scraper`) Actor

Scrape US business listings from yellowpages.com — names, phone numbers, addresses, websites, categories, ratings, and reviews. Search by category + location or pass direct URLs. Production-grade with battle-tested anti-bot handling and daily fixture tests.

- **URL**: https://apify.com/giga\_data/yellow-pages-us-scraper.md
- **Developed by:** [Giga Data](https://apify.com/giga_data) (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 $1.05 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 📞 Yellow Pages US Scraper

> Extract US business listings from yellowpages.com — names, phone numbers, addresses, websites, categories, ratings, and reviews. Built for lead-gen agencies, local-SEO teams, and B2B sales ops.

**Yellow Pages US Scraper** turns yellowpages.com into a clean, structured data feed. Provide a category and a city, and you get every business listed — with phones, websites, addresses, ratings, and category labels — pushed straight to a downloadable dataset (JSON, CSV, Excel).

Use it to:
- **Generate qualified B2B lead lists** — plumbers in Boston, dentists in Denver, electricians in Austin — every business with phone and website in seconds.
- **Track local competitors** across regions to spot expansion opportunities or gaps.
- **Seed your CRM or marketing tool** with verified local business data.
- **Run market research** — TAM sizing, density mapping, vertical surveys.
- **Power RAG / LLM datasets** that need structured local-business records.

Unlike Google's Places API (which caps you at 60 results per query and charges per call) or one-off freebie scrapers (which break the moment Yellow Pages tweaks its HTML), this Actor ships with **active maintenance**: every selector is fixture-tested daily, breakage gets fixed within hours, and you only ever pay for results — never for failed runs.

### 💰 Pricing

**$1.00 per 1,000 results** — Pay-Per-Result. The first **100 results are free**, and Apify's $5/month free credit covers a further ~5,000 results out of the box. Stops costing you anything if you stop running it.

### 🎥 Demo

*Demo video coming soon — meanwhile, see "Sample output" below for what a single row looks like.*

### ✨ What you get

Every business record contains:

| Field | Description |
|---|---|
| `name` | Business name as listed |
| `phone` | Primary phone (e.g. "(617) 555-1234") |
| `website` | Direct website URL (when provided by the listing) |
| `address` | Street address |
| `city`, `state`, `zip` | Parsed locality components |
| `categories` | Array of Yellow Pages category labels |
| `rating` | Star rating (0–5, half-stars supported) |
| `reviewCount` | Number of reviews on Yellow Pages |
| `yearsInBusiness` | Self-reported years operating |
| `isAd` | `true` for paid/sponsored listings, `false` for organic |
| `businessUrl` | Canonical Yellow Pages business-detail URL |
| `email`, `hours`, `services` | Extra fields populated when "Visit business detail pages" is enabled |
| `searchTerm`, `searchLocation` | Echo of the input that produced this row |
| `scrapedAt` | ISO timestamp of extraction |

### 🚀 How to use

1. **Pick what you want.** Enter one or more **search terms** (e.g. `plumber`, `italian restaurant`) and one or more **locations** (e.g. `Boston, MA`, `Austin, TX`). The Actor crawls every combination.
2. **Cap the result count.** Set `maxItems` and `maxPagesPerSearch` so the Actor stops exactly where you want.
3. **(Optional) toggle "Visit business detail pages"** to pull richer fields per business (email, hours, services). Roughly 2× the runtime and cost.
4. **Click Start.** Results stream into the Apify dataset — download as JSON, CSV, or Excel from the Actor's Storage tab when the run completes.

Advanced users can pass `startUrls` directly to control which exact category landing pages get crawled (e.g. `https://www.yellowpages.com/boston-ma/plumbers`).

### 📦 Sample output

```json
{
  "name": "A Hohmann & Co Inc",
  "phone": "(844) 825-3055",
  "website": "http://www.hohmannoilandplumbing.com",
  "address": "1146 Dorchester Ave",
  "city": "Boston",
  "state": "MA",
  "zip": "02125",
  "categories": ["Plumbers"],
  "rating": 3,
  "reviewCount": 2,
  "yearsInBusiness": 116,
  "isAd": false,
  "businessUrl": "https://www.yellowpages.com/boston-ma/mip/a-hohmann-co-inc-474353566",
  "email": null,
  "hours": null,
  "services": [],
  "searchTerm": "plumber",
  "searchLocation": "Boston, MA",
  "scrapedAt": "2026-05-12T14:23:17.504Z"
}
````

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | string\[] | `["plumber"]` | Categories or keywords to search for. |
| `locations` | string\[] | `["Boston, MA"]` | US locations in "City, ST" format. |
| `startUrls` | URL\[] | — | Direct category URLs (advanced; overrides `searchTerms` × `locations`). |
| `maxItems` | int | `200` | Stop after N results. `0` = unlimited. |
| `maxPagesPerSearch` | int | `5` | Max result pages crawled per query (YP caps near 30). |
| `extractDetails` | bool | `false` | Follow each business's detail page for email, hours, services. |
| `proxyConfiguration` | proxy | `RESIDENTIAL` | Apify proxy settings — residential strongly recommended. |

See the input schema panel for the full reference.

### ❓ FAQ

**How is this different from the official Yellow Pages search?**
Yellow Pages' on-site search is built for human browsers — there's no bulk export, no structured fields, and no API to feed your CRM. This Actor gives you the same listings as clean rows you can pipe into Salesforce, Apollo, a spreadsheet, or your own dashboard.

**How accurate is the data?**
Every field you see on a listing page is captured. Yellow Pages updates listings continuously, so freshness depends on when they were last updated by the business owner. Phone numbers and business names are the most reliable fields; emails and hours often live on the detail page (enable `extractDetails` to pull them).

**Will it break when Yellow Pages changes their HTML?**
That's the bet most scrapers lose. This one ships with daily fixture tests that detect breakage within hours, and fixes are deployed fast — typically same-day. Run-success-rate is publicly visible on this page.

**What about anti-bot? Will my runs get blocked?**
Yellow Pages is fronted by Cloudflare. This Actor uses Apify's residential proxy by default plus a Chrome-grade TLS fingerprint, which sails past Cloudflare's normal protections. We monitor block rates and adapt.

**Does this scrape user-personal information?**
No. Every field is publicly-listed business data (business names, business phones, business addresses, business reviews). We don't extract reviewer profiles, individual emails, or anything Yellow Pages classifies as personal.

**How big a job can it handle?**
Tens of thousands of records per run is comfortable. For multi-million-record jobs, contact us — we'll suggest sharding strategy and run dedicated infrastructure.

### ⚠️ Limits, ToS & compliance

- **Rate limits**: Yellow Pages caps results around 30 pages per category-location pair. Run-pace is throttled by Apify residential proxy.
- **Anti-bot**: Cloudflare protection bypassed via real browser TLS fingerprint + residential IPs. Datacenter proxies will not work.
- **Legal posture**: Output is **public business data** — names, addresses, phones of registered businesses. No personal data, no protected content. GDPR-clean.
- **Source data ownership**: Yellow Pages content is published by Thryv, Inc. This Actor sells the **capability** to extract that public data into your own workflow — buyers are responsible for how they use the results.

### 🏷️ Other Actors by Giga Data

- More B2B-directory scrapers coming soon — bookmark our [org page](https://apify.com/giga-data).

### 📬 Support & contact

- Open an issue on the Apify support console.
- Issue templates auto-route maintenance failures to a fix queue.

***

*Built and maintained by [Giga Data](https://apify.com/giga-data). We treat scraping as infrastructure — fixture-tested, monitored, and patched fast when target sites change.*

*Disclosure: this Actor is AI-assisted (the parser, schema, and listing copy were authored with Anthropic Claude). The maintainer reviews every change before deploy.*

# Actor input Schema

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

Categories or keywords to search for. Examples: "plumber", "dentist", "italian restaurant". Each term is paired with each location in `locations` (cartesian product).

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

US locations in "City, ST" format. Examples: "Boston, MA", "Austin, TX". Each location is paired with each term in `searchTerms`.

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

Direct yellowpages.com category URLs to crawl. Use this if you want exact control over which category landing pages are scraped (e.g. https://www.yellowpages.com/boston-ma/plumbers). When provided, `searchTerms` and `locations` are ignored.

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

Stop after this many business records have been extracted. 0 = unlimited.

## `maxPagesPerSearch` (type: `integer`):

Maximum result pages to crawl per (search term × location) pair or per start URL. Yellow Pages typically caps results around 30 pages.

## `extractDetails` (type: `boolean`):

When enabled, follow each business's MIP detail page to extract additional fields (email, hours, services, year established, full address). Roughly 2× the runtime and cost per result.

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

Apify proxy settings. US residential proxies (`RESIDENTIAL`, country `US`) are required — Yellow Pages is fronted by Cloudflare and blocks datacenter IPs and non-US residential ranges.

## Actor input object example

```json
{
  "searchTerms": [
    "plumber"
  ],
  "locations": [
    "Boston, MA"
  ],
  "maxItems": 200,
  "maxPagesPerSearch": 5,
  "extractDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

# 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": [
        "plumber"
    ],
    "locations": [
        "Boston, MA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("giga_data/yellow-pages-us-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": ["plumber"],
    "locations": ["Boston, MA"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("giga_data/yellow-pages-us-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": [
    "plumber"
  ],
  "locations": [
    "Boston, MA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call giga_data/yellow-pages-us-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yellow Pages US Scraper",
        "description": "Scrape US business listings from yellowpages.com — names, phone numbers, addresses, websites, categories, ratings, and reviews. Search by category + location or pass direct URLs. Production-grade with battle-tested anti-bot handling and daily fixture tests.",
        "version": "0.6",
        "x-build-id": "I8FoNfXUpqE6q0TDF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/giga_data~yellow-pages-us-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-giga_data-yellow-pages-us-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/giga_data~yellow-pages-us-scraper/runs": {
            "post": {
                "operationId": "runs-sync-giga_data-yellow-pages-us-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/giga_data~yellow-pages-us-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-giga_data-yellow-pages-us-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": "Categories or keywords to search for. Examples: \"plumber\", \"dentist\", \"italian restaurant\". Each term is paired with each location in `locations` (cartesian product).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "US locations in \"City, ST\" format. Examples: \"Boston, MA\", \"Austin, TX\". Each location is paired with each term in `searchTerms`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Direct yellowpages.com category URLs to crawl. Use this if you want exact control over which category landing pages are scraped (e.g. https://www.yellowpages.com/boston-ma/plumbers). When provided, `searchTerms` and `locations` are ignored.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many business records have been extracted. 0 = unlimited.",
                        "default": 200
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum result pages to crawl per (search term × location) pair or per start URL. Yellow Pages typically caps results around 30 pages.",
                        "default": 5
                    },
                    "extractDetails": {
                        "title": "Visit business detail pages",
                        "type": "boolean",
                        "description": "When enabled, follow each business's MIP detail page to extract additional fields (email, hours, services, year established, full address). Roughly 2× the runtime and cost per result.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy settings. US residential proxies (`RESIDENTIAL`, country `US`) are required — Yellow Pages is fronted by Cloudflare and blocks datacenter IPs and non-US residential ranges.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```