# Practo India Doctor Directory Scraper (`jungle_synthesizer/practo-doctor-scraper`) Actor

Extract 20+ fields from Practo.com doctor profiles — specialties, qualifications, experience, clinic details, fees, ratings, services, and medical registration number

- **URL**: https://apify.com/jungle\_synthesizer/practo-doctor-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.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

## Practo Doctor Scraper — India Healthcare Directory

Scrape doctor profiles from Practo.com, India's largest healthcare platform. Extract 20+ fields per doctor including specialties, qualifications, years of experience, clinic address, consultation fees, ratings, and medical council registration numbers — filtered by city and specialty.

Covers 50+ Indian cities and 50+ medical specialties. Practo indexes over 500,000 doctor profiles. The scraper runs a two-level crawl: listing pages for speed, individual profile pages for richer data.

---

### What Data Does This Scraper Extract?

With **detail pages enabled** (default), each record contains:

| Field | Type | Description |
|---|---|---|
| `doctorName` | string | Full name of the doctor |
| `specialty` | string | Primary medical specialty (e.g. "Dentist") |
| `subspecialties` | array | Additional specializations from the profile |
| `qualifications` | array | Degrees and credentials (e.g. `["MBBS", "MDS"]`) |
| `experienceYears` | number | Years of clinical experience |
| `clinicName` | string | Primary clinic or hospital name |
| `clinicAddress` | string | Full street address of the practice |
| `city` | string | City where the doctor practices |
| `locality` | string | Neighborhood or locality within the city |
| `consultationFee` | number | Consultation fee in INR |
| `ratingValue` | number | Aggregate patient rating (out of 100) |
| `reviewCount` | number | Total number of patient reviews |
| `recommendationPercent` | number | Percentage of patients who recommend this doctor |
| `patientStoriesCount` | number | Number of patient stories submitted |
| `services` | array | Medical services offered (e.g. root canal, scaling) |
| `awards` | array | Professional awards and recognitions |
| `registrationNumber` | string | Medical council registration number |
| `onlineConsultation` | boolean | Whether the doctor offers video consultations |
| `profilePhotoUrl` | string | URL to the doctor's profile photo |
| `profileUrl` | string | Full URL to the doctor's Practo profile |
| `scrapedAt` | string | ISO timestamp of when the record was scraped |

With **detail pages disabled** (`scrapeDetails: false`), the scraper saves listing-level fields only: name, specialty, experience, clinic name, locality, city, fee, recommendation percent, patient stories, and profile URL. Runs significantly faster.

---

### Practo Scraper Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `city` | string | `bangalore` | Indian city to search. Examples: `mumbai`, `delhi`, `hyderabad`, `chennai`, `pune` |
| `specialty` | string | (all doctors) | Medical specialty filter. Examples: `dentist`, `dermatologist`, `gynecologist`, `cardiologist`, `orthopedic-surgeon` |
| `maxItems` | integer | `50` | Maximum number of doctor profiles to return |
| `maxPages` | integer | `10` | Maximum number of listing pages to crawl (10 doctors per page) |
| `scrapeDetails` | boolean | `true` | Fetch full profile pages for qualifications, services, awards, and registration data |

Leave `specialty` empty to scrape all doctors in a city without a specialty filter.

---

### Sample Output

```json
{
  "doctorName": "Dr. Venkatesh M J",
  "specialty": "Dentist",
  "subspecialties": ["Cosmetic Dentist", "Oral and Maxillofacial Surgeon"],
  "qualifications": ["BDS", "MDS"],
  "experienceYears": 18,
  "clinicName": "Smile Care Dental Clinic",
  "clinicAddress": "12, 2nd Cross, Indiranagar, Bangalore, Karnataka",
  "city": "Bangalore",
  "locality": "Indiranagar",
  "consultationFee": 400,
  "ratingValue": 98,
  "reviewCount": 312,
  "recommendationPercent": 98,
  "patientStoriesCount": 312,
  "services": ["Root Canal Treatment", "Dental Implants", "Teeth Whitening", "Braces"],
  "awards": ["Best Dentist Award - IDA Bangalore 2021"],
  "registrationNumber": "KAR-12345",
  "onlineConsultation": false,
  "profilePhotoUrl": "https://assets.practo.com/practice_photo/venkatesh-mj.jpg",
  "profileUrl": "https://www.practo.com/bangalore/doctor/venkatesh-m-j-dentist",
  "scrapedAt": "2026-04-20T09:14:32.000Z"
}
````

***

### How to Use the Practo Doctor Scraper

#### Quick Start

1. Open the actor on Apify and click **Try for free**
2. Set `city` to your target city (e.g. `mumbai`)
3. Set `specialty` to your target specialty (e.g. `cardiologist`) — or leave blank for all doctors
4. Set `maxItems` to control dataset size
5. Leave `scrapeDetails` enabled for full profile data
6. Click **Start** and download results as JSON or CSV

#### Example Inputs

Scrape 100 dermatologists in Mumbai:

```json
{
  "city": "mumbai",
  "specialty": "dermatologist",
  "maxItems": 100,
  "maxPages": 10,
  "scrapeDetails": true
}
```

Fast listing-only scrape (no detail pages) for all doctors in Delhi:

```json
{
  "city": "delhi",
  "specialty": "",
  "maxItems": 500,
  "maxPages": 50,
  "scrapeDetails": false
}
```

Scrape gynecologists across Hyderabad:

```json
{
  "city": "hyderabad",
  "specialty": "gynecologist",
  "maxItems": 200,
  "maxPages": 20,
  "scrapeDetails": true
}
```

#### Via the Apify API

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('jungle_synthesizer/practo-doctor-scraper').call({
  city: 'bangalore',
  specialty: 'dentist',
  maxItems: 100,
  scrapeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

***

### Supported Cities

The scraper works with any city that Practo covers. Common options:

`bangalore` · `mumbai` · `delhi` · `hyderabad` · `chennai` · `pune` · `kolkata` · `ahmedabad` · `jaipur` · `lucknow` · `chandigarh` · `kochi` · `coimbatore` · `nagpur` · `bhopal`

Use the city slug as it appears in Practo URLs (lowercase, hyphen-separated for multi-word cities, e.g. `new-delhi`).

### Supported Specialties

`dentist` · `dermatologist` · `gynecologist` · `cardiologist` · `orthopedic-surgeon` · `pediatrician` · `neurologist` · `ophthalmologist` · `ent-specialist` · `psychiatrist` · `urologist` · `gastroenterologist` · `endocrinologist` · `pulmonologist` · `oncologist`

Leave `specialty` empty to scrape all available doctors in a city.

***

### Use Cases

- **Lead generation for medical device and pharma companies** — build contact lists of doctors filtered by specialty and city
- **Healthcare market research** — analyze consultation fee ranges, doctor density by specialty, and geographic distribution across Indian cities
- **Doctor credentialing and verification** — cross-reference medical council registration numbers with independent sources
- **Healthcare directory products** — populate or supplement your own India doctor directory with Practo data
- **Competitive benchmarking** — track how clinics and hospitals are represented on India's largest healthcare booking platform
- **Telemedicine and health-tech prospecting** — identify doctors offering online consultations for partnership outreach

***

### Pricing

This actor uses **pay-per-result** pricing. You are charged per doctor profile saved to the dataset.

- **With detail pages** (`scrapeDetails: true`): each profile triggers two HTTP requests (listing + detail page). Runs slower but returns 20+ fields.
- **Without detail pages** (`scrapeDetails: false`): one request per 10 doctors (full listing page). Faster and cheaper per record, but returns fewer fields.

Run a small test (`maxItems: 10`) to estimate cost before running large batches.

***

### Proxy and Rate Limit Notes

- **No proxy required.** Practo's public pages are served without Cloudflare or CAPTCHA. Standard datacenter IPs work without residential proxies.
- **Rate limiting:** Practo runs on Akamai CDN which enforces moderate rate limits. The scraper caps concurrency at 5 requests and includes automatic rate-limit handling.
- **robots.txt:** Practo's robots.txt permits crawling of doctor profiles and listing pages.
- **Memory:** 512 MB default. Sufficient for most runs. Increase to 1 GB for very large runs (1,000+ profiles with detail pages).

***

### FAQ

**How do I scrape all doctors in a city without filtering by specialty?**
Leave the `specialty` field empty. The actor will crawl `/bangalore/doctors` (or your chosen city) which returns all available doctors.

**How many doctor profiles does Practo have?**
Practo indexes over 500,000 doctor profiles across India. Coverage varies by city — Bangalore, Mumbai, and Delhi have the densest listings.

**Can I scrape multiple cities in one run?**
The actor takes one city per run. Run it multiple times with different city inputs, or use the Apify scheduler to queue runs for each city.

**What is the difference between `scrapeDetails: true` and `scrapeDetails: false`?**
With detail pages enabled, the actor visits each doctor's individual profile page to extract qualifications, subspecialties, services, awards, registration numbers, and full clinic addresses from JSON-LD structured data. Without detail pages, only the 10 fields visible on the listing card are returned.

**How current is the data?**
The scraper returns whatever Practo shows at the time of the run. Practo profiles update in near real-time when doctors make changes. Run the actor on a schedule to keep your dataset fresh.

**Is it legal to scrape Practo?**
This actor scrapes publicly accessible pages that Practo serves to all visitors without login. The data collected (doctor names, specialties, fees, and clinic addresses) is publicly listed by the doctors themselves for patient discovery. Review Practo's terms of service and your jurisdiction's data protection regulations before using scraped data commercially.

***

Need custom features or a different specialty/city scope? Get in touch.

# 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.

## `city` (type: `string`):

Indian city to search doctors in (e.g. bangalore, mumbai, delhi, hyderabad, chennai)

## `specialty` (type: `string`):

Medical specialty to filter by (e.g. dentist, dermatologist, gynecologist, cardiologist). Leave empty for all doctors.

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

Maximum number of doctor profiles to scrape

## `maxPages` (type: `integer`):

Maximum number of listing pages to crawl (10 doctors per page)

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

Fetch full profile pages for richer data (qualifications, services, awards, registration). Slower but more comprehensive.

## 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...",
  "city": "bangalore",
  "specialty": "dentist",
  "maxItems": 50,
  "maxPages": 10,
  "scrapeDetails": true
}
```

# 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...",
    "city": "bangalore",
    "specialty": "dentist",
    "maxItems": 50,
    "maxPages": 10,
    "scrapeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/practo-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "city": "bangalore",
    "specialty": "dentist",
    "maxItems": 50,
    "maxPages": 10,
    "scrapeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/practo-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "city": "bangalore",
  "specialty": "dentist",
  "maxItems": 50,
  "maxPages": 10,
  "scrapeDetails": true
}' |
apify call jungle_synthesizer/practo-doctor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Practo India Doctor Directory Scraper",
        "description": "Extract 20+ fields from Practo.com doctor profiles — specialties, qualifications, experience, clinic details, fees, ratings, services, and medical registration number",
        "version": "0.1",
        "x-build-id": "TJglG2ysCB27MLa9k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~practo-doctor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-practo-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/jungle_synthesizer~practo-doctor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-practo-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/jungle_synthesizer~practo-doctor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-practo-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": {
                    "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."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Indian city to search doctors in (e.g. bangalore, mumbai, delhi, hyderabad, chennai)",
                        "default": "bangalore"
                    },
                    "specialty": {
                        "title": "Specialty",
                        "type": "string",
                        "description": "Medical specialty to filter by (e.g. dentist, dermatologist, gynecologist, cardiologist). Leave empty for all doctors.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of doctor profiles to scrape",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max Listing Pages",
                        "type": "integer",
                        "description": "Maximum number of listing pages to crawl (10 doctors per page)",
                        "default": 10
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Fetch full profile pages for richer data (qualifications, services, awards, registration). Slower but more comprehensive.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
