# Usa Medical Services Extractor (`b2b_lead_generation/usa-medical-services-extractor`) Actor

US healthcare directory extractor that instantly searches and retrieves active medical, dental, and wellness listings across all US states. Export verified leads containing company names, emails, phones, physical addresses, and websites in seconds.

- **URL**: https://apify.com/b2b\_lead\_generation/usa-medical-services-extractor.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## USA Medical Services Extractor

<p align="center">
  <img src="https://imgur.com/huAKQPs.png" alt="USA Medical Services Extractor" style="max-width:100%; border-radius:14px; width:680px;" />
</p>

Search **American medical business records** by category keyword and registry sector. Results arrive instantly with ultra-fast search and dynamic retrieval. Each record includes the provider or facility name, contact phone, email address, full address, and website.

Type a category like `clinic`, `dentist`, or `therapy`, select your target sector filters, set your limit, and download a ready-to-use medical contact list in seconds.

### What you can do

- **Search any healthcare niche**: search family doctors, dentists, physical therapists, chiropractors, acupuncturists, and thousands more.
- **Filter by specific sector**: target dental clinics, alternative medicine practitioners, holistic health, and pediatricians independently.
- **Search multiple medical categories at once**: combine `Acupuncture`, `Chiropractor`, and `Dentist` in a single run.
- **Set your own result limit**: pull 100 records for a quick test or 10,000 for a full export.
- **Download in any format**: JSON, CSV, or Excel straight from the Apify dataset.

### Use cases

- **B2B medical outreach**: build contact lists of clinic owners who match your ideal customer profile, filtered by healthcare industry sector.
- **Cold email campaigns**: collect verified email addresses from any medical category across the USA to fuel your outreach sequences.
- **Healthcare recruitment and agency new business**: find clinics in your niche to pitch your staffing, marketing, or technical services to.
- **Market research**: map out the size of any medical sector by pulling all matching businesses across one or more regions.
- **Supplier and partner discovery**: identify medical equipment suppliers, local pharmacies, or service providers in specific categories.
- **Local medical directories**: build or refresh an online directory for any healthcare vertical or geographic region.

### Input

The category filters and result limit are optional. At least one target category is recommended.

#### Search and filter

| Parameter | Type | Description |
|-----------|------|-------------|
| `categories` | string list | One or more category keywords to search, one per line. The actor searches each in sequence and merges results. Partial match is supported: `acu` matches `Acupuncture clinic`, `Acupuncturist`, etc. |
| `sourceCategories` | string list | Specific medical directories or registries to filter by (e.g. `Acupuncture`, `Chiropractors`). One per line. Matches target registry directories. |
| `matchType` | select | Choose whether to match exact full words (`full_word`) or any character substring (`any_character`). Default: `any_character`. |
| `limit` | integer | Maximum records to return in this run. Default: `500`. Range: `100` to `10,000`. |

#### Example input: single category

```json
{
    "sourceCategories": ["Acupuncture"],
    "matchType": "any_character",
    "limit": 500
}
````

#### Example input: multiple categories

```json
{
    "sourceCategories": ["Acupuncture", "Chiropractor", "Dentist"],
    "matchType": "any_character",
    "limit": 3000
}
```

#### Example input: specific categories and registries

```json
{
    "categories": ["Acupuncture clinic", "Acupuncturist"],
    "sourceCategories": ["Acupuncture"],
    "matchType": "full_word",
    "limit": 2000
}
```

### Output data

Each record represents one American medical business contact. Results are written to your Apify dataset and can be exported as JSON, CSV, or Excel.

```json
{
    "name": "The Yinova Center Acupuncture",
    "categories": "Acupuncture clinic;Alternative medicine practitioner;Fertility clinic;Herb shop;Holistic medicine practitioner;Massage spa;Massage therapist;Perinatal center;Pregnancy care center",
    "phone": "+17189286533",
    "email": "appointments@yinovacenter.com",
    "address": "147 Remsen St, Brooklyn, NY 11201",
    "website": "https://www.yinovacenter.com/locations/brooklyn-heights/",
    "source_category": "Acupuncture",
    "scrapedAt": "2026-06-04T11:45:00.000Z"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Registered business name of the medical provider |
| `categories` | string | Business categories, semicolon-separated (e.g. `Acupuncture clinic;Alternative medicine practitioner`) |
| `phone` | string | Contact phone number in international format |
| `email` | string | Contact email address |
| `address` | string | Full physical address of the business |
| `website` | string | Business website URL |
| `source_category` | string | The source registry sector that this lead was extracted from |
| `scrapedAt` | string | ISO timestamp when the record was processed |

### Popular categories

These sectors return the most results. Select any in the `sourceCategories` filter, or enter any word in the `categories` filter. Partial and case-insensitive matching is supported.

#### Clinical & General Medical Services

| Category | Businesses it finds |
|---------|---------------------|
| `Healthcare_Providers` | Family doctors, pediatricians, local clinics, medical centers |
| `Medical_Clinic` | Outpatient centers, diagnostic clinics, general practitioners |
| `Eye_Care_Center` | Optometrists, opticians, eye exams, glasses and frames |
| `Doctor` | Specialized physicians, surgical practitioners, medical specialists |
| `Psychiatric_Services` | Psychiatrists, mental health therapy clinics, counseling |

#### Therapy, Physical & Rehabilitation

| Category | Businesses it finds |
|---------|---------------------|
| `Physical_Therapist` | Rehabilitation specialists, physiotherapy centers, sports recovery |
| `Physical_therapy_clinic` | Physiotherapist offices, clinical sports rehabilitation |
| `Massage_therapist` | Therapeutic massage, clinical massage practitioners |
| `Speech_Therapy_Services` | Speech and language pathologists, pediatric speech clinics |

#### Alternative, Holistic & Wellness

| Category | Businesses it finds |
|---------|---------------------|
| `Acupuncture` | Acupuncture clinics, acupuncturists, traditional Chinese medicine |
| `Alternative_medicine_practitioner` | Holistic health centers, naturopathic clinics, herbalists |
| `Holistic_medicine_practitioner` | Functional medicine, natural healing, integrative health specialists |
| `Chiropractor` | Chiropractic adjustments, spinal health clinics |
| `Wellness_center` | Health and wellness coaching, spas, holistic therapy centers |

#### Specialized & Family Care

| Category | Businesses it finds |
|---------|---------------------|
| `Fertility_clinic` | IVF centers, reproductive medicine, family planning |
| `Pregnancy_care_center` | Perinatal care, midwifery, prenatal health services |
| `Senior_Care_Services` | Assisted living, nursing home care, senior home aid agencies |
| `Medical_Genetic_Services` | DNA analysis clinics, genetic counselors, family lineage testing |

<p align="center">
  <img src="https://imgur.com/0maVi0S.png" alt="USA Medical Services Extractor" style="max-width:100%; border-radius:14px; width:680px;" />
</p>

### All USA Medical Services Categories: https://github.com/kawsarlog/automatic-text/blob/main/USA%20Medical%20All%20Categories.txt

### US states and major reference cities

The directory covers cities and towns across all US states. You can filter results geographically by exporting the dataset and sorting by address.

#### New York (NY)

New York City, Brooklyn, Buffalo, Rochester, Yonkers, Syracuse, Albany, White Plains, Queens, Flushing

#### California (CA)

Los Angeles, San Diego, San Jose, San Francisco, Fresno, Sacramento, Long Beach, Oakland, Bakersfield, Anaheim, Santa Ana, Riverside

#### Texas (TX)

Houston, San Antonio, Dallas, Austin, Fort Worth, El Paso, Arlington, Corpus Christi, Plano, Laredo, Lubbock, Garland

#### Florida (FL)

Jacksonville, Miami, Tampa, Orlando, St. Petersburg, Hialeah, Port St. Lucie, Tallahassee, Cape Coral, Fort Lauderdale, Pembroke Pines

#### Illinois (IL)

Chicago, Aurora, Rockford, Joliet, Naperville, Springfield, Peoria, Elgin, Waukegan, Cicero, Champaign

#### Pennsylvania (PA)

Pennsylvania (PA): Philadelphia, Pittsburgh, Allentown, Erie, Reading, Scranton, Bethlehem, Lancaster, Harrisburg, York

### Search tips

- **Use broad keywords**: `clinic` matches acupuncture clinic, eye clinic, sports clinic, and more in one search. Narrow with specific terms if you need precision.
- **Combine with categories**: running multiple specific category searches compiles all records into a single merged run.
- **Use the categories list**: run `sourceCategories: ["Acupuncture", "Chiropractor", "Healthcare_Providers"]` to pull all medical sectors in a single job.
- **Set limits high**: set to `5000` or `10000` when building a campaign outreach list. You can always filter the exported CSV further.
- **Partial match is on by default**: `Acup` also matches `Acupuncturist` and `Acupuncture clinic`. Use `"matchType": "full_word"` to reduce noise.

### How it works

1. Enter a category keyword describing the type of American medical business you are looking for.
2. Optionally select specific registry source categories to narrow down sectors.
3. Set how many records you want.
4. The platform retrieves matching businesses and writes them to your dataset as they arrive.
5. When the run finishes, download your contact list as JSON, CSV, or Excel.

### FAQ

**Why do some records have a blank email?**
Not every business has a publicly listed email address. Records with no email still include phone, address, and website, which are often enough for outreach.

**Why did I get fewer results than my limit?**
Only businesses matching your filters are returned. If 200 acupuncture clinics are indexed and you set limit to 500, you will receive 200 records. Try a broader keyword to get more.

**Can I search multiple categories in one run?**
Yes. Use the `categories` or `sourceCategories` fields and enter one keyword per line. The platform searches each in sequence and merges all results into a single dataset run.

**Does partial matching work?**
Yes. `acu` matches `Acupuncture` and `Acupuncturist`. Use `"matchType": "full_word"` for exact matching.

**How do I export results?**
After the run completes, open the dataset in your Apify console and click Export. Choose JSON, CSV, or Excel. You can also connect to Google Sheets directly via Apify integrations.

**Is there a limit per run?**
The actor supports up to 10,000 records per run. For very large exports, split your categories to keep individual runs manageable.

### Integrations

Connect USA Medical Services Extractor with other tools using [Apify integrations](https://apify.com/integrations). Push results straight to Google Sheets, trigger a Zapier workflow, sync with your CRM via Make, or pipe data into Airbyte. Use [webhooks](https://docs.apify.com/integrations/webhooks) to fire actions the moment results are ready.

<p align="center">
  <img src="https://imgur.com/5JHNT0l.png" alt="USA Medical Services Extractor: sample results" style="max-width:100%; border-radius:12px; width:680px;" />
</p>

### Related actors

- [WooCommerce Website Scraper Email](https://apify.com/b2b_lead_generation/woocommerce-website-scraper-email): search WooCommerce stores by company name, country, ZIP code, employee count, and revenue.
- [Shopify Website Scraper Email](https://apify.com/b2b_lead_generation/shopify-website-scraper-email): search Shopify merchant records filtered by country, ZIP, employee count, and revenue.
- [Chrome Extension Scraper Email](https://apify.com/b2b_lead_generation/chrome-extension-scraper-email): extract developer contacts and metadata from Chrome Web Store extensions.

# Actor input Schema

## `categories` (type: `array`):

One or more category keywords to search (e.g. 'clinic', 'dentist', 'therapy'). Searches each in sequence and merges results. Partial matches are supported.

Full list of all USA Medical Service Categories: https://github.com/kawsarlog/automatic-text/blob/main/USA%20Medical%20All%20Categories.txt

## `sourceCategories` (type: `array`):

Specific medical directories/registries to filter by (e.g. 'Healthcare\_Providers', 'Medical\_Clinic', 'Acupuncture'). One per line. Matches exact target registry directories.

## `searchText` (type: `string`):

Optional search text to match against either the 'categories' or 'source\_category' columns.

## `matchType` (type: `string`):

How category queries should match: 'Any Character Match' matches substrings, while 'Full Word Match' matches whole words only.

## `limit` (type: `integer`):

Maximum number of filtered records to return. Min: 100, Max: 100000. Default: 500.

## Actor input object example

```json
{
  "categories": [
    "clinic"
  ],
  "matchType": "any_character",
  "limit": 500
}
```

# 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 = {
    "categories": [
        "clinic"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/usa-medical-services-extractor").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 = { "categories": ["clinic"] }

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/usa-medical-services-extractor").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 '{
  "categories": [
    "clinic"
  ]
}' |
apify call b2b_lead_generation/usa-medical-services-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b2b_lead_generation/usa-medical-services-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Usa Medical Services Extractor",
        "description": "US healthcare directory extractor that instantly searches and retrieves active medical, dental, and wellness listings across all US states. Export verified leads containing company names, emails, phones, physical addresses, and websites in seconds.",
        "version": "0.0",
        "x-build-id": "6YyJznZbRvM3i9uRY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~usa-medical-services-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-usa-medical-services-extractor",
                "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/b2b_lead_generation~usa-medical-services-extractor/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-usa-medical-services-extractor",
                "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/b2b_lead_generation~usa-medical-services-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-usa-medical-services-extractor",
                "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": {
                    "categories": {
                        "title": "Category Keywords",
                        "type": "array",
                        "description": "One or more category keywords to search (e.g. 'clinic', 'dentist', 'therapy'). Searches each in sequence and merges results. Partial matches are supported.\n\nFull list of all USA Medical Service Categories: https://github.com/kawsarlog/automatic-text/blob/main/USA%20Medical%20All%20Categories.txt",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceCategories": {
                        "title": "Source Registry Categories",
                        "type": "array",
                        "description": "Specific medical directories/registries to filter by (e.g. 'Healthcare_Providers', 'Medical_Clinic', 'Acupuncture'). One per line. Matches exact target registry directories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchText": {
                        "title": "General Search Text",
                        "type": "string",
                        "description": "Optional search text to match against either the 'categories' or 'source_category' columns."
                    },
                    "matchType": {
                        "title": "Match Type",
                        "enum": [
                            "any_character",
                            "full_word"
                        ],
                        "type": "string",
                        "description": "How category queries should match: 'Any Character Match' matches substrings, while 'Full Word Match' matches whole words only.",
                        "default": "any_character"
                    },
                    "limit": {
                        "title": "Max Results Limit",
                        "minimum": 100,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of filtered records to return. Min: 100, Max: 100000. Default: 500.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
