# AnyWho People Search Scraper (`automation-lab/anywho-people-search-scraper`) Actor

Scrape public AnyWho people-search, reverse-phone, area-code, and directory results for privacy ops and lead enrichment.

- **URL**: https://apify.com/automation-lab/anywho-people-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## AnyWho People Search Scraper

Scrape public AnyWho people-search, reverse-phone, area-code, and last-name directory pages.

Use this actor to collect structured public directory signals such as names, ages, masked phone snippets, locations, relatives, profile URLs, area codes, and phone prefixes.

> Compliance note: this actor is not a consumer-reporting agency tool. Do not use it for employment, tenant screening, credit, insurance, or any FCRA-covered decision.

### What does AnyWho People Search Scraper do?

AnyWho People Search Scraper turns public AnyWho pages into clean dataset rows.

It supports several workflows:

- 🔎 Name search pages such as `John Smith`
- 📞 Reverse phone pages such as `(310) 555-1212`
- 🌎 Area-code pages such as `310`
- 🔤 Last-name directory pages such as `S`
- 🔗 Direct AnyWho start URLs

The actor fetches AnyWho over HTTP and parses the server-rendered HTML.

### Who is it for?

This actor is useful for teams that need repeatable public-directory collection.

- 🛡️ Privacy operations teams checking public personal-data exposure
- 🧭 Executive protection analysts reviewing visible contact traces
- 📇 Lead enrichment teams adding public directory context
- 🧹 Data hygiene teams validating names, locations, and area-code signals
- 🔍 Researchers monitoring public white-pages style results

### Why use this actor?

AnyWho pages are human-readable but hard to use in a pipeline.

This actor gives you:

- Structured rows instead of HTML
- Consistent field names
- Dataset exports in JSON, CSV, Excel, XML, and RSS
- API access through Apify
- Per-result pricing
- Small default runs for cheap testing

### Data you can extract

| Field | Description |
| --- | --- |
| `resultType` | `person`, `phone`, `area_code`, `directory_suggestion`, or `page_summary` |
| `searchType` | Input mode used for this result |
| `query` | Original query |
| `name` | Person or directory suggestion name |
| `age` | Age shown on AnyWho, when available |
| `currentLocation` | Current location snippet |
| `previousLocations` | Previous-location snippets |
| `maskedPhones` | Masked phone snippets shown by AnyWho |
| `relatives` | Public relative snippets |
| `profileUrl` | AnyWho profile or directory URL |
| `phoneNumber` | Reverse-phone page number |
| `areaCode` | Area code parsed from phone or area-code pages |
| `phonePrefix` | Prefix listed on area-code pages |
| `sourceUrl` | Page that produced the record |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape AnyWho people search results?

The actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged per dataset item produced.
- Keep `maxItems` low while testing.
- Increase `maxPages` only when you need deeper pagination.

Final production tier prices are calculated from cloud validation before publishing.

### Input options

#### `searchType`

Choose one of:

- `name`
- `reversePhone`
- `areaCode`
- `directoryLetter`
- `url`

#### `queries`

The meaning depends on `searchType`.

Examples:

- `John Smith`
- `(310) 555-1212`
- `310`
- `S`
- `https://www.anywho.com/people/john+smith`

#### `location`

Optional for name searches.

Examples:

- `California`
- `California, Los Angeles`

#### `startUrls`

Use direct AnyWho URLs if you already have them.

#### `maxItems`

Stops the run after this many rows.

#### `maxPages`

Controls pagination depth per query.

### Example input: name search

```json
{
  "searchType": "name",
  "queries": ["John Smith"],
  "location": "California",
  "maxItems": 25,
  "maxPages": 1
}
````

### Example input: reverse phone lookup

```json
{
  "searchType": "reversePhone",
  "queries": ["(310) 555-1212"],
  "maxItems": 5
}
```

### Example input: area-code research

```json
{
  "searchType": "areaCode",
  "queries": ["310"],
  "maxItems": 50
}
```

### Example input: directory suggestions

```json
{
  "searchType": "directoryLetter",
  "queries": ["S"],
  "includeDirectorySuggestions": true,
  "maxItems": 100
}
```

### Example output

```json
{
  "resultType": "person",
  "searchType": "name",
  "query": "John Smith",
  "name": "John T Smith",
  "age": 100,
  "currentLocation": "Reed St, Fort Wayne, IN",
  "maskedPhones": ["(260) 744-", "(260) 745-"],
  "relatives": ["Harold Smith", "Ella Smithclark"],
  "profileUrl": "https://www.anywho.com/people/john+smith/indiana/fort+wayne/a758114512127",
  "sourceUrl": "https://www.anywho.com/people/john+smith",
  "scrapedAt": "2026-06-20T17:30:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Choose a search type.
3. Enter one or more queries.
4. Keep `maxItems` low for the first run.
5. Click **Start**.
6. Download the dataset.

### Tips for better results

- Use full names when possible.
- Add a state for common names.
- Use direct AnyWho URLs for repeatable monitoring.
- Use area-code mode when you need prefix lists.
- Do not set high pagination until the first page looks correct.

### Integrations

You can connect this actor to:

- Google Sheets via Apify integrations
- Zapier or Make for enrichment workflows
- CRM import jobs
- Privacy ticket queues
- Executive protection dashboards
- Internal lead-scoring pipelines

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/anywho-people-search-scraper').call({
  searchType: 'name',
  queries: ['John Smith'],
  location: 'California',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/anywho-people-search-scraper').call(run_input={
    'searchType': 'areaCode',
    'queries': ['310'],
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~anywho-people-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchType":"reversePhone","queries":["(310) 555-1212"],"maxItems":5}'
```

### MCP usage

Use the Apify MCP server with:

```text
https://mcp.apify.com/?tools=automation-lab/anywho-people-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-anywho "https://mcp.apify.com/?tools=automation-lab/anywho-people-search-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-anywho": {
      "url": "https://mcp.apify.com/?tools=automation-lab/anywho-people-search-scraper"
    }
  }
}
```

Example prompts:

- "Run AnyWho People Search Scraper for John Smith in California and summarize the public directory matches."
- "Check this phone number with the AnyWho reverse-phone actor and return the dataset rows."
- "Collect prefixes for area code 310 and export them as CSV."

### Legality

AnyWho displays public directory information and its own legal notices.

### Legal and FCRA notice

AnyWho displays public directory information and its own legal notices.

You are responsible for how you use the data.

Do not use this actor for:

- Employment eligibility
- Tenant screening
- Credit decisions
- Insurance decisions
- FCRA-covered consumer reporting
- Harassment, stalking, or doxxing

Use it only for lawful public-information workflows.

### Privacy operations workflow

A common workflow is:

1. Load a list of executives or protected persons.
2. Run name searches with state filters.
3. Export public exposure rows.
4. Review profile URLs manually.
5. Create opt-out/remediation tickets where appropriate.
6. Repeat on a schedule.

### Lead enrichment workflow

A lead enrichment workflow can:

1. Search full names.
2. Capture approximate location and masked phone signals.
3. Combine with first-party CRM data.
4. Route uncertain matches to manual review.
5. Avoid automated sensitive decisions.

### Area-code workflow

Area-code mode is useful when you need:

- Prefix lists
- Area-code page metadata
- Phone-region context
- Repeatable telecom enrichment inputs

### FAQ

#### Can I use this for employment or tenant screening?

No. Do not use this actor for FCRA-covered decisions such as employment, tenant screening, credit, or insurance.

#### Does it reveal full phone numbers?

The actor exports what AnyWho publicly shows on the page. Some people-search rows contain masked phone snippets rather than full numbers.

### Troubleshooting: no results

If a query returns no people rows:

- Check that the name has both first and last name.
- Try without a location.
- Try a broader state instead of city.
- Open the `sourceUrl` manually to confirm AnyWho has results.

### Troubleshooting: only page summary rows

A page summary row means the page loaded but no supported result cards were found.

This can happen with unsupported URLs, no-result pages, or changed AnyWho markup.

### Related scrapers

- Website Contact Finder: https://apify.com/automation-lab/website-contact-finder
- Website Emails Scraper: https://apify.com/automation-lab/website-emails-scraper

### Changelog

Initial version supports name, reverse-phone, area-code, directory-letter, and direct URL modes.

### Support

If results look wrong, include:

- Input JSON
- Run URL
- Expected AnyWho page URL
- A short description of the missing field

### Responsible use

Respect AnyWho's terms, robots signals, and applicable laws.

Run only the searches you are authorized to perform.

Avoid collecting more data than your workflow requires.

Use small test runs before scaling.

# Actor input Schema

## `searchType` (type: `string`):

Choose whether queries are names, phone numbers, area codes, directory letters, or direct AnyWho URLs.

## `queries` (type: `array`):

Names, phone numbers, area codes, letters, or AnyWho URLs depending on the selected search type.

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

Optional city/state filter for name searches, for example California or California, Los Angeles.

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

Optional direct AnyWho result, directory, phone, or area-code URLs to scrape in addition to queries.

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

Stop after this many output records.

## `maxPages` (type: `integer`):

How many paginated AnyWho pages to fetch for each query. Keep low for testing.

## `includeDirectorySuggestions` (type: `boolean`):

Also emit name-directory suggestion links found on directory pages.

## Actor input object example

```json
{
  "searchType": "name",
  "queries": [
    "John Smith"
  ],
  "location": "California",
  "startUrls": [
    {
      "url": "https://www.anywho.com/people/john+smith"
    }
  ],
  "maxItems": 10,
  "maxPages": 1,
  "includeDirectorySuggestions": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchType": "name",
    "queries": [
        "John Smith"
    ],
    "location": "California",
    "startUrls": [
        {
            "url": "https://www.anywho.com/people/john+smith"
        }
    ],
    "maxItems": 10,
    "maxPages": 1,
    "includeDirectorySuggestions": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/anywho-people-search-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 = {
    "searchType": "name",
    "queries": ["John Smith"],
    "location": "California",
    "startUrls": [{ "url": "https://www.anywho.com/people/john+smith" }],
    "maxItems": 10,
    "maxPages": 1,
    "includeDirectorySuggestions": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/anywho-people-search-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 '{
  "searchType": "name",
  "queries": [
    "John Smith"
  ],
  "location": "California",
  "startUrls": [
    {
      "url": "https://www.anywho.com/people/john+smith"
    }
  ],
  "maxItems": 10,
  "maxPages": 1,
  "includeDirectorySuggestions": false
}' |
apify call automation-lab/anywho-people-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AnyWho People Search Scraper",
        "description": "Scrape public AnyWho people-search, reverse-phone, area-code, and directory results for privacy ops and lead enrichment.",
        "version": "0.1",
        "x-build-id": "vgN5v3yrI9OXx64Po"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~anywho-people-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-anywho-people-search-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/automation-lab~anywho-people-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-anywho-people-search-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/automation-lab~anywho-people-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-anywho-people-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "searchType": {
                        "title": "🔎 Search type",
                        "enum": [
                            "name",
                            "reversePhone",
                            "areaCode",
                            "directoryLetter",
                            "url"
                        ],
                        "type": "string",
                        "description": "Choose whether queries are names, phone numbers, area codes, directory letters, or direct AnyWho URLs.",
                        "default": "name"
                    },
                    "queries": {
                        "title": "Queries",
                        "type": "array",
                        "description": "Names, phone numbers, area codes, letters, or AnyWho URLs depending on the selected search type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Name-search location",
                        "type": "string",
                        "description": "Optional city/state filter for name searches, for example California or California, Los Angeles."
                    },
                    "startUrls": {
                        "title": "Direct AnyWho start URLs",
                        "type": "array",
                        "description": "Optional direct AnyWho result, directory, phone, or area-code URLs to scrape in addition to queries.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many output records.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many paginated AnyWho pages to fetch for each query. Keep low for testing.",
                        "default": 1
                    },
                    "includeDirectorySuggestions": {
                        "title": "Include directory suggestions",
                        "type": "boolean",
                        "description": "Also emit name-directory suggestion links found on directory pages.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```