# Plastic Surgeon Directory Scraper (ASPS) (`jungle_synthesizer/plastic-surgeon-medspa-directory-scraper`) Actor

Scrape board-certified plastic surgeons from the ASPS find-a-surgeon directory. Returns name, board certs, practice address, phone, email, website, languages, NPI, and lat/lon — structured for B2B lead-gen in aesthetic medicine.

- **URL**: https://apify.com/jungle\_synthesizer/plastic-surgeon-medspa-directory-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN 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.

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

## ASPS Plastic Surgeon Directory Scraper

Scrape board-certified plastic surgeons from the [American Society of Plastic Surgeons](https://find.plasticsurgery.org) find-a-surgeon directory. Returns 26 fields per surgeon — name, board certifications, full practice address, phone, email, website, languages, NPI, geocoordinates, and more — sourced from the official ASPS member registry.

ASPS is the credentialing body that matters in this market. Member status means a surgeon passed the American Board of Plastic Surgery, which is the only board certification recognized by the American Board of Medical Specialties for plastic surgery. The directory holds roughly 8,000 members worldwide, and this actor turns it into structured B2B-grade data.

---

### Plastic Surgeon Directory Scraper Features

- Extracts 26 fields per surgeon, including full practice address with geocoordinates
- Sources data directly from the public ASPS member registry — board certification verified at the source
- Supports radial search anchored on US ZIP codes; comes with a curated 30-ZIP US metro sweep as the default
- Returns NPI numbers when surgeons have them on file, which is most US-based members
- Captures multilingual practice info — useful if you're segmenting for non-English-speaking markets
- No proxies, no browser, no captchas — just a clean HTML directory and a public JSON endpoint
- Page-bounded concurrency so you don't get throttled and don't have to think about it

---

### Who Uses ASPS Directory Data?

- **Aesthetic device sales reps (Allergan, Galderma, Cynosure, BTL, Sciton)** — build territory account lists filtered by metro
- **Practice management software vendors (Aesthetic Record, Mangomint, PatientNow)** — feed verified plastic surgeon contacts into outbound campaigns
- **Healthcare lead-gen agencies** — prospect a credentialed segment that's hard to verify any other way
- **Financing partners (CareCredit, Cherry, Alphaeon)** — identify board-certified practices for partnership outreach
- **Healthcare market researchers** — map geographic distribution of board-certified plastic surgeons across US metros
- **Recruiters placing into private practice** — source a clean list of credentialed surgeons by city and language

---

### How the Plastic Surgeon Directory Scraper Works

1. Pick anchor ZIP codes — leave the field empty to use the curated 30-metro US sweep, or pass your own list
2. The scraper paginates each ZIP's nearest-distance results from the ASPS find-a-surgeon endpoint
3. For each unique surgeon ID seen across all ZIPs, the actor fetches the full profile from the official ASPS member-info JSON endpoint
4. Records are deduplicated across ZIP overlaps and saved as flat JSON, one row per surgeon

---

### Input

```json
{
  "zipCodes": ["10001", "90210", "60601", "33139", "94102"],
  "maxPagesPerZip": 5,
  "maxItems": 100
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `zipCodes` | array of strings | curated 30-metro US sweep | Anchor ZIP codes for radial search. Each ZIP returns nearest surgeons sorted by distance. Leave empty to use the default sweep |
| `maxPagesPerZip` | integer | `5` | Maximum listing pages to crawl per ZIP. Each page returns up to 12 surgeons. Deep pagination works but yields heavy duplicates after ~30 pages |
| `maxItems` | integer | `100` | Hard cap on output records. Set to `0` for no limit |

#### Targeted ZIP Sweep

```json
{
  "zipCodes": ["90210", "10001", "33139"],
  "maxPagesPerZip": 10,
  "maxItems": 200
}
```

#### Full Default Sweep

```json
{
  "zipCodes": [],
  "maxPagesPerZip": 20,
  "maxItems": 0
}
```

Empty `zipCodes` triggers the built-in 30-metro list: New York, Beverly Hills, San Francisco, Chicago, Houston, Phoenix, Philadelphia, San Antonio, San Diego, Dallas, San Jose, Austin, Jacksonville, Fort Worth, Columbus, Charlotte, Indianapolis, Seattle, Denver, Washington DC, Boston, Nashville, Baltimore, Oklahoma City, Portland, Las Vegas, Louisville, Milwaukee, Albuquerque, and Miami Beach.

***

### Plastic Surgeon Directory Scraper Output Fields

```json
{
  "memberId": "72211",
  "memberName": "Jay Calvert MD",
  "firstName": "Jay",
  "lastName": "Calvert",
  "suffix": "",
  "boardCertifications": "American Board of Plastic Surgery, 2002",
  "npi": "",
  "languages": "English, French, Spanish",
  "paymentOptions": "",
  "addressLine": "465 N. Roxbury Drive Suite 1001",
  "city": "Beverly Hills",
  "state": "CA",
  "postalCode": "90210",
  "country": "United States",
  "phone": "1 (310) 777-8800",
  "fax": "",
  "email": "drcalvert@roxburysurgery.com",
  "website": "http://www.drcalvert.com",
  "latitude": 34.0662498474121,
  "longitude": -118.40860748291,
  "profileImage": "https://cdn.plasticsurgery.org/images/profile/crop-72211.jpg",
  "isInternational": false,
  "enableConsultRequests": true,
  "additionalLocations": "",
  "source": "asps",
  "profileUrl": "https://find.plasticsurgery.org/?member=72211",
  "scrapedAt": "2026-04-25T14:52:21.337Z"
}
```

| Field | Type | Description |
|---|---|---|
| `memberId` | string | ASPS member ID — stable surgeon identifier |
| `memberName` | string | Display name including credentials (e.g. `Randal Haworth MD`) |
| `firstName` | string | Surgeon first name |
| `lastName` | string | Surgeon last name |
| `suffix` | string | Name suffix when present (e.g. `MD, FACS`) |
| `boardCertifications` | string | Semicolon-separated certifications and years issued |
| `npi` | string | National Provider Identifier — 10 digits for US providers, blank for international |
| `languages` | string | Comma-separated languages spoken at the practice |
| `paymentOptions` | string | Comma-separated accepted payment options when listed |
| `addressLine` | string | Street address of primary practice location |
| `city` | string | City of primary practice |
| `state` | string | US state code or international subdivision |
| `postalCode` | string | ZIP or postal code |
| `country` | string | Country name as reported by ASPS |
| `phone` | string | Primary practice phone number |
| `fax` | string | Practice fax when listed |
| `email` | string | Practice contact email |
| `website` | string | Practice website URL |
| `latitude` | number | Geocoded latitude of primary practice address |
| `longitude` | number | Geocoded longitude of primary practice address |
| `profileImage` | string | URL to the surgeon's profile photo |
| `isInternational` | boolean | True for surgeons practicing outside the US |
| `enableConsultRequests` | boolean | Whether ASPS allows consult requests via the directory |
| `additionalLocations` | string | Pipe-separated extra practice locations when surgeons have multiple offices |
| `source` | string | Source directory — currently always `asps` |
| `profileUrl` | string | Direct link to the surgeon's ASPS profile |
| `scrapedAt` | string | ISO 8601 timestamp when the record was scraped |

***

### FAQ

#### How do I scrape the ASPS plastic surgeon directory?

The Plastic Surgeon Directory Scraper does it for you. Pass a list of ZIP codes and a per-ZIP page cap, and the actor returns deduplicated surgeon records sourced from the official ASPS find-a-surgeon endpoint. No browser, no proxy.

#### How many plastic surgeons does ASPS have?

ASPS has roughly 8,000 board-certified members worldwide. Coverage is densest in major US metros — Beverly Hills, Manhattan, and Miami Beach return the most surgeons per page.

#### How much does the Plastic Surgeon Directory Scraper cost to run?

The actor uses Apify's pay-per-event model: $0.10 per actor start plus $0.001 per surgeon saved. A 100-record run costs about $0.20 total. Larger runs scale linearly — 1,000 surgeons is roughly $1.10.

#### What's the difference between this and a RealSelf or Healthgrades scraper?

This actor only includes ASPS members, which is a higher-credentialed segment than RealSelf's broader provider directory. RealSelf includes injectors and non-board-certified providers. ASPS membership requires American Board of Plastic Surgery certification. If you only want surgeons whose credentials check out, ASPS is the right source.

#### Can I filter by procedure type?

Not directly. ASPS returns the full member roster matching your geographic search; procedure filters are not exposed in the public profile data. Filter post-hoc by board certification text or website domain if you need a procedure-specific subset.

#### Does the scraper need proxies?

No. ASPS serves the find-a-surgeon directory without any anti-bot protection — no Cloudflare, no PerimeterX, no captchas. Standard datacenter IPs work fine at the actor's default concurrency.

#### How current is the data?

The scraper returns whatever ASPS shows at the time of the run. Member rosters change slowly — annual or semi-annual updates are typical. Daily re-runs would be overkill; weekly or monthly is plenty.

***

### Need More Features?

Need additional fields, broader international coverage, or procedure-level filters? File an issue on the actor page or get in touch.

### Why Use This Plastic Surgeon Directory Scraper?

- **Source quality** — pulls directly from the official ASPS member registry, not a third-party aggregator
- **Clean output** — returns 26 structured fields per surgeon with geocoordinates, NPI, and full contact info, so you spend less time cleaning data and more time using it
- **No anti-bot setup** — works with the default proxy-free Apify configuration; there's nothing to tune

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `zipCodes` (type: `array`):

List of US ZIP codes to anchor the radial search. Each ZIP returns nearest surgeons sorted by distance. Leave empty to use a curated set of US metro centroids.

## `maxPagesPerZip` (type: `integer`):

Maximum number of listing pages to crawl per anchor ZIP (each page returns up to 12 surgeons). ASPS supports deep pagination but yields heavy duplicates after ~30 pages per ZIP.

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

Hard cap on output records. Stop crawling once this many unique surgeons have been saved. Set to 0 for no limit.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "zipCodes": [
    "10001",
    "90210",
    "60601",
    "33139",
    "94102"
  ],
  "maxPagesPerZip": 5,
  "maxItems": 100
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "zipCodes": [
        "10001",
        "90210",
        "60601",
        "33139",
        "94102"
    ],
    "maxPagesPerZip": 5,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/plastic-surgeon-medspa-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "zipCodes": [
        "10001",
        "90210",
        "60601",
        "33139",
        "94102",
    ],
    "maxPagesPerZip": 5,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/plastic-surgeon-medspa-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "zipCodes": [
    "10001",
    "90210",
    "60601",
    "33139",
    "94102"
  ],
  "maxPagesPerZip": 5,
  "maxItems": 100
}' |
apify call jungle_synthesizer/plastic-surgeon-medspa-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Plastic Surgeon Directory Scraper (ASPS)",
        "description": "Scrape board-certified plastic surgeons from the ASPS find-a-surgeon directory. Returns name, board certs, practice address, phone, email, website, languages, NPI, and lat/lon — structured for B2B lead-gen in aesthetic medicine.",
        "version": "0.1",
        "x-build-id": "XL78EEnKZql0zmPZp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~plastic-surgeon-medspa-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-plastic-surgeon-medspa-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/jungle_synthesizer~plastic-surgeon-medspa-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-plastic-surgeon-medspa-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/jungle_synthesizer~plastic-surgeon-medspa-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-plastic-surgeon-medspa-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": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "zipCodes": {
                        "title": "Anchor ZIP Codes",
                        "type": "array",
                        "description": "List of US ZIP codes to anchor the radial search. Each ZIP returns nearest surgeons sorted by distance. Leave empty to use a curated set of US metro centroids.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerZip": {
                        "title": "Max Pages Per ZIP",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of listing pages to crawl per anchor ZIP (each page returns up to 12 surgeons). ASPS supports deep pagination but yields heavy duplicates after ~30 pages per ZIP.",
                        "default": 5
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on output records. Stop crawling once this many unique surgeons have been saved. Set to 0 for no limit.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
