# Doctors Email Scraper (`scrapers-hub/doctors-email-scraper`) Actor

📧 Doctors Email Scraper extracts verified doctor contact emails from public sources. Streamline lead gen, outreach, and research with fast, accurate results. Ideal for healthcare sales, marketing, and recruitment.

- **URL**: https://apify.com/scrapers-hub/doctors-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Doctors Email Scraper 📬

**Doctors Email Scraper** helps you find medical practices and extract their publicly available contact information—especially email addresses—so you can build a targeted doctor email list faster. If you’re looking for a **doctors email scraper**, a **medical doctors email finder**, or a **healthcare email scraper**, this actor uses your **doctor-focused keywords** plus **location targeting** to return a structured dataset with contact details.  

Whether you’re a marketer, a researcher, or a data analyst building a **doctor contact email database**, you can use this to automate the tedious “find the right contact” workflow and save hours of manual work at scale.

---

### Why choose Doctors Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one workflow** (business discovery + website scraping) | Extract emails, phone numbers, and social media profiles in one run |
| ✅ **Reliability with fallback logic** | Includes resilient scraping behavior so the run keeps going even when some pages fail |
| ✅ **Email-focused output control** | Supports an email-only mode so you can prioritize results for outreach |
| ✅ **Structured dataset output** | Saves consistently shaped rows you can export to JSON/CSV for analysis |
| ✅ **Scales across multiple locations** | Works with one or many `googleMapsLocation` entries with configurable result limits |
| ✅ **Proxy configuration support** | Lets you set proxy settings for more stable large-scale scraping |

---

### Key features

- 🧾 **Doctor-focused contact extraction**: Searches by your business type keyword and extracts contact details from associated websites  
- 🌐 **Website-based email discovery**: Scrapes publicly available pages to collect emails, phones, and social media profiles  
- 🛡️ **Resilience and safe execution**: Handles failures per business and keeps the run moving  
- 🔄 **Controlled limits for predictable output**: Stops when it reaches your `maxBusinesses` target (and can enforce per-location limits)  
- 💾 **Real-time dataset saving**: Pushes results to the Apify dataset as scraping progresses  
- 🎯 **Email-only mode support**: Optionally saves only businesses where email addresses are found  
- 📊 **Rich contact context**: Outputs rating and review counts where available, plus address and geolocation fields  
- 🔗 **Structured arrays for multi-value fields**: Includes `scraped_emails`, `scraped_phones`, and `scraped_social_media` in the dataset view

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "googleMapsSearchTerm": "Doctors",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | Yes | The business type or niche you want the doctor email scraper to look for (example: `dentists`). |
| `googleMapsLocation` | Yes | One or more geographic targets to search within (example: `Miami, Florida` or a list like `["New York"]`). |
| `maxBusinesses` | No | The target number of businesses to find **with emails**. The actor stops when this target is reached (allowed range: 1–1000). |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the actor collects up to `maxBusinesses` results **per location**. If disabled, it combines all locations into a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. This is recommended for larger runs to reduce the risk of rate limits and blocks. |
| `• proxy support` | No | When set to `true`, the actor uses Apify Proxy as the default proxy configuration. |

***

### Output

The actor saves your results in the **Apify dataset** under the default view “Businesses with Contact Information”.

```json
{
  "name": "Example Medical Practice",
  "website": "https://exampleclinic.com",
  "phone": "+1-555-123-4567",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": ["contact@exampleclinic.com"],
  "scraped_phones": ["+1-555-987-6543"],
  "scraped_social_media": ["https://www.linkedin.com/company/exampleclinic"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.6,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "PLACE_ID_VALUE",
  "scrape_status": "success"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name |
| `website` | string | Business website URL |
| `phone` | string | Phone number associated with the business listing |
| `full_address` | string | Combined formatted address |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | ZIP/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Extracted email addresses from the business website |
| `scraped_phones` | array | Extracted phone numbers from the business website |
| `scraped_social_media` | array | Extracted social media links from the business website |
| `emails_found` | number | Count of emails found for the business |
| `pages_scraped` | number | Number of pages processed during website scraping |
| `avg_rating` | number | Average rating (when available) |
| `total_reviews` | number | Total review count (when available) |
| `lat` | number | Latitude |
| `long` | number | Longitude |
| `place_id` | string | Place identifier |
| `scrape_status` | string | Status of the scraping attempt (for example: `success`, `failed`, `no_website`, or `error`) |

**Export tip:** After the run completes, you can export the dataset from the Apify UI as JSON or CSV for use in your doctor email list workflows.

***

### How to use Doctors Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** page.

2. **Find Doctors Email Scraper**\
   Open the actor listing for **Doctors Email Scraper** to view the input form.

3. **Set your target niche keyword**\
   In **Search Term** (`googleMapsSearchTerm`), enter a doctor-related keyword (example: `Doctors` or `dentists`).

4. **Add one or more locations**\
   In **Location** (`googleMapsLocation`), add your city/region targets. The actor supports multiple locations.

5. **Choose your size limits**\
   Set `maxBusinesses` to control how many businesses-with-emails you want.\
   Optionally enable `scrapeMaxBusinessesPerLocation` if you want the limit applied separately to each location.

6. **Configure proxy settings (optional but recommended)**\
   In **Proxy Configuration**, you can keep `proxy support` enabled for more stable scraping on larger batches.

7. **Start the run**\
   Click **Run actor** and monitor the logs to see progress and how many results are being found.

8. **Open the dataset and export results**\
   After the run finishes, open the **dataset** output (default view: “Businesses with Contact Information”) and export to JSON/CSV.

No coding required—get doctors email scraping results in minutes. ✅

***

### Advanced features & SEO optimization

- 🔍 **Engineered for doctor email list building**: Built specifically to support **doctors email scraper** workflows like *find doctors email addresses* and *medical lead generation email scraper* use cases
- 🌐 **Website contact extraction**: Goes beyond listing info to pull emails plus related contacts like phones and social media from each business website
- 💡 **Keyword + location targeting**: Uses your `googleMapsSearchTerm` and `googleMapsLocation` to narrow results to the right healthcare provider category and geography
- 🧱 **Structured, analytics-friendly output**: Consistent fields like `scraped_emails`, `emails_found`, `avg_rating`, `total_reviews`, `lat`, and `long` make downstream processing straightforward
- 🛡️ **Proxy configuration support for stability**: Lets you apply proxy settings to help keep runs reliable when scaling across many targets

***

### Best use cases

- 🏥 **Healthcare marketers building lead lists**: Generate a **healthcare provider email list** for outreach campaigns in specific cities
- 📈 **B2B sales teams**: Enrich prospect records using a **doctor contact email database** with emails plus phone and social links
- 🔬 **Market researchers**: Compile **clinic email scraper** style datasets to study contact coverage by location and practice rating
- 🧑‍⚕️ **Private practice operators**: Find and verify outreach targets when doing networking, partnerships, or community initiatives
- 🏨 **Hospital outreach coordinators**: Build a **hospital email scraper** dataset for stakeholders and referrals
- 🗂️ **Data analysts**: Export a structured table (emails, pages scraped, ratings, reviews, geo fields) for modeling and reporting
- 💼 **Practice managers**: Quickly assemble a **practice manager email scraper**-friendly list for operational outreach and vendor communications

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm`: string (doctor or clinic niche keyword)
  - ✅ `googleMapsLocation`: array of strings (geographic targets)
- **Proxy Support**
  - ✅ `proxyConfiguration` object with `proxy support`
- **Retry Mechanism**
  - ✅ Includes resilience behaviors and fallbacks during scraping runs (exact retry tuning is handled internally)
- **Dataset Structure**
  - ✅ Saved to Apify dataset view “Businesses with Contact Information”
  - ✅ Includes fields: `scraped_emails`, `scraped_phones`, `scraped_social_media`, plus address, rating, review count, and geo fields
- **Rate Limits & Performance**
  - ✅ Designed for practical scaling by running website scraping across discovered businesses while respecting controlled limits
- **Limitations**
  - ❌ Businesses without a website cannot yield website-derived emails, and will be marked with an appropriate `scrape_status` such as `no_website`
  - ❌ Output depends on publicly available contact details found on websites

***

### FAQ

#### Does Doctors Email Scraper require coding?

✅ No. You configure `googleMapsSearchTerm`, `googleMapsLocation`, and your business limits in the Apify Console and then export the resulting dataset.

#### What kinds of contacts does Doctors Email Scraper extract?

✅ It extracts contact information including emails, phone numbers, and social media profiles from the businesses’ websites, and stores them in fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`.

#### How does it control the number of results?

✅ Use `maxBusinesses` to set the target number of businesses-with-emails. If you enable `scrapeMaxBusinessesPerLocation`, the actor applies `maxBusinesses` per location; otherwise it combines locations into a single total limit.

#### Is proxy support available for large scraping runs?

✅ Yes. You can configure `proxyConfiguration`, including `proxy support`, to improve stability when scraping at scale.

#### What does `scrape_status` mean in the dataset?

✅ `scrape_status` indicates the outcome of scraping for each business, such as `success`, `failed`, `no_website`, or `error`.

#### Can I validate emails?

✅ The code supports `validateEmails` as an input value (stored internally as `validate_emails`), but note that email validation behavior depends on the actor’s internal configuration and what’s available from the scraped sources.

#### Will it still save businesses that don’t have emails?

✅ By default, businesses are pushed with website-derived fields (and `scrape_status`). If you want email-only behavior, the actor includes an email-only mode internally—however, the dataset view primarily reflects the fields listed in the output schema.

#### Is the data sourced from public information?

✅ Yes. Doctors Email Scraper collects information only from publicly accessible sources.

***

### Support & feature requests

Want to improve **Doctors Email Scraper** for your **doctor email list** workflows? Share your ideas and feedback—our goal is to keep making the actor more useful for healthcare outreach and research.

- 💡 **Feature Requests:** Examples include additional export formats, more dataset fields, or enhancements to how contacts are organized in the output
- 📧 **Contact:** Reach out via <dataforleads@gmail.com>

User feedback shapes the roadmap—thanks for helping make this **doctors email scraper** even better. 🚀

***

*Doctors Email Scraper is built to make doctors email scraping for healthcare lead generation fast, structured, and scalable—without the manual spreadsheet grind.*

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages.

It’s your responsibility to comply with applicable laws (including GDPR and CCPA where relevant), spam regulations, and each website’s terms of service while using the data.

For data removal requests, contact: <dataforleads@gmail.com>. Please use **Doctors Email Scraper** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Doctors",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Doctors",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/doctors-email-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 = {
    "googleMapsSearchTerm": "Doctors",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/doctors-email-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 '{
  "googleMapsSearchTerm": "Doctors",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapers-hub/doctors-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doctors Email Scraper",
        "description": "📧 Doctors Email Scraper extracts verified doctor contact emails from public sources. Streamline lead gen, outreach, and research with fast, accurate results. Ideal for healthcare sales, marketing, and recruitment.",
        "version": "1.0",
        "x-build-id": "En7cqcbNONIpwY93z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~doctors-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-doctors-email-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/scrapers-hub~doctors-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-doctors-email-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/scrapers-hub~doctors-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-doctors-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Doctors"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
