# Bookimed.com Medical Tourism Scraper (`haketa/bookimed-scraper`) Actor

Scrape medical tourism clinics from Bookimed.com — world's #1 medical tourism platform with 1,600+ clinics across 50+ countries. Extract prices, ratings, reviews, doctors, success rates and certifications by country, city and procedure.

- **URL**: https://apify.com/haketa/bookimed-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Bookimed.com Medical Tourism Scraper

Extract medical tourism clinic data from **[Bookimed.com](https://us-uk.bookimed.com)** — the world's #1 medical tourism platform with 1,600+ verified clinics across 50+ countries. Covers plastic surgery, dental, IVF, oncology, cardiology, orthopedics and 20+ medical categories.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![Playwright](https://img.shields.io/badge/Engine-Playwright%20Chrome-green)]()

---

### What It Does

Scrapes Bookimed.com listing pages by country, city and/or procedure. Returns structured JSON for each clinic including name, rating, reviews, treatment prices, certifications, doctors and success rates.

**Default run (prefill input):** Scrapes clinics in Turkey, completes in under 3 minutes, and produces a non-empty dataset.

---

### How It Works

Bookimed uses server-side rendering with a "Load More" button for pagination. This actor:

1. Launches Chrome via Playwright
2. Navigates to listing page (country + optional city/procedure)
3. Clicks "Load More" button to expand results
4. Parses all clinic cards from the rendered HTML
5. Extracts name, rating, prices, certifications, doctor info
6. Optionally fetches individual clinic profiles for rich data

---

### Input

#### Quick Start (Default)

```json
{
  "countries": ["turkey"],
  "maxClinics": 50,
  "maxLoadMore": 10
}
````

#### Full Example

```json
{
  "countries": ["turkey", "thailand", "india"],
  "cities": ["istanbul"],
  "procedures": ["rhinoplasty-nose-job", "hair-transplant"],
  "language": "us-uk",
  "scrapeDetails": true,
  "maxClinics": 200,
  "maxLoadMore": 20,
  "requestDelay": 2000
}
```

#### Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `countries` | array | `["turkey"]` | Country slugs |
| `cities` | array | `[]` | City slugs (optional) |
| `procedures` | array | `[]` | Procedure slugs (optional) |
| `language` | string | `us-uk` | Site language (13 options) |
| `startUrls` | array | `[]` | Direct listing or clinic URLs |
| `scrapeDetails` | boolean | `false` | Fetch profile pages for rich data |
| `maxClinics` | integer | `50` | Total clinics cap |
| `maxLoadMore` | integer | `10` | Max "Load More" clicks per page |
| `proxyConfiguration` | object | Apify auto | Proxy settings |
| `requestDelay` | integer (ms) | `1500` | Delay between requests |

***

### Countries

| Slug | Country | Top Procedures |
|---|---|---|
| `turkey` | Turkey | Hair transplant, rhinoplasty, dental |
| `thailand` | Thailand | Cosmetic surgery, dental, gender reassignment |
| `india` | India | IVF, cardiac surgery, orthopedics |
| `germany` | Germany | Oncology, cardiac, orthopedics |
| `spain` | Spain | IVF, dental, cosmetic |
| `mexico` | Mexico | Dental, bariatric, cosmetic |
| `south-korea` | South Korea | Cosmetic surgery, dermatology |
| `israel` | Israel | Oncology, cardiac, IVF |
| `united-arab-emirates` | UAE | Dental, cosmetic, orthopedics |
| `czech-republic` | Czech Republic | Dental, cosmetic |
| `poland` | Poland | Dental, cosmetic |
| `hungary` | Hungary | Dental |
| `brazil` | Brazil | Cosmetic surgery |
| `colombia` | Colombia | Cosmetic, dental |
| `austria` | Austria | Orthopedics, cardiac |

***

### Procedures

| Slug | Procedure |
|---|---|
| `hair-transplant` | Hair Transplant |
| `rhinoplasty-nose-job` | Rhinoplasty |
| `dental-implant` | Dental Implant |
| `dental-veneers` | Dental Veneers |
| `ivf` | IVF / In Vitro Fertilization |
| `breast-augmentation` | Breast Augmentation |
| `gastric-sleeve` | Gastric Sleeve |
| `knee-replacement` | Knee Replacement |
| `hip-replacement` | Hip Replacement |
| `lasik-eye-surgery` | LASIK Eye Surgery |
| `liposuction` | Liposuction |
| `tummy-tuck` | Tummy Tuck |
| `facelift` | Facelift |

***

### Output

#### Search Mode (`scrapeDetails: false`)

```json
{
  "clinicName": "Quartz Hospital",
  "clinicUrl": "https://us-uk.bookimed.com/clinic/quartz-clinique/",
  "country": "Turkey",
  "city": "Istanbul",
  "rating": 4.7,
  "reviewCount": 129,
  "certifications": ["JCI"],
  "treatmentPrices": [
    { "treatment": "Mommy makeover", "min": 4500, "max": 7000, "currency": "USD" },
    { "treatment": "Liposuction", "min": 1500, "max": 2000, "currency": "USD" }
  ],
  "featuredDoctor": { "name": "Dr. Nur Afsar", "yearsExperience": 7 },
  "searchCountry": "turkey",
  "scrapedAt": "2026-05-04T09:00:00Z"
}
```

#### Detail Mode (`scrapeDetails: true`)

```json
{
  "clinicName": "Quartz Hospital",
  "clinicUrl": "https://us-uk.bookimed.com/clinic/quartz-clinique/",
  "country": "Turkey",
  "city": "Istanbul",
  "rating": 4.7,
  "reviewCount": 129,
  "certifications": ["JCI"],
  "patientsPerYear": 6500,
  "specialties": ["Plastic Surgery", "Aesthetic Medicine"],
  "successRates": { "rhinoplasty": 97.4, "breast augmentation": 96.3 },
  "patientOrigins": ["Europe", "Arab League", "USA"],
  "doctors": ["Dr. Nur Afsar", "Prof. Mehmet Yildiz"],
  "address": "Kartal, Istanbul, Turkey",
  "description": "Quartz Hospital is a leading plastic surgery clinic...",
  "scrapedAt": "2026-05-04T09:00:00Z"
}
```

***

### Languages

Bookimed publishes in 13 languages. Set `language` parameter:

| Code | Language | Subdomain |
|---|---|---|
| `us-uk` | English | us-uk.bookimed.com |
| `de` | German | de.bookimed.com |
| `ru` | Russian | ru.bookimed.com |
| `es` | Spanish | es.bookimed.com |
| `fr` | French | fr.bookimed.com |
| `ar` | Arabic | ar.bookimed.com |
| `tr` | Turkish | tr.bookimed.com |

***

### Technical Notes

- **Architecture**: Playwright Chrome for "Load More" button interaction
- **Pagination**: "Load More" button loads ~5 clinics per click
- **Proxy**: Works from datacenter IPs (no residential proxy needed)
- **Rate limiting**: Moderate. Default 1500ms delay is safe.
- **Memory**: Requires 1-4 GB (Playwright Chrome)

***

### Cost & Performance

| Mode | Speed | CU per 100 clinics |
|---|---|---|
| Search only | ~20-30/min | ~0.02 |
| With details | ~3-5/min | ~0.06 |

***

### Changelog

| Version | Date | Notes |
|---|---|---|
| 1.0.0 | 2026-05-04 | Initial release — Playwright extraction, Load More handling, price/rating/cert parsing, 13 languages |

# Actor input Schema

## `countries` (type: `array`):

Country slugs to search. Examples: 'turkey', 'thailand', 'india', 'germany', 'spain', 'mexico', 'south-korea', 'united-arab-emirates', 'czech-republic', 'poland'. See README for full list.

## `cities` (type: `array`):

City slugs to narrow search. Leave empty to search entire country. Examples: 'istanbul', 'antalya', 'bangkok', 'mumbai', 'barcelona'.

## `procedures` (type: `array`):

Procedure slugs to filter. Leave empty for all. Examples: 'hair-transplant', 'rhinoplasty-nose-job', 'dental-implant', 'ivf', 'knee-replacement', 'breast-augmentation', 'gastric-sleeve'.

## `language` (type: `string`):

Site language/region. Affects subdomain and content language.

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

Direct Bookimed.com listing or clinic profile URLs. Overrides country/city/procedure if provided.

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

Fetch individual clinic profile pages for rich data: full description, all doctors, success rates, patient origins, complete treatment list. Slower but much more complete.

## `maxClinics` (type: `integer`):

Maximum total clinics to scrape. Set 0 for unlimited.

## `maxLoadMore` (type: `integer`):

Maximum 'Load More' button clicks per listing page. Each click loads ~5 more clinics. Set 0 for unlimited.

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

Proxy settings. Bookimed works from datacenter IPs.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds.

## Actor input object example

```json
{
  "countries": [
    "turkey"
  ],
  "cities": [],
  "procedures": [],
  "language": "us-uk",
  "startUrls": [],
  "scrapeDetails": false,
  "maxClinics": 50,
  "maxLoadMore": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelay": 1500
}
```

# Actor output Schema

## `clinicName` (type: `string`):

Clinic display name

## `clinicUrl` (type: `string`):

Full Bookimed profile URL

## `country` (type: `string`):

Country name

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

City name

## `rating` (type: `string`):

Average rating (0-5)

## `reviewCount` (type: `string`):

Number of verified reviews

## `certifications` (type: `string`):

JCI, ISO and other accreditations

## `patientsPerYear` (type: `string`):

Annual patient volume

## `specialties` (type: `string`):

Medical specialties array

## `treatmentPrices` (type: `string`):

Treatment price list with ranges

## `featuredDoctor` (type: `string`):

Primary doctor name and experience

## `description` (type: `string`):

Clinic description text

## `successRates` (type: `string`):

Procedure success rates

## `patientOrigins` (type: `string`):

Countries patients come from

## `doctors` (type: `string`):

Doctor list with specialties

## `address` (type: `string`):

Clinic address

## `photos` (type: `string`):

Clinic photo URLs

## `verified` (type: `string`):

Bookimed verified clinic

## `searchCountry` (type: `string`):

Country used to find this clinic

## `searchCity` (type: `string`):

City used to find this clinic

## `searchProcedure` (type: `string`):

Procedure used to find this clinic

## `scrapedAt` (type: `string`):

ISO timestamp when scraped

# 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 = {
    "countries": [
        "turkey"
    ],
    "cities": [],
    "procedures": [],
    "startUrls": [],
    "maxClinics": 50,
    "maxLoadMore": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/bookimed-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 = {
    "countries": ["turkey"],
    "cities": [],
    "procedures": [],
    "startUrls": [],
    "maxClinics": 50,
    "maxLoadMore": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/bookimed-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 '{
  "countries": [
    "turkey"
  ],
  "cities": [],
  "procedures": [],
  "startUrls": [],
  "maxClinics": 50,
  "maxLoadMore": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/bookimed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bookimed.com Medical Tourism Scraper",
        "description": "Scrape medical tourism clinics from Bookimed.com — world's #1 medical tourism platform with 1,600+ clinics across 50+ countries. Extract prices, ratings, reviews, doctors, success rates and certifications by country, city and procedure.",
        "version": "0.0",
        "x-build-id": "plUVuVuSD1BG35INh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~bookimed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-bookimed-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/haketa~bookimed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-bookimed-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/haketa~bookimed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-bookimed-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": {
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Country slugs to search. Examples: 'turkey', 'thailand', 'india', 'germany', 'spain', 'mexico', 'south-korea', 'united-arab-emirates', 'czech-republic', 'poland'. See README for full list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities (optional)",
                        "type": "array",
                        "description": "City slugs to narrow search. Leave empty to search entire country. Examples: 'istanbul', 'antalya', 'bangkok', 'mumbai', 'barcelona'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "procedures": {
                        "title": "Procedures (optional)",
                        "type": "array",
                        "description": "Procedure slugs to filter. Leave empty for all. Examples: 'hair-transplant', 'rhinoplasty-nose-job', 'dental-implant', 'ivf', 'knee-replacement', 'breast-augmentation', 'gastric-sleeve'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "us-uk",
                            "de",
                            "ru",
                            "es",
                            "fr",
                            "it",
                            "pt",
                            "ar",
                            "ja",
                            "tr",
                            "pl",
                            "ro",
                            "hu"
                        ],
                        "type": "string",
                        "description": "Site language/region. Affects subdomain and content language.",
                        "default": "us-uk"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct Bookimed.com listing or clinic profile URLs. Overrides country/city/procedure if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Fetch individual clinic profile pages for rich data: full description, all doctors, success rates, patient origins, complete treatment list. Slower but much more complete.",
                        "default": false
                    },
                    "maxClinics": {
                        "title": "Max Clinics",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total clinics to scrape. Set 0 for unlimited.",
                        "default": 50
                    },
                    "maxLoadMore": {
                        "title": "Max Load More Clicks",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum 'Load More' button clicks per listing page. Each click loads ~5 more clinics. Set 0 for unlimited.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Bookimed works from datacenter IPs."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds.",
                        "default": 1500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
