# Healthgrades Doctor Scraper - Physician & NPI Data (`memo23/healthgrades-doctor-scraper`) Actor

Scrape doctor & physician profiles from Healthgrades by specialty + US city, or paste /usearch and /physician URLs. One flat row per doctor: name, specialty, star rating, reviews, NPI, address, phone, insurance, telehealth. Optional profile enrichment: bio, education, languages.

- **URL**: https://apify.com/memo23/healthgrades-doctor-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 doctor profiles

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

## Healthgrades Doctor Scraper

Turn any [Healthgrades](https://www.healthgrades.com) search into clean, structured physician data. Search by **specialty + US city**, or paste **/usearch** and **/physician** URLs — and get one flat row per doctor with name, specialty, star rating, review count, NPI, address, phone, accepted insurance, telehealth and appointment availability. Flip on detail mode to add each doctor's biography, education, languages spoken, procedures and full office list.

Built for healthcare market research, provider-network and referral analysis, credentialing, and physician lead generation across every specialty.

#### How it works

![How the Healthgrades Doctor Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-healthgrades.png)

#### ✨ Why use this scraper?

- **Rich rows out of the box** — ~30 fields per doctor from the search results alone: name, specialty, star rating, review count, NPI, gender, years of experience, address, image, accepted insurance, telehealth and same-/next-day availability, plus Healthgrades badges (Recommended, Patient Favorite, HG Choice).
- **Two ways in** — specialty + location searches, or direct Healthgrades `/usearch` and `/physician` URLs. Mix them in one run.
- **Clean 200s, no captcha** — every request routes through US residential IPs with a real browser fingerprint, so you get the real page and full data.
- **Full profile on demand** — turn on *Scrape doctor profile pages* (or paste a physician URL) to add phone number, biography, education and training, languages spoken, procedures and the complete list of office locations.
- **No brittle DOM scraping** — reads Healthgrades' embedded app data, so the output stays stable when the page layout changes.
- **JSON, CSV, Excel or API** — pipe straight into your sheet, CRM, BI tool or pipeline. Billed per doctor.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Healthcare marketer | Build targeted physician lists by specialty and city for outreach campaigns |
| Market researcher | Measure provider density, rating distribution and telehealth adoption per specialty/market |
| Medical recruiter | Source physicians by specialty, location, experience and accepted insurance |
| Payer / network analyst | Map which providers accept which insurance and where they practice |
| Data / app builder | Seed a provider directory with structured doctor rows (NPI, specialty, address, ratings) |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Specialty + location | `Cardiology\|New York, NY` | Searches Healthgrades and paginates the doctor results |
| Specialty only | `Dermatology` | Searches that specialty nationwide |
| Search URL | `https://www.healthgrades.com/usearch?what=Cardiology&where=New+York` | Paginates that search's results |
| Physician URL | `https://www.healthgrades.com/physician/dr-jane-doe-abc12` | Scrapes that single doctor in full detail |

**Not supported:** patient records, appointment booking, login-only or account data, and anything behind a Healthgrades login. The actor reads only public search and physician-profile pages.

#### ⚙️ How it works

1. **Classify** every input — `Specialty|Location` pairs become search URLs; pasted URLs are sorted into search vs physician.
2. **Fetch** each page over a US residential IP with a real browser TLS fingerprint, so the full page is returned.
3. **Parse** the page's embedded app data — a search page yields ~20 doctors; the next-page sequence is followed automatically up to your limit.
4. **Enrich** each doctor from their profile page (when *Scrape doctor profile pages* is on): phone, biography, education, languages, procedures and every office.
5. **Emit** one flat, deduplicated row per doctor to the dataset.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | — | Searches in `Specialty\|Location` form, e.g. `Cardiology\|New York, NY`. Location optional. |
| `startUrls` | array | — | Healthgrades `/usearch` and `/physician` URLs. Auto-classified. |
| `scrapeDetails` | boolean | `false` | Also fetch each doctor's profile page for phone, biography, education, languages and procedures (~2× requests). Pasted physician URLs are always fully detailed. |
| `maxItems` | integer | `1000` | Max rows for the whole run. Free tier is additionally capped at 100. |
| `maxItemsPerSearch` | integer | `1000` | Max doctors per search / URL. |
| `maxConcurrency` | integer | `6` | Parallel requests. Keep moderate (4–8). |
| `maxRequestRetries` | integer | `15` | Retry budget per request on 403 / 429 / 5xx and network errors. |
| `proxy` | object | Apify Residential (US) | Applies to free-tier runs; paid runs use a built-in US residential pool. |

#### 📊 Output overview

Each dataset record is **one doctor**. Rows carry the search-card fields (name, specialty, rating, reviews, NPI, address, image, accepted insurance, telehealth, availability, badges) and — when *Scrape doctor profile pages* is on, or for pasted physician URLs — the detail fields (phone, biography, education, languages, procedures, full office list). Ratings are on a 0–5 star scale.

#### 📦 Output sample

```json
{
  "rowType": "doctor",
  "npi": "1730192837",
  "pwid": "gf28x",
  "name": "Dr. Satjit Bhusri, MD",
  "profileUrl": "https://www.healthgrades.com/physician/dr-satjit-bhusri-gf28x",
  "specialty": "Cardiology",
  "specialtyDescriptions": ["Cardiologist", "Interventional Cardiology Specialist"],
  "gender": "Male",
  "age": 47,
  "yearsExperience": 19,
  "rating": 4.5,
  "reviewCount": 62,
  "isRecommendedProvider": true,
  "isPatientFavorite": true,
  "isHgChoice": false,
  "acceptsNewPatients": true,
  "telehealthAvailable": true,
  "sameDayAppointments": false,
  "nextDayAppointments": true,
  "address": "635 Madison Ave Fl 11",
  "city": "New York",
  "state": "NY",
  "postalCode": "10022",
  "phone": "(212) 752-3464",
  "imageUrl": "https://d3euc9tf6ejmqe.cloudfront.net/…/provider.jpg",
  "insurances": ["Aetna", "Cigna", "UnitedHealthcare"],
  "insuranceCount": 41,
  "affiliatedHospitalIds": ["hg-12345"],
  "offices": [
    { "name": "Upper East Side Cardiology", "address1": "635 Madison Ave Fl 11", "city": "New York", "state": "NY", "postalCode": "10022", "phone": "(212) 752-3464" }
  ],
  "languages": ["English", "Hindi", "Punjabi", "Spanish"],
  "education": [
    { "type": "Medical School", "name": "SUNY Downstate", "completionYear": 2006 }
  ],
  "sourceMode": "physician",
  "scrapedAt": "2026-07-06T07:30:00.000Z"
}
````

#### 🗂 Key output fields

| Field | Type | Notes |
|---|---|---|
| `name` / `profileUrl` | string | Doctor name (with credentials) + canonical profile URL |
| `npi` | string | National Provider Identifier |
| `specialty` / `specialtyDescriptions` | string / string\[] | Primary specialty + descriptive titles |
| `rating` / `reviewCount` | number | Patient star rating (0–5) + number of survey responses |
| `yearsExperience` / `age` / `gender` | number / string | Practitioner demographics |
| `address` / `city` / `state` / `postalCode` | string | Primary practice address |
| `phone` | string | Primary office phone (with detail / on physician URLs) |
| `insurances` / `insuranceCount` | string\[] / number | Accepted insurance carriers |
| `acceptsNewPatients` / `telehealthAvailable` | boolean | Availability flags |
| `sameDayAppointments` / `nextDayAppointments` | boolean | Appointment availability |
| `isRecommendedProvider` / `isPatientFavorite` / `isHgChoice` | boolean | Healthgrades badges |
| `offices` | array | Every practice: name, address, city, state, ZIP, phone |
| `education` / `languages` / `procedures` / `biography` | — | Present with `scrapeDetails` / on physician URLs |

#### ❓ FAQ

**Can I get the doctor's email?** No. Healthgrades doesn't publish physician email addresses; the actor returns the public profile — name, specialty, ratings, NPI, address, office phone, accepted insurance and (with detail on) biography, education and languages.

**How many doctors can I get per search?** Healthgrades returns ~20 doctors per page and paginates deep (popular specialty + big city searches run to 100+ pages). Use `maxItemsPerSearch` to cap.

**What does *Scrape doctor profile pages* add?** The search row is already rich (~30 fields). Turning it on visits each doctor's profile to add the **phone number, biography, education and training, languages spoken, procedures and full office list** — at roughly double the requests. Physician URLs you paste are always fully detailed.

**Is the star rating 0–5 or 0–10?** Output is always normalized to a **0–5 star** scale, regardless of which internal scale the page used.

**Do I need to configure proxies?** No. US residential routing is built in (Healthgrades is a US site). Just give it specialties + cities or URLs.

#### 💬 Support

Found a bug or need an extra field? Open an issue on the [actor's Issues tab](https://apify.com/memo23/healthgrades-doctor-scraper/issues) and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom field, another provider directory (Vitals, Zocdoc, WebMD, NPI Registry), or a scheduled physician-data feed into your warehouse? Custom scraping and pipeline work is available on request.

#### 🔎 Explore more scrapers

Looking for more directory or company-data sources? Check out the other directory, review and marketplace scrapers in the same publisher's collection on the Apify Store.

***

### ⚠️ Disclaimer

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

The scraper accesses only publicly available Healthgrades search and physician-profile pages — no authenticated endpoints, no login-only or private data, and no patient information. Users are responsible for ensuring their use complies with Healthgrades' Terms of Service, applicable data-protection law (including GDPR and CCPA where relevant), and any professional or contractual obligations of their own organisation. Scraped data concerns healthcare professionals in their public professional capacity; use it lawfully and honour any opt-out or do-not-contact requirements.

***

### SEO Keywords

healthgrades scraper, scrape healthgrades, healthgrades doctor scraper, healthgrades physician scraper, doctor data extraction, physician directory scraper, healthgrades api, medical provider scraper, npi scraper, doctor ratings scraper, healthcare provider data, physician lead generation, scrape doctor profiles, healthgrades reviews scraper, doctor specialty scraper, medical directory scraper, physician contact scraper, healthgrades listings scraper, apify healthgrades, provider network data

# Actor input Schema

## `searchQueries` (type: `array`):

Searches in the form `Specialty|Location`, e.g. `Cardiology|New York, NY`, `Dermatology|Chicago, IL`, `Pediatrics|Austin, TX`. Location is optional (`Cardiology` alone searches nationwide). Each is searched and paginated.

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

Direct Healthgrades URLs — search pages (`https://www.healthgrades.com/usearch?what=Cardiology&where=New+York`) and/or physician profile URLs (`https://www.healthgrades.com/physician/dr-jane-doe-abc12`). Auto-classified.

## `scrapeDetails` (type: `boolean`):

For each doctor found in search, also fetch their profile page to add phone, biography, education, languages spoken, procedures and full office list. Richer rows, but ~2× the requests. Off = the search-card fields (already ~30 per doctor). Physician URLs you paste are always fully detailed.

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

Hard cap on rows across the entire run. Each row is one paid `doctor` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerSearch` (type: `integer`):

Cap per search query / URL. Healthgrades returns ~20 doctors per page. Default 1000.

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

Parallel HTTP requests. Keep this moderate (4–8) to stay under rate limits. Default 6.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh US residential IP. Default 15.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "Cardiology|New York, NY"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 1000,
  "maxConcurrency": 6,
  "maxRequestRetries": 15
}
```

# 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 = {
    "searchQueries": [
        "Cardiology|New York, NY"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/healthgrades-doctor-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 = {
    "searchQueries": ["Cardiology|New York, NY"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/healthgrades-doctor-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 '{
  "searchQueries": [
    "Cardiology|New York, NY"
  ],
  "startUrls": []
}' |
apify call memo23/healthgrades-doctor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Healthgrades Doctor Scraper - Physician & NPI Data",
        "description": "Scrape doctor & physician profiles from Healthgrades by specialty + US city, or paste /usearch and /physician URLs. One flat row per doctor: name, specialty, star rating, reviews, NPI, address, phone, insurance, telehealth. Optional profile enrichment: bio, education, languages.",
        "version": "0.1",
        "x-build-id": "auHsqILoxkeWDRdMI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~healthgrades-doctor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-healthgrades-doctor-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/memo23~healthgrades-doctor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-healthgrades-doctor-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/memo23~healthgrades-doctor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-healthgrades-doctor-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": {
                    "searchQueries": {
                        "title": "Specialty + location searches",
                        "type": "array",
                        "description": "Searches in the form `Specialty|Location`, e.g. `Cardiology|New York, NY`, `Dermatology|Chicago, IL`, `Pediatrics|Austin, TX`. Location is optional (`Cardiology` alone searches nationwide). Each is searched and paginated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Healthgrades URLs",
                        "type": "array",
                        "description": "Direct Healthgrades URLs — search pages (`https://www.healthgrades.com/usearch?what=Cardiology&where=New+York`) and/or physician profile URLs (`https://www.healthgrades.com/physician/dr-jane-doe-abc12`). Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape doctor profile pages",
                        "type": "boolean",
                        "description": "For each doctor found in search, also fetch their profile page to add phone, biography, education, languages spoken, procedures and full office list. Richer rows, but ~2× the requests. Off = the search-card fields (already ~30 per doctor). Physician URLs you paste are always fully detailed.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `doctor` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max doctors per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per search query / URL. Healthgrades returns ~20 doctors per page. Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. Keep this moderate (4–8) to stay under rate limits. Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh US residential IP. Default 15.",
                        "default": 15
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
