# Doctoralia Scraper (`solidcode/doctoralia-scraper`) Actor

\[💰 $30 / 1K doctors · $1.50 / 1K reviews] Extract doctors from Doctoralia across 11 countries — names, specialties, addresses, phones, GPS, ratings, services, prices, and patient reviews. Search by city and specialty, or paste profile URLs.

- **URL**: https://apify.com/solidcode/doctoralia-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.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.
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

## Doctoralia Scraper

Pull doctor and clinic data from Doctoralia at scale — full names, specialties, star ratings, opinion counts, clinic addresses with GPS coordinates, phone numbers, services with prices, next-available appointment slots, and complete patient reviews across 11 country sites. Built for healthcare marketers, medical recruiters, and clinic competitive-intelligence teams who need structured doctor and review data without collecting it profile by profile.

### Why This Scraper?

- **11 localized country sites in one actor** — Spain, Brazil, Mexico, Argentina, Chile, Peru, Colombia, Italy (MioDottore), Poland (ZnanyLekarz), Turkey (DoktorTakvimi), and Czech Republic (ZnamyLekar). Switch country with one dropdown.
- **Per-clinic GPS coordinates** — exact latitude and longitude on every clinic location, ready to plot on a map or join to your territory data.
- **Services with prices and currency** — each doctor's bookable services with name, description, and price (e.g. "Consulta ginecología €160"), including "from price" flags so you know which prices are starting estimates.
- **Full patient reviews, not just counts** — every opinion comes with the author name, star rating, ISO 8601 publish date, and the complete review text — capped exactly by your per-doctor limit.
- **Multiple clinic locations per doctor** — doctors practicing at several clinics return every address, postal code, phone, and online-payment flag, not just the primary one.
- **Next-available appointment and booking signal** — the soonest open slot plus a calendar-availability flag, so you can spot which professionals are actively taking new patients.
- **Aggregate rating and total opinion count** — the headline star average and lifetime opinion total on every doctor, alongside how many reviews this run collected.
- **Paste-a-URL or structured search** — drop in any doctor profile or search-results URL, or search by country, city, and specialty. No need to learn each country's taxonomy.

### Use Cases

**Healthcare Lead Generation**
- Build outreach lists of doctors by specialty and city with clinic phone numbers
- Map clinic locations by GPS to plan field-sales territories
- Target professionals offering specific paid services and price bands
- Identify doctors actively accepting new patients via next-available slots

**Market & Competitive Research**
- Benchmark service pricing across cities and specialties
- Track how many clinics a specialty has in a given metro
- Compare provider density between Spain, Italy, Brazil, and other markets
- Monitor which competitors offer online booking and online payment

**Reputation & Review Monitoring**
- Pull full patient review text to analyze sentiment for a clinic or specialty
- Track a doctor's rating and opinion volume over time
- Surface recurring complaints from low-star reviews
- Compile testimonials and star averages for marketing collateral

**Healthcare Recruitment**
- Source candidates by specialty, city, and country site
- Assess a candidate's public rating and patient feedback before outreach
- Map where target specialists practice across multiple clinics

### Getting Started

#### Search by Country, City, and Specialty

The simplest run — find dentists in Madrid:

```json
{
    "country": "es",
    "city": "Madrid",
    "specialty": "Dentist",
    "maxResults": 50
}
````

#### Doctors Without Reviews (Lighter, Faster)

Skip review collection when you only need doctor and clinic details:

```json
{
    "country": "it",
    "city": "Milano",
    "specialty": "Ginecologo",
    "includeReviews": false,
    "maxResults": 100
}
```

#### Paste Doctoralia URLs Directly

Mix doctor profiles and search-results pages from any country site:

```json
{
    "startUrls": [
        "https://www.doctoralia.es/maria-garcia-lopez/dentista/madrid",
        "https://www.miodottore.it/cardiologo/roma"
    ],
    "maxReviewsPerDoctor": 30
}
```

#### Full-Featured Example

```json
{
    "country": "br",
    "city": "São Paulo",
    "specialty": "Cardiologista",
    "maxResults": 200,
    "includeReviews": true,
    "maxReviewsPerDoctor": 50
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Doctoralia doctor profile or search-results URLs. The most direct way to get exactly the doctors you want. Leave empty to use the search options below. |
| `country` | select | `Spain` | Which Doctoralia country site to search: Spain, Brazil, Mexico, Argentina, Chile, Peru, Colombia, Italy, Poland, Turkey, or Czech Republic. Used with City and Specialty; ignored when you paste URLs. |
| `city` | string | `""` | City or area to search within the chosen country (e.g. "Madrid", "São Paulo"). Leave empty to search the whole country. |
| `specialty` | string | `""` | Medical specialty to look for (e.g. "Dentist", "Cardiologist", "Psychologist"). Leave empty to include all specialties. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of doctors to collect. Set to 0 for no limit. Keep a limit to control cost. |
| `includeReviews` | boolean | `true` | Collect each doctor's patient reviews. Turn off for faster, cheaper runs when you only need doctor and clinic details. |
| `maxReviewsPerDoctor` | integer | `20` | Maximum reviews to collect per doctor. Set to 0 to collect all available reviews, up to a safety maximum of 5,000 per doctor. Popular doctors can have hundreds of reviews — a limit keeps runs fast and affordable. |

### Output

The dataset contains two kinds of rows, marked by a `recordType` field: one **doctor** row per professional, followed by one **review** row for each patient opinion collected for that doctor.

#### Doctor Records

```json
{
    "recordType": "doctor",
    "doctorId": "123456",
    "fullName": "Dr. María García López",
    "title": "Dra.",
    "gender": null,
    "profileUrl": "https://www.doctoralia.es/maria-garcia-lopez/ginecologo/madrid",
    "specialties": [
        { "id": 51, "name": "Ginecólogo" }
    ],
    "rating": 4.9,
    "opinionsTotal": 187,
    "reviewsCollected": 20,
    "locations": [
        {
            "clinicName": "Clínica Salud Mujer",
            "addressStreet": "Calle de Serrano 45",
            "city": "Madrid",
            "postalCode": "28001",
            "phone": "+34 911 234 567",
            "latitude": 40.4319,
            "longitude": -3.6883,
            "onlinePayment": true,
            "nextAvailable": "2026-06-15T09:30:00+02:00"
        }
    ],
    "services": [
        {
            "name": "Consulta ginecología",
            "description": "Primera visita y revisión",
            "price": 160,
            "isFromPrice": false
        }
    ],
    "insurances": ["Adeslas", "Sanitas"],
    "hasCalendar": true,
    "nextAvailable": "2026-06-15T09:30:00+02:00",
    "country": "es",
    "scrapedAt": "2026-06-12T14:30:00+00:00"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"doctor"` for these rows |
| `doctorId` | string | Stable Doctoralia doctor identifier |
| `fullName` | string | Doctor's full display name |
| `title` | string | Professional title or prefix (e.g. "Dr.", "Dra.") |
| `gender` | string | Reported gender when available |
| `profileUrl` | string | Canonical doctor profile URL |
| `specialties` | object\[] | Each specialty as `{ id, name }` |
| `country` | string | Country site the record came from |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

##### Ratings & Availability

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Average star rating |
| `opinionsTotal` | number | Total lifetime opinions on file |
| `reviewsCollected` | number | How many reviews this run collected for the doctor |
| `hasCalendar` | boolean | Whether online booking is offered |
| `nextAvailable` | string | Soonest open appointment (ISO 8601) when shown |

##### Locations & Services

| Field | Type | Description |
|-------|------|-------------|
| `locations` | object\[] | One entry per clinic — see fields below |
| `services` | object\[] | Bookable services as `{ name, description, price, isFromPrice }` |
| `insurances` | string\[] | Accepted insurance names |

Each `locations[]` entry contains: `clinicName`, `addressStreet`, `city`, `postalCode`, `phone`, `latitude`, `longitude`, `onlinePayment`, `nextAvailable`, `addressId` (the clinic's Doctoralia identifier), and `isOnlineOnly` (true for online-only consultations with no physical address).

#### Review Records

```json
{
    "recordType": "review",
    "doctorId": "123456",
    "doctorName": "Dr. María García López",
    "reviewId": "9876543",
    "authorName": "Laura M.",
    "rating": 5,
    "datePublished": "2026-05-28T10:15:00+02:00",
    "body": "Excelente trato y muy profesional. La consulta fue muy completa.",
    "isAnonymous": false,
    "country": "es",
    "scrapedAt": "2026-06-12T14:30:00+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` for these rows |
| `doctorId` | string | Identifier of the doctor this review belongs to |
| `doctorName` | string | Name of the reviewed doctor |
| `reviewId` | string | Stable review identifier |
| `authorName` | string | Display name of the review author |
| `rating` | number | Star rating given in this review |
| `datePublished` | string | When the review was posted (ISO 8601) |
| `body` | string | Full review text |
| `isAnonymous` | boolean | Whether the author was posted anonymously |
| `country` | string | Country site the review came from |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

### Tips for Best Results

- **Start small** — set `maxResults` to 25-50 on your first run to confirm the city and specialty return the doctors you expect, then scale up.
- **Control review spend with `maxReviewsPerDoctor`** — popular doctors can carry hundreds of reviews. A cap of 10-20 is plenty for sentiment sampling and keeps runs fast and affordable; set it to 0 only when you genuinely need every review (up to a safety maximum of 5,000 per doctor).
- **Turn off `includeReviews` for pure lead lists** — when you only need names, specialties, addresses, and phones, switching reviews off makes runs noticeably leaner.
- **Match the specialty word to the country language** — each site uses its own localized slugs. Use "Cardiologo" on the Italian site, "Cardiologista" in Brazil, and "Cardiólogo" in Spain. When in doubt, paste a search-results URL instead.
- **Paste URLs for precise targeting** — to scrape one specific doctor or an already-filtered search page, copy the URL straight from your browser; it works across all 11 country sites.
- **Combine sources in one run** — mix pasted profile URLs, pasted search URLs, and a structured city/specialty search together; results are deduplicated by doctor.

### Pricing

**Charged per doctor profile plus per review collected — from $30 per 1,000 doctor profiles + $1.50 per 1,000 reviews.** Each doctor carries an unbounded review collection, so a split keeps pricing fair: you pay the doctor rate once per professional, and only pay the review rate for the reviews you actually choose to collect. Bronze, Silver, and Gold subscribers pay progressively less.

#### Doctor Profiles

| Doctor profiles | No discount | Bronze | Silver | Gold |
|-----------------|-------------|--------|--------|------|
| 100 | $3.60 | $3.40 | $3.20 | $3.00 |
| 1,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 10,000 | $360.00 | $340.00 | $320.00 | $300.00 |
| 100,000 | $3,600.00 | $3,400.00 | $3,200.00 | $3,000.00 |

#### Reviews

| Reviews | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 1,000 | $1.80 | $1.70 | $1.60 | $1.50 |
| 10,000 | $18.00 | $17.00 | $16.00 | $15.00 |
| 100,000 | $180.00 | $170.00 | $160.00 | $150.00 |

**Example:** collecting 100 doctors with an average of 20 reviews each at Gold rates costs 100 × $0.030 + 2,000 × $0.0015 = **$3.00 + $3.00 = $6.00**, plus a small fixed per-run start fee.

No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Use `includeReviews` and `maxReviewsPerDoctor` to keep review spend exactly where you want it.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, recruitment, and reputation-monitoring use. The data includes information about named medical professionals and patient reviews — treat it as personal data. You are responsible for complying with applicable laws (including GDPR and other privacy regulations), the relevant Doctoralia site's Terms of Service, and any restrictions on processing health-related or personal data. Do not use extracted data for spam, harassment, or any unlawful purpose, and honor individuals' privacy and data-subject rights. </content> </invoke>

# Actor input Schema

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

Paste one or more Doctoralia URLs — doctor profiles, clinic pages, or search-results pages. This is the quickest way to get exactly the doctors you want. Leave empty to use the search options below instead.

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

Which Doctoralia country site to search. Only used with the City and Specialty search below — ignored when you paste URLs.

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

City or area to search within the chosen country, for example 'Madrid' or 'São Paulo'. Leave empty to search the whole country.

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

Medical specialty to look for, for example 'Dentist', 'Cardiologist', or 'Psychologist'. Leave empty to include all specialties.

## `maxResults` (type: `integer`):

Maximum number of doctors to collect. Set to 0 for no limit. We recommend keeping a limit to control cost.

## `includeReviews` (type: `boolean`):

Collect each doctor's patient opinions (reviews). Turn this off for faster, cheaper runs when you only need doctor and clinic details.

## `maxReviewsPerDoctor` (type: `integer`):

Maximum number of patient reviews to collect for each doctor. Set to 0 to collect all available reviews, up to a safety maximum of 5,000 per doctor. Popular doctors can have hundreds of reviews — a limit keeps runs fast and affordable. Only applies when 'Include Patient Reviews' is on.

## Actor input object example

```json
{
  "startUrls": [],
  "country": "es",
  "maxResults": 100,
  "includeReviews": true,
  "maxReviewsPerDoctor": 20
}
```

# Actor output Schema

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

Table of scraped doctors with key fields.

## `reviews` (type: `string`):

Table of patient reviews collected for the doctors.

# 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 = {
    "startUrls": [],
    "country": "es",
    "city": "",
    "specialty": "",
    "maxResults": 100,
    "includeReviews": true,
    "maxReviewsPerDoctor": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/doctoralia-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 = {
    "startUrls": [],
    "country": "es",
    "city": "",
    "specialty": "",
    "maxResults": 100,
    "includeReviews": True,
    "maxReviewsPerDoctor": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/doctoralia-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 '{
  "startUrls": [],
  "country": "es",
  "city": "",
  "specialty": "",
  "maxResults": 100,
  "includeReviews": true,
  "maxReviewsPerDoctor": 20
}' |
apify call solidcode/doctoralia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doctoralia Scraper",
        "description": "[💰 $30 / 1K doctors · $1.50 / 1K reviews] Extract doctors from Doctoralia across 11 countries — names, specialties, addresses, phones, GPS, ratings, services, prices, and patient reviews. Search by city and specialty, or paste profile URLs.",
        "version": "1.0",
        "x-build-id": "j3uGTIv4k8jRMKwKA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~doctoralia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-doctoralia-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/solidcode~doctoralia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-doctoralia-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/solidcode~doctoralia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-doctoralia-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": {
                    "startUrls": {
                        "title": "Doctoralia URLs",
                        "type": "array",
                        "description": "Paste one or more Doctoralia URLs — doctor profiles, clinic pages, or search-results pages. This is the quickest way to get exactly the doctors you want. Leave empty to use the search options below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "es",
                            "br",
                            "mx",
                            "ar",
                            "cl",
                            "pe",
                            "co",
                            "it",
                            "pl",
                            "tr",
                            "cz"
                        ],
                        "type": "string",
                        "description": "Which Doctoralia country site to search. Only used with the City and Specialty search below — ignored when you paste URLs.",
                        "default": "es"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City or area to search within the chosen country, for example 'Madrid' or 'São Paulo'. Leave empty to search the whole country."
                    },
                    "specialty": {
                        "title": "Specialty",
                        "type": "string",
                        "description": "Medical specialty to look for, for example 'Dentist', 'Cardiologist', or 'Psychologist'. Leave empty to include all specialties."
                    },
                    "maxResults": {
                        "title": "Max Doctors",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of doctors to collect. Set to 0 for no limit. We recommend keeping a limit to control cost.",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Include Patient Reviews",
                        "type": "boolean",
                        "description": "Collect each doctor's patient opinions (reviews). Turn this off for faster, cheaper runs when you only need doctor and clinic details.",
                        "default": true
                    },
                    "maxReviewsPerDoctor": {
                        "title": "Max Reviews Per Doctor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of patient reviews to collect for each doctor. Set to 0 to collect all available reviews, up to a safety maximum of 5,000 per doctor. Popular doctors can have hundreds of reviews — a limit keeps runs fast and affordable. Only applies when 'Include Patient Reviews' is on.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
