# Doximity Directory Scraper (`automation-lab/doximity-directory-scraper`) Actor

Scrape public Doximity clinician directory profiles by specialty, location, or profile URL with public contacts and education fields.

- **URL**: https://apify.com/automation-lab/doximity-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## Doximity Directory Scraper

Extract public clinician directory and profile data from Doximity for healthcare recruiting, market research, and lead generation.

### What does Doximity Directory Scraper do?

Doximity Directory Scraper collects public clinician records from Doximity directory pages and profile pages.
It can start from specialty directories, location directories, clinician-type directories, or direct public profile URLs.
The actor is built for public data only and does not require a Doximity login.

### Who is it for?

Healthcare recruiters use it to build specialty/location candidate lists.
Medical sales teams use it to map public physician and practice contacts.
Staffing agencies use it to source clinicians by state, city, and specialty.
Market researchers use it to analyze public clinician distribution.
Partnership teams use it to enrich account lists with public profile URLs and roles.

### Why use this actor?

- 🩺 Healthcare-specific fields instead of generic page titles
- 🔎 Directory pagination support
- 📇 Optional public profile enrichment
- ⚙️ Low-memory HTTP implementation
- 📦 Clean tabular output for exports and integrations

### Data you can extract

| Field | Description |
| --- | --- |
| profileUrl | Public Doximity profile URL |
| name | Clinician name |
| credentials | MD, DO, NP, PA, PharmD, and similar credentials when visible |
| clinicianType | Directory category inferred from the source URL |
| specialty | Public specialty |
| subspecialty | Public subspecialty or focus area |
| city | Profile city |
| state | Profile state |
| postalCode | Public postal code when visible |
| jobTitle | Public role/title |
| organization | Public practice/organization clue when visible |
| address | Public address lines |
| phone | Public phone number when visible |
| fax | Public fax number when visible |
| summary | Public profile summary |
| education | Public education/training entries |
| profileImageUrl | Public profile image URL |
| sourceListingUrl | Directory page where the profile was found |
| scrapedAt | Timestamp for the scrape |

### How much does it cost to scrape Doximity clinician profiles?

The actor uses pay-per-event pricing.
A small start fee is charged per run and a per-record fee is charged for each clinician saved.
Formula-derived BRONZE pricing is $0.00011756 per saved clinician (about $0.12 per 1,000 records), with lower per-record rates on higher Apify tiers.
Actual Apify platform pricing is shown on the actor page before you run it.

### Quick start

1. Open the actor on Apify.
2. Paste one or more Doximity directory URLs.
3. Set Maximum clinicians.
4. Keep profile enrichment enabled if you need phone, address, summary, and education fields.
5. Run the actor and export the dataset.

### Example start URLs

```text
https://www.doximity.com/directory/md/specialty/cardiology
https://www.doximity.com/directory/location/tennessee/nashville
https://www.doximity.com/pub/mark-aaron-md
````

### Input options

#### Start URLs

Use Doximity directory, specialty, location, or public profile URLs.
If no start URL is supplied, the actor can build a directory URL from the clinician type and optional paths.

#### Clinician type

Choose physicians, nurse practitioners, physician assistants, or pharmacists.
This is used only when no explicit start URL is provided.

#### Specialty path

Paste a Doximity specialty path such as `/directory/md/specialty/cardiology`.
This overrides the clinician type fallback.

#### Location path

Paste a Doximity location path such as `/directory/location/tennessee/nashville`.
This is useful for city or state based research.

#### Maximum clinicians

Controls how many clinician records are saved.
Use a low number for test runs, then increase it for production runs.

#### Open profile detail pages

When enabled, the actor visits each public profile and extracts richer fields.
Disable it for faster directory-only collection when you only need names and profile URLs.

#### Delay between profile requests

Adds a polite pause between detail requests.
The default is conservative enough for small and medium runs.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.doximity.com/directory/md/specialty/cardiology" }
  ],
  "maxItems": 25,
  "enrichProfiles": true,
  "requestDelayMs": 250
}
```

### Example output

```json
{
  "profileUrl": "https://www.doximity.com/pub/som-a-bailey-do",
  "name": "Som A. Bailey",
  "credentials": "DO",
  "clinicianType": "md",
  "specialty": "Cardiology",
  "subspecialty": "Interventional Cardiology",
  "city": "Mount Vernon",
  "state": "OH",
  "postalCode": "43050",
  "jobTitle": "Physician",
  "organization": "1330 Coshocton Ave",
  "address": "1330 Coshocton Ave, Mount Vernon, OH 43050",
  "phone": "+1 740-393-9000",
  "fax": null,
  "summary": "Public profile summary text...",
  "education": ["Ohio University Heritage College of Osteopathic Medicine in Athens — Class of 2017"],
  "profileImageUrl": "https://doximity-res.cloudinary.com/...jpg",
  "sourceListingUrl": "https://www.doximity.com/directory/md/specialty/cardiology",
  "scrapedAt": "2026-05-31T08:11:33.798Z"
}
```

### Tips for better results

- ✅ Start with one specialty or one location for a quick test.
- ✅ Use profile enrichment when contact fields matter.
- ✅ Increase `maxItems` after confirming the first dataset looks right.
- ✅ Use Doximity's own directory paths instead of search-engine result URLs.
- ✅ Keep a small request delay for public profile detail runs.

### Common workflows

#### Recruit cardiologists in a target region

Use a cardiology specialty URL and filter the exported dataset by city or state.

#### Build a physician account list

Use a specialty directory, enable enrichment, and export profile URL, name, specialty, organization, address, and phone.

#### Research clinician coverage

Run several location pages and aggregate by specialty, city, and state.

### Integrations

Use the dataset with:

- Google Sheets for lead review
- Airtable for recruiting workflows
- HubSpot or Salesforce imports after your compliance review
- Clay or enrichment tools for additional public data matching
- Internal BI dashboards for healthcare market analysis

### 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/doximity-directory-scraper').call({
  startUrls: [{ url: 'https://www.doximity.com/directory/md/specialty/cardiology' }],
  maxItems: 25,
  enrichProfiles: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/doximity-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.doximity.com/directory/md/specialty/cardiology'}],
    'maxItems': 25,
    'enrichProfiles': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~doximity-directory-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.doximity.com/directory/md/specialty/cardiology"}],"maxItems":25,"enrichProfiles":true}'
```

### MCP integration

Connect Apify MCP with this actor:

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

Claude Code CLI setup:

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

MCP JSON config:

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

Example prompt: "Use the Apify Doximity Directory Scraper to collect 10 public cardiology profiles and summarize the cities, specialties, and public phone fields."

### MCP setup for Claude Code

Add the Apify MCP server with this actor enabled:

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

Then ask Claude Code to run the actor, inspect the dataset, and transform the output into CSV, JSONL, or a recruiting workflow.

### MCP JSON config

Use this server configuration in MCP-compatible clients:

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

### MCP prompts for Claude Desktop

- "Use the Apify Doximity Directory Scraper to find 25 public cardiology profiles and summarize locations."
- "Run the Doximity scraper for this location page and return profile URLs and phone numbers when public."
- "Create a CSV of public Doximity physician profiles from this specialty directory."

### MCP prompts for Claude Code

- "Run automation-lab/doximity-directory-scraper for this Doximity specialty URL and inspect the dataset schema."
- "Use the Doximity scraper dataset to generate a deduplicated lead list."
- "Call the Apify MCP Doximity tool with maxItems 10 and show the first 5 records as a markdown table."

### Data quality notes

Doximity pages can vary by profile.
Some public profiles include phone, fax, summary, and education fields.
Others may expose only a name, specialty, and location.
The actor returns `null` for public fields that are not present.

### Legality and responsible use

This actor is designed for publicly available Doximity directory and profile pages.
Do not use it to access private, logged-in, restricted, or personal account-only data.
Review Doximity's terms and your local laws before using exported data for outreach, recruiting, sales, or analytics.
You are responsible for compliance with privacy, anti-spam, and healthcare marketing regulations.

### FAQ

#### Does this actor require a Doximity login?

No. It only extracts data available in public directory and profile HTML.

#### Can I scrape direct profile URLs?

Yes. Add public `/pub/...` profile URLs to Start URLs and keep enrichment enabled.

### Troubleshooting

#### Why are some phone or fax fields empty?

The public profile may not show those fields.
Enable profile enrichment and verify the public Doximity page includes the field.

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

The directory may have fewer visible profiles from that start page, or the run may have reached the end of pagination.
Try a broader specialty or location page.

#### Why is profile enrichment slower?

The actor opens every public profile page to extract richer details.
Disable enrichment if you only need names and profile URLs.

### Related scrapers

Try other Automation Lab actors for healthcare and lead-generation workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/doctoralia-mexico-scraper
- https://apify.com/automation-lab/yelp-business-scraper
- https://apify.com/automation-lab/linkedin-company-scraper

### Changelog

Initial version extracts public Doximity directory links and optional profile details.

### Support

If a Doximity URL returns no records, share the input URL and run ID in an Apify issue so the actor can be checked against the current page structure.

### Limits

The actor does not log in, bypass access controls, or collect non-public information.
It only extracts fields visible in public HTML responses.

### Best practices

Run small tests first.
Export only the fields you need.
Deduplicate downstream by `profileUrl`.
Respect opt-out and compliance requirements in outreach workflows.

### Output schema stability

The dataset uses stable field names so automations can depend on predictable exports.
New fields may be added in the future, but existing field names are intended to remain compatible.

### Performance

The actor uses HTTP requests and Cheerio parsing, so it is lighter than browser-based scrapers.
Directory-only mode is fastest.
Profile enrichment is more complete and naturally makes more requests.

# Actor input Schema

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

Doximity directory URLs (specialty/location/type pages) or public profile URLs. Leave empty to use clinicianType/specialtyPath/locationPath.

## `clinicianType` (type: `string`):

Used only when Start URLs are empty.

## `specialtyPath` (type: `string`):

Optional Doximity specialty path, for example /directory/md/specialty/cardiology. Overrides Clinician type when Start URLs are empty.

## `locationPath` (type: `string`):

Optional Doximity location path, for example /directory/location/tennessee/nashville. Used when no Start URLs or specialty path are supplied.

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

Maximum number of clinician records to save.

## `enrichProfiles` (type: `boolean`):

When enabled, the actor visits each public profile to extract specialty, address, phone, summary, education, and image fields.

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

Polite delay between profile detail requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.doximity.com/directory/md/specialty/cardiology"
    }
  ],
  "clinicianType": "md",
  "specialtyPath": "/directory/md/specialty/cardiology",
  "maxItems": 10,
  "enrichProfiles": true,
  "requestDelayMs": 250
}
```

# 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.doximity.com/directory/md/specialty/cardiology"
        }
    ],
    "specialtyPath": "/directory/md/specialty/cardiology",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/doximity-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.doximity.com/directory/md/specialty/cardiology" }],
    "specialtyPath": "/directory/md/specialty/cardiology",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/doximity-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.doximity.com/directory/md/specialty/cardiology"
    }
  ],
  "specialtyPath": "/directory/md/specialty/cardiology",
  "maxItems": 10
}' |
apify call automation-lab/doximity-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doximity Directory Scraper",
        "description": "Scrape public Doximity clinician directory profiles by specialty, location, or profile URL with public contacts and education fields.",
        "version": "0.1",
        "x-build-id": "Dznhtd1v6w2lop86j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~doximity-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-doximity-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~doximity-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-doximity-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~doximity-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-doximity-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": "Start URLs",
                        "type": "array",
                        "description": "Doximity directory URLs (specialty/location/type pages) or public profile URLs. Leave empty to use clinicianType/specialtyPath/locationPath.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "clinicianType": {
                        "title": "Clinician type",
                        "enum": [
                            "md",
                            "nurse-practitioners",
                            "physician-assistants",
                            "pharmacists"
                        ],
                        "type": "string",
                        "description": "Used only when Start URLs are empty.",
                        "default": "md"
                    },
                    "specialtyPath": {
                        "title": "Specialty path or URL",
                        "type": "string",
                        "description": "Optional Doximity specialty path, for example /directory/md/specialty/cardiology. Overrides Clinician type when Start URLs are empty."
                    },
                    "locationPath": {
                        "title": "Location path or URL",
                        "type": "string",
                        "description": "Optional Doximity location path, for example /directory/location/tennessee/nashville. Used when no Start URLs or specialty path are supplied."
                    },
                    "maxItems": {
                        "title": "Maximum clinicians",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of clinician records to save.",
                        "default": 25
                    },
                    "enrichProfiles": {
                        "title": "Open profile detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each public profile to extract specialty, address, phone, summary, education, and image fields.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between profile requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between profile detail requests.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
