# GoodTherapy Therapist Directory Scraper (`automation-lab/goodtherapy-therapist-directory-scraper`) Actor

Scrape public GoodTherapy therapist profiles, specialties, locations, phone numbers, and practice details for lead generation and market research.

- **URL**: https://apify.com/automation-lab/goodtherapy-therapist-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 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

## GoodTherapy Therapist Directory Scraper

Scrape public therapist listings and profile details from GoodTherapy directory pages.

### What does GoodTherapy Therapist Directory Scraper do?

GoodTherapy Therapist Directory Scraper extracts therapist lead data from public GoodTherapy search results and profile pages. It is designed for healthcare lead generation, referral research, therapist market mapping, and local behavioral-health analysis.

The actor reads GoodTherapy directory pages such as `https://www.goodtherapy.org/therapists/ny/new-york`, follows pagination, and saves one clean therapist record per dataset row. You can also pass a direct therapist profile URL or use the city/state shortcut.

### Who is it for?

- 🏥 Clinic growth teams building partner and referral lists
- 📍 Local SEO teams mapping therapist supply in a city
- 🤝 Healthcare partnership teams finding private-practice contacts
- 📊 Analysts comparing specialties, credentials, and locations
- 🧭 Referral coordinators researching public therapist directories
- 🧪 Data teams enriching CRM records with public source URLs

### Why use this actor?

GoodTherapy pages are public, but manually collecting names, profile links, phone numbers, credentials, specialties, and office locations is slow. This actor automates the repeatable collection step and outputs structured JSON, CSV, Excel, and API-ready data through Apify datasets.

### What data can it extract?

| Field | Description |
| --- | --- |
| `name` | Therapist or practice contact name |
| `credentials` | Credentials shown on the listing |
| `profileUrl` | GoodTherapy profile URL |
| `photoUrl` | Listing photo URL when available |
| `roles` | Professional roles such as Psychotherapist or Counselor |
| `location` | Public listing location text |
| `city` | Parsed city when available |
| `state` | Parsed state when available |
| `postalCode` | Parsed ZIP/postal code when available |
| `phone` | Public telephone link when shown |
| `isVerified` | Whether GoodTherapy marks the listing as verified |
| `isAcceptingClients` | Availability signal when detectable on a profile |
| `profileSnippet` | Public listing or meta-description snippet |
| `approach` | Therapy approach text when profile enrichment is enabled |
| `ageGroups` | Age-group chips from profile pages |
| `services` | Services and therapy modes from profile pages |
| `concerns` | Concerns/challenges addressed from profile pages |
| `officeLocations` | Public office location strings from profile pages |
| `sourceUrl` | Directory or profile URL where the record was found |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape GoodTherapy therapists?

This actor uses pay-per-event pricing. A small `$0.005` start charge covers run setup, and a per-therapist charge is emitted for every saved therapist record. Formula-derived tier pricing starts at `$0.000045319` per therapist on the Free tier and `$0.000039408` on Bronze, with lower per-item prices on higher Apify tiers.

### Quick start

1. Open the actor on Apify.
2. Paste a GoodTherapy directory URL, for example `https://www.goodtherapy.org/therapists/ny/new-york`.
3. Set `maxItems` to a small number for a first test.
4. Keep `includeProfileDetails` off for faster listing-only runs.
5. Run the actor and export the dataset.

### Input options

#### GoodTherapy URLs

Use `startUrls` for directory pages or direct profile pages. Directory pages are the normal mode and support pagination.

#### City and state shortcut

Set `city` to a GoodTherapy city slug such as `new-york` and `state` to a two-letter state code such as `ny`. The actor builds a URL like `/therapists/ny/new-york`.

#### Maximum therapists

`maxItems` controls how many therapist records are saved. Use a low number for testing and a higher number for production exports.

#### Maximum directory pages

`maxPages` controls pagination per source. GoodTherapy city pages can have many pages, so this setting keeps runs predictable.

#### Profile enrichment

`includeProfileDetails` fetches every therapist profile page to extract richer fields such as age groups, concerns, services, office locations, and approach text. It is slower than listing-only mode but provides more complete data.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.goodtherapy.org/therapists/ny/new-york" }
  ],
  "maxItems": 25,
  "maxPages": 2,
  "includeProfileDetails": false
}
````

### Example input using location fields

```json
{
  "city": "los-angeles",
  "state": "ca",
  "maxItems": 20,
  "maxPages": 1,
  "includeProfileDetails": true
}
```

### Example output

```json
{
  "name": "Example Therapist",
  "credentials": "LCSW",
  "profileUrl": "https://www.goodtherapy.org/therapists/profile/example",
  "photoUrl": "https://www.goodtherapy.org/thumbs/160x160/example.jpg",
  "roles": ["Clinical Social Worker", "Psychotherapist"],
  "location": "New York, 10001",
  "city": "New York",
  "state": null,
  "postalCode": "10001",
  "phone": "+12125550123",
  "isVerified": true,
  "isAcceptingClients": null,
  "profileSnippet": "Public listing text...",
  "approach": null,
  "ageGroups": [],
  "services": [],
  "concerns": [],
  "officeLocations": [],
  "sourceUrl": "https://www.goodtherapy.org/therapists/ny/new-york",
  "scrapedAt": "2026-05-28T00:00:00.000Z"
}
```

### Tips for best results

- Start with `includeProfileDetails: false` to collect listing data quickly.
- Enable profile enrichment when you need specialties, concerns, or longer descriptions.
- Use `maxPages` with city pages to control runtime and cost.
- Use direct profile URLs if you only need a few known therapists.
- Export to CSV for outreach workflows or JSON for enrichment pipelines.

### Integrations

Use the dataset in CRM imports, healthcare market maps, referral partner databases, spreadsheets, BI tools, or enrichment jobs. Apify can push results through webhooks, API clients, Make, Zapier, or your own ETL process.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/goodtherapy-therapist-directory-scraper').call({
  startUrls: [{ url: 'https://www.goodtherapy.org/therapists/ny/new-york' }],
  maxItems: 25,
  maxPages: 2
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/goodtherapy-therapist-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.goodtherapy.org/therapists/ny/new-york'}],
    'maxItems': 25,
    'maxPages': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~goodtherapy-therapist-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.goodtherapy.org/therapists/ny/new-york"}],"maxItems":25,"maxPages":2}'
```

### MCP usage

You can use this actor through the Apify MCP server from Claude Code, Claude Desktop, or compatible MCP clients.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/goodtherapy-therapist-directory-scraper`

Claude Code setup:

```bash
claude mcp add apify-goodtherapy "https://mcp.apify.com/?tools=automation-lab/goodtherapy-therapist-directory-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-goodtherapy": {
      "url": "https://mcp.apify.com/?tools=automation-lab/goodtherapy-therapist-directory-scraper"
    }
  }
}
```

Example prompts:

- "Run the GoodTherapy scraper for New York and return therapist names and phone numbers."
- "Find public GoodTherapy profiles in Los Angeles and summarize the common specialties."
- "Export GoodTherapy therapist records as CSV for my referral research."

### Data quality notes

GoodTherapy profile layouts vary. Some listings expose phone numbers and verified badges; others may not. Profile-enrichment fields depend on what is publicly present on the therapist's profile page.

### Legality and ethical use

This actor extracts publicly available information. You are responsible for using the data lawfully, respecting GoodTherapy terms, and following applicable privacy, healthcare, outreach, and anti-spam regulations. Do not use scraped data for deceptive, discriminatory, or unlawful purposes.

### FAQ

#### Why did I get fewer results than requested?

The directory page may contain fewer available profiles than your limit, duplicate profiles may be skipped, or `maxPages` may be too low. Increase `maxPages` or use another city URL.

#### Why are profile details empty?

Profile-enrichment fields only populate when `includeProfileDetails` is enabled and the profile page publishes those sections. Listing-only runs intentionally leave rich profile fields empty to run faster.

### Related scrapers

- https://apify.com/automation-lab/psychology-today-therapist-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/doctor-lead-scraper

### Changelog

#### 0.1

Initial version with HTTP directory scraping, pagination, direct profile URL support, location shortcut input, and optional profile enrichment.

### Support

If a GoodTherapy page layout changes or you need additional fields, open an Apify actor issue with an example URL and desired output fields.

### Field reference

Use `profileUrl` as the stable source identifier. Use `sourceUrl` to understand which directory page produced each row. Use `scrapedAt` to track freshness in recurring workflows.

### Performance guidance

Listing-only mode is the fastest mode. Enrichment mode performs one extra HTTP request per therapist profile, so it is best for smaller or more targeted runs.

### Export formats

Apify datasets support JSON, JSONL, CSV, Excel, XML, and RSS exports. Choose JSON/JSONL for pipelines and CSV/Excel for spreadsheet workflows.

# Actor input Schema

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

GoodTherapy directory pages such as /therapists/ny/new-york or individual therapist profile URLs.

## `city` (type: `string`):

Optional city slug used with state to build a GoodTherapy directory URL, for example new-york or los-angeles.

## `state` (type: `string`):

Optional two-letter state code used with city, for example ny or ca.

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

Maximum number of therapist records to save.

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

Maximum directory pages to crawl per start URL or location.

## `includeProfileDetails` (type: `boolean`):

Fetch each profile page for specialties, concerns, age groups, office details, and approach text. Slower but richer.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.goodtherapy.org/therapists/ny/new-york"
    }
  ],
  "city": "new-york",
  "state": "ny",
  "maxItems": 10,
  "maxPages": 1,
  "includeProfileDetails": 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 = {
    "startUrls": [
        {
            "url": "https://www.goodtherapy.org/therapists/ny/new-york"
        }
    ],
    "city": "new-york",
    "state": "ny",
    "maxItems": 10,
    "maxPages": 1,
    "includeProfileDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/goodtherapy-therapist-directory-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.goodtherapy.org/therapists/ny/new-york" }],
    "city": "new-york",
    "state": "ny",
    "maxItems": 10,
    "maxPages": 1,
    "includeProfileDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/goodtherapy-therapist-directory-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.goodtherapy.org/therapists/ny/new-york"
    }
  ],
  "city": "new-york",
  "state": "ny",
  "maxItems": 10,
  "maxPages": 1,
  "includeProfileDetails": false
}' |
apify call automation-lab/goodtherapy-therapist-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoodTherapy Therapist Directory Scraper",
        "description": "Scrape public GoodTherapy therapist profiles, specialties, locations, phone numbers, and practice details for lead generation and market research.",
        "version": "0.1",
        "x-build-id": "yd9sgtKCcr4T4kntG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~goodtherapy-therapist-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-goodtherapy-therapist-directory-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~goodtherapy-therapist-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-goodtherapy-therapist-directory-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~goodtherapy-therapist-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-goodtherapy-therapist-directory-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": "🔎 GoodTherapy URLs",
                        "type": "array",
                        "description": "GoodTherapy directory pages such as /therapists/ny/new-york or individual therapist profile URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "city": {
                        "title": "City slug",
                        "type": "string",
                        "description": "Optional city slug used with state to build a GoodTherapy directory URL, for example new-york or los-angeles."
                    },
                    "state": {
                        "title": "State code",
                        "type": "string",
                        "description": "Optional two-letter state code used with city, for example ny or ca."
                    },
                    "maxItems": {
                        "title": "Maximum therapists",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of therapist records to save.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Maximum directory pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum directory pages to crawl per start URL or location.",
                        "default": 3
                    },
                    "includeProfileDetails": {
                        "title": "Enrich profile details",
                        "type": "boolean",
                        "description": "Fetch each profile page for specialties, concerns, age groups, office details, and approach text. Slower but richer.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
