# Doximity Physician Directory Scraper (`parseforge/doximity-scraper`) Actor

Extract US physician profiles from Doximity — name, specialty, credentials, city, state, phone, fax, hospital affiliation, education, certifications, awards, publications, and professional memberships. Free preview caps at 10 profiles.

- **URL**: https://apify.com/parseforge/doximity-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Social media
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 👨‍⚕️ Doximity Physician Directory Scraper

Extract comprehensive physician profiles from Doximity's public directory without writing any code. Collect physician records including credentials, specialties, education, certifications, hospital affiliations, and professional memberships. Perfect for healthcare researchers building databases, sales teams identifying providers for outreach, recruitment agencies finding specialists, or market analysts studying physician distributions across states and medical specialties. Download your data instantly in JSON, CSV, or Excel format.

> **The Doximity Physician Directory Scraper extracts verified physician profiles from Doximity's public directory with advanced filtering by specialty and state.**

### ✨ What Does It Do

- 👤 **Physician Name and Credentials** - identify healthcare providers and their medical qualifications at a glance
- 🏥 **Hospital Affiliation** - track hospitals and health systems physicians practice at for partnership and network analysis
- 📚 **Education History** - capture medical schools, residency programs, and fellowship training institutions for credential verification
- ✅ **Professional Certifications** - extract board certifications and specialty credentials to assess provider qualifications
- 📖 **Publications and Research** - collect academic publications, journals, and citation counts to identify thought leaders
- 🤝 **Professional Memberships** - gather memberships in medical associations and professional organizations for networking insights

### 🔧 Input

- **Start URL** - provide a direct link to any Doximity directory page, such as /directory/md/specialty/cardiology. If provided, specialty and state filters are ignored.
- **Specialty** - filter physicians by medical specialty like cardiology, dermatology, or neurology to narrow your search
- **State** - filter physicians by US state such as California or New York to target specific geographic regions
- **Include Full Profile Details** - when enabled, fetches each physician's complete profile page to extract education, certifications, awards, publications, and professional memberships. Takes longer but captures more complete data
- **Max Items** - set how many physician records to collect in a single run
- **Max Concurrency** - adjust the number of parallel requests to prevent rate limiting between 1 and 20
- **Request Delay** - set milliseconds to wait between requests if you encounter rate limits

```json
{
  "specialty": "cardiology",
  "state": "california",
  "maxItems": 100,
  "includeDetails": true
}
````

### 📊 Output

Each physician record includes comprehensive data fields. Download as JSON, CSV, or Excel.

| 👤 Physician Name | 📚 Credentials | 🩺 Medical Specialty |
|---|---|---|
| 🏥 Hospital Affiliation | 📍 City | 🗺️ State |
| 📞 Phone Number | 🎓 Education History | ✅ Certifications |
| 🏆 Awards & Honors | 📖 Publications | 🤝 Professional Memberships |
| 🖼️ Profile Image | 🔗 Profile URL | 📅 Scraped Timestamp |
| ⚠️ Error Messages | | |

### 💎 Why Choose the Doximity Scraper?

| Feature | Our Actor |
|---|---|
| Extract comprehensive physician data fields | ✔️ |
| Filter by medical specialty (40+ options) | ✔️ |
| Filter by US state | ✔️ |
| Extract full profile details on demand | ✔️ |
| Access education and training history | ✔️ |
| Capture board certifications | ✔️ |
| Collect publication and research records | ✔️ |
| Extract professional memberships | ✔️ |
| Download in JSON, CSV, or Excel | ✔️ |
| No coding or technical skills required | ✔️ |
| Respect rate limits with adjustable concurrency | ✔️ |
| Handle various dataset sizes | ✔️ |
| Scale from single queries to bulk operations | ✔️ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. Sign Up: [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Find the Tool: Search for "Doximity Physician Directory Scraper" in the Apify Store and configure your input
3. Run It: Click "Start" and watch your results appear

That's it. No coding, no setup, no complicated configuration. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Healthcare Data Analyst** - create a searchable database of cardiologists across all US states to analyze specialty distribution and population health patterns
- 💼 **Medical Device Sales Manager** - extract orthopedic surgeon contact information and hospital affiliations to build targeted sales campaigns by region and hospital network
- 🔬 **Medical Research Recruiter** - collect immunology and infectious disease specialists with publication records to identify collaborators for clinical trials

### ❓ FAQ

**🔍 How does it work?**
The tool visits Doximity's public directory, extracts physician profiles based on your filters, and optionally fetches full profile details for additional information like education, certifications, and publications.

**📊 Is the data accurate?**
The data comes directly from Doximity's public profiles. Accuracy depends on how well physicians maintain their Doximity profiles, which are generally professional and current.

**📅 Can I schedule this to run automatically?**
Yes, use the Schedule tab in Apify Console to run this scraper daily, weekly, or monthly to monitor physician data changes.

**⚖️ Is it legal to scrape Doximity?**
Yes, you are collecting data from public profiles. However, you are responsible for complying with Doximity's terms of service and all applicable laws in your jurisdiction.

**🛡️ Will Doximity block me?**
Doximity may rate-limit aggressive requests. We recommend using a residential proxy and adjusting the Request Delay and Max Concurrency settings if you encounter blocks.

**⚡ How long does a run take?**
For 100 physicians without profile details, expect 2-5 minutes. With full profile details enabled, 100 physicians may take 10-20 minutes depending on concurrency settings and request delay.

**⚠️ Are there any limits?**
You can adjust the Max Items parameter to control how many physician records to collect per run. Check your account settings for dataset size specifications.

### 🔗 Integrate Doximity Physician Directory Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

Browse additional healthcare and professional directory data extraction tools:

- [ITI NYC Scraper](https://apify.com/parseforge/iti-nyc-scraper) - Extract New York technology and innovation listings
- [Monster Scraper](https://apify.com/parseforge/monster-scraper) - Collect job postings and career data
- [Auctiontime Scraper](https://apify.com/parseforge/auctiontime-scraper) - Gather vehicle auction listings and details
- [Instant Gaming Scraper](https://apify.com/parseforge/instant-gaming-scraper) - Extract video game titles and prices
- [HOA Documents Scraper](https://apify.com/parseforge/hoa-documents-scraper) - Collect homeowner association records

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create an account](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first results instantly. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Doximity or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

Direct URL to a Doximity directory page (e.g. /directory/md/specialty/cardiology). If provided, specialty and state filters below are ignored.

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

Free users: Limited to 10 items. Paid users: Optional, max 1,000,000.

## `specialty` (type: `string`):

Filter physicians by medical specialty (e.g. cardiology, dermatology, neurology). Used to build the directory URL.

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

Filter physicians by US state (e.g. new-york, california). Combined with specialty if both are provided.

## `includeDetails` (type: `boolean`):

When enabled, fetches each physician's full profile page to extract education, certifications, awards, publications, and professional memberships. Slower but more complete data.

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

Maximum number of parallel requests. Lower this if you get rate-limited.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between requests. Increase if the site rate-limits you.

## Actor input object example

```json
{
  "maxItems": 10,
  "specialty": "cardiology",
  "includeDetails": false,
  "maxConcurrency": 5,
  "requestDelayMs": 500
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "maxItems": 10,
    "specialty": "cardiology",
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/doximity-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 = {
    "maxItems": 10,
    "specialty": "cardiology",
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/doximity-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 '{
  "maxItems": 10,
  "specialty": "cardiology",
  "includeDetails": false
}' |
apify call parseforge/doximity-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doximity Physician Directory Scraper",
        "description": "Extract US physician profiles from Doximity — name, specialty, credentials, city, state, phone, fax, hospital affiliation, education, certifications, awards, publications, and professional memberships. Free preview caps at 10 profiles.",
        "version": "1.0",
        "x-build-id": "NJ5aG83efv35LxM05"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~doximity-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-doximity-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/parseforge~doximity-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-doximity-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/parseforge~doximity-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-doximity-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct URL to a Doximity directory page (e.g. /directory/md/specialty/cardiology). If provided, specialty and state filters below are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items. Paid users: Optional, max 1,000,000."
                    },
                    "specialty": {
                        "title": "Specialty",
                        "enum": [
                            "allergy-immunology",
                            "anesthesiology",
                            "cardiology",
                            "colon-rectal-surgery",
                            "dermatology",
                            "emergency-medicine",
                            "endocrinology",
                            "family-medicine",
                            "gastroenterology",
                            "general-surgery",
                            "geriatrics",
                            "hematology",
                            "infectious-disease",
                            "internal-medicine",
                            "interventional-radiology",
                            "medical-genetics",
                            "nephrology",
                            "neurology",
                            "neurosurgery",
                            "nuclear-medicine",
                            "obstetrics-gynecology",
                            "occupational-medicine",
                            "oncology",
                            "ophthalmology",
                            "orthopaedic-surgery",
                            "otolaryngology-ent",
                            "pathology",
                            "pediatric-cardiology",
                            "pediatrics",
                            "physical-medicine-rehab",
                            "plastic-surgery",
                            "psychiatry",
                            "pulmonology",
                            "radiation-oncology",
                            "radiology",
                            "rheumatology",
                            "thoracic-surgery",
                            "urology",
                            "vascular-surgery"
                        ],
                        "type": "string",
                        "description": "Filter physicians by medical specialty (e.g. cardiology, dermatology, neurology). Used to build the directory URL."
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "alabama",
                            "alaska",
                            "arizona",
                            "arkansas",
                            "california",
                            "colorado",
                            "connecticut",
                            "delaware",
                            "district-of-columbia",
                            "florida",
                            "georgia",
                            "hawaii",
                            "idaho",
                            "illinois",
                            "indiana",
                            "iowa",
                            "kansas",
                            "kentucky",
                            "louisiana",
                            "maine",
                            "maryland",
                            "massachusetts",
                            "michigan",
                            "minnesota",
                            "mississippi",
                            "missouri",
                            "montana",
                            "nebraska",
                            "nevada",
                            "new-hampshire",
                            "new-jersey",
                            "new-mexico",
                            "new-york",
                            "north-carolina",
                            "north-dakota",
                            "ohio",
                            "oklahoma",
                            "oregon",
                            "pennsylvania",
                            "rhode-island",
                            "south-carolina",
                            "south-dakota",
                            "tennessee",
                            "texas",
                            "utah",
                            "vermont",
                            "virginia",
                            "washington",
                            "west-virginia",
                            "wisconsin",
                            "wyoming"
                        ],
                        "type": "string",
                        "description": "Filter physicians by US state (e.g. new-york, california). Combined with specialty if both are provided."
                    },
                    "includeDetails": {
                        "title": "Include Full Profile Details",
                        "type": "boolean",
                        "description": "When enabled, fetches each physician's full profile page to extract education, certifications, awards, publications, and professional memberships. Slower but more complete data.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of parallel requests. Lower this if you get rate-limited.",
                        "default": 5
                    },
                    "requestDelayMs": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between requests. Increase if the site rate-limits you.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
