# Clinical Trial  Aggregator Scraper (`datapilot/clinical-trial-aggregator-scraper`) Actor

Clinical Trial Scraper collects research studies from ClinicalTrials.gov using keyword and country filters. It extracts status, phase, sponsor, dates, and results, then outputs structured data via Apify. Ideal for medical research and analytics

- **URL**: https://apify.com/datapilot/clinical-trial-aggregator-scraper.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** Agents, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Clinical Trial Aggregator Scraper

🏥 **Clinical Trial Aggregator Scraper** is a powerful Apify Actor designed to discover and aggregate comprehensive **Clinical Trial** data from the official ClinicalTrials.gov database. This tool provides detailed **Clinical Trial** information including trial phases, status, sponsors, locations, and results availability. Whether you're conducting medical research, pharmaceutical analysis, or healthcare intelligence gathering, the Clinical Trial Aggregator Scraper delivers authoritative **Clinical Trial** data efficiently.

With direct API integration to ClinicalTrials.gov, pagination support, multi-field extraction, and real-time dataset integration, the Clinical Trial Aggregator Scraper ensures comprehensive discovery of relevant **Clinical Trial** opportunities and research data. It focuses on key **Clinical Trial** metrics including status, phase, sponsor information, and completion dates, making it an essential tool for **Clinical Trial** research and medical intelligence.

---

### 📋 Table of Contents

- [Features](#-features)
- [Data Source](#-data-source)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields)
- [Trial Statuses](#-trial-statuses)
- [Trial Phases](#-trial-phases)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Important Notes](#-important-notes)
- [Keywords](#-keywords)
- [Changelog](#-changelog)
- [Support](#-support)

---

### 🔥 Features

- **ClinicalTrials.gov API Integration** – Direct integration with official **Clinical Trial** database for authoritative data.
- **Keyword-Based Search** – Search **Clinical Trial** data by medical condition, drug name, or procedure.
- **Geographic Filtering** – Filter **Clinical Trial** studies by country of origin or location.
- **Multi-Status Aggregation** – Fetches **Clinical Trial** data with all statuses (Recruiting, Not recruiting, Active, Completed, etc.).
- **Comprehensive Field Extraction** – Extracts 10+ key fields including trial ID, title, phase, and sponsor information.
- **Pagination Support** – Automatically handles pagination to retrieve up to limit trials.
- **Phase Detection** – Identifies **Clinical Trial** phases (Phase 1, Phase 2, Phase 3, Phase 4, N/A).
- **Results Availability** – Indicates whether **Clinical Trial** results are available.
- **Date Tracking** – Captures trial start and completion dates.
- **URL Generation** – Creates direct links to **Clinical Trial** profiles on ClinicalTrials.gov.
- **Bulk Trial Processing** – Discovers and analyzes multiple **Clinical Trial** studies.
- **Pagination Efficiency** – Retrieves 100 trials per API request for optimal speed.
- **Rate Limiting** – Includes automatic delays to respect API limits.
- **Real-Time Dataset Push** – Pushes results to Apify Dataset with metadata.
- **Timestamp Recording** – Records scrape timestamp for audit trails.
- **Error Handling** – Graceful error handling with detailed logging.
- **Asyncio-Friendly** – Non-blocking async/await architecture.

---

### 🌍 Data Source

#### **ClinicalTrials.gov**

- **Authority**: U.S. National Library of Medicine (part of NIH)
- **Coverage**: 400,000+ clinical studies worldwide
- **Data Quality**: Official, authoritative government database
- **API**: Public REST API v2
- **Endpoint**: `https://clinicaltrials.gov/api/v2/studies`
- **Authentication**: No authentication required (public data)
- **Response Format**: JSON
- **Rate Limits**: Approximately 1 request per 200ms recommended
- **Completeness**: Includes international trials, US-based and foreign studies

---

### ⚙️ How It Works

The Clinical Trial Aggregator Scraper takes a medical condition or keyword as input and searches the ClinicalTrials.gov API. It retrieves **Clinical Trial** studies across all statuses, extracting key information from multiple API response sections. Results are paginated and pushed to the Apify Dataset with comprehensive metadata.

**Key Processing Steps:**

1. **Input Parsing** – Accept keyword and optional country filter from Actor input
2. **API Parameter Setup** – Configure ClinicalTrials.gov API request parameters
3. **Initial Search** – Query API with keyword and filters
4. **Pagination Loop** – Continue fetching until limit reached or no more results
5. **Data Extraction** – Extract fields from multiple protocol sections
6. **Trial Status Normalization** – Convert status codes to human-readable format
7. **Phase Detection** – Extract and format trial phases
8. **Results Checking** – Verify results availability flag
9. **URL Generation** – Create direct links to ClinicalTrials.gov profiles
10. **Dataset Push** – Push individual trial records to Apify Dataset
11. **Progress Logging** – Report collection progress
12. **Completion** – Summarize total trials collected

**Key Benefits:**

- Access authoritative **Clinical Trial** data from official government database
- Discover **Clinical Trial** opportunities for patients and researchers
- Research pharmaceutical pipeline and development
- Analyze **Clinical Trial** landscapes by condition or sponsor
- Monitor **Clinical Trial** recruitment and completion
- Identify emerging research areas
- Conduct competitive pharmaceutical analysis

---

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keyword` | string | required | Medical condition, drug name, or procedure to search **Clinical Trial** database |
| `country` | string | "" (empty) | Optional country filter (e.g., "United States", "Germany", "Japan") |
| `limit` | integer | `200` | Maximum **Clinical Trial** records to retrieve (1-10000) |

**Example Input:**

```json
{
  "keyword": "diabetes",
  "country": "",
  "limit": 300
}
````

**US-Based Trials Example:**

```json
{
  "keyword": "cancer immunotherapy",
  "country": "United States",
  "limit": 500
}
```

**Single Country Search:**

```json
{
  "keyword": "alzheimer",
  "country": "Germany",
  "limit": 200
}
```

***

### 📤 Output

The Actor pushes **Clinical Trial** records with the following structure:

| Field | Type | Description |
|-------|------|-------------|
| `trial_id` | string | NCT (National Clinical Trial) identifier (e.g., "NCT04567890") |
| `title` | string | **Clinical Trial** brief title/name |
| `status` | string | Current trial status (Recruiting, Active, Completed, etc.) |
| `phase` | string | Trial phase (Phase 1, Phase 2, Phase 3, Phase 4) |
| `sponsor` | string | Lead sponsor organization name |
| `start_date` | string | Trial start date (YYYY-MM-DD format) |
| `completion_date` | string | Planned or actual completion date |
| `results_available` | boolean | Whether **Clinical Trial** results are available |
| `url` | string | Direct link to ClinicalTrials.gov trial page |
| `scraped_at` | string | ISO 8601 scrape timestamp |

**Example Output Record:**

```json
{
  "trial_id": "NCT04567890",
  "title": "A Study to Evaluate the Efficacy and Safety of Drug ABC in Type 2 Diabetes",
  "status": "Recruiting",
  "phase": "Phase 2/Phase 3",
  "sponsor": "Pharmaceutical Company XYZ",
  "start_date": "2024-03-15",
  "completion_date": "2026-12-31",
  "results_available": false,
  "url": "https://clinicaltrials.gov/study/NCT04567890",
  "scraped_at": "2025-02-14T12:00:00Z"
}
```

**Completed Trial Example:**

```json
{
  "trial_id": "NCT03210456",
  "title": "Long-Term Safety and Efficacy of Treatment X in Cancer Patients",
  "status": "Completed",
  "phase": "Phase 3",
  "sponsor": "National Cancer Institute",
  "start_date": "2020-06-01",
  "completion_date": "2024-11-30",
  "results_available": true,
  "url": "https://clinicaltrials.gov/study/NCT03210456",
  "scraped_at": "2025-02-14T12:00:00Z"
}
```

***

### 🧰 Technical Stack

- **HTTP Requests:** requests library with asyncio executor
- **API:** ClinicalTrials.gov REST API v2 (JSON)
- **Async:** asyncio for concurrent operations
- **JSON:** Native JSON parsing
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment
- **Timeout:** 20 seconds per API request
- **Rate Limiting:** 0.2-second delay between API calls

### 📋 Trial Statuses

| Status | Description |
|--------|-------------|
| **Recruiting** | Currently enrolling participants |
| **Not Yet Recruiting** | Approved but not started enrollment |
| **Active, Not Recruiting** | Ongoing, no new participants accepted |
| **Enrolling by Invitation** | Only specific participants can join |
| **Suspended** | Temporarily halted |
| **Terminated** | Stopped before completion |
| **Completed** | Finished, final results may be available |
| **Withdrawn** | Never started or cancelled before initiation |

***

### 📊 Trial Phases

| Phase | Description |
|-------|-------------|
| **Phase 1** | Safety and dosage testing (20-100 volunteers) |
| **Phase 2** | Efficacy and side effects (100-500 volunteers) |
| **Phase 3** | Monitoring and effectiveness (1000-5000 volunteers) |
| **Phase 4** | Post-market monitoring and safety surveillance |
| **N/A** | No specific phase (observational, behavioral studies) |

***

### 🎯 Use Cases

- **Patient Research** – Find **Clinical Trial** opportunities for specific conditions
- **Drug Pipeline Analysis** – Research pharmaceutical **Clinical Trial** landscape
- **Competitor Analysis** – Monitor competitor **Clinical Trial** portfolios
- **Research Institution Analysis** – Track institution **Clinical Trial** activity
- **Market Opportunity Assessment** – Evaluate therapeutic area **Clinical Trial** activity
- **Regulatory Intelligence** – Monitor development stages and **Clinical Trial** progress
- **Recruitment Analysis** – Identify active **Clinical Trial** recruitment opportunities
- **Medical Literature Research** – Find trials for conditions covered in research
- **Healthcare Investment Analysis** – Assess pharmaceutical company **Clinical Trial** pipelines
- **Academic Research** – Discover related **Clinical Trial** studies
- **Patient Advocacy** – Compile **Clinical Trial** information for patient communities
- **Geographic Expansion** – Identify **Clinical Trial** availability by country
- **Results Tracking** – Monitor **Clinical Trial** completion and result publication
- **Biomarker Research** – Find trials with specific biomarker endpoints
- **Real-World Evidence** – Identify trials that might generate real-world data

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "keyword": "diabetes",
  "country": "",
  "limit": 300
}
```

#### **2. Run the Actor**

Click **Start** button. The Actor will:

- Query ClinicalTrials.gov API
- Fetch trials matching keyword
- Extract comprehensive trial data
- Handle pagination
- Push results to Dataset

#### **3. Monitor Progress**

Console shows:

```
Starting fetch for 'diabetes' - Fetching all statuses for maximum output.
Progress: 100 trials collected...
Progress: 200 trials collected...
Scraping finished. Total trials pushed to dataset: 287
```

#### **4. View & Download Results**

- **Results Tab**: All trial records
- **Export**: JSON, CSV, Excel
- **Filter**: By status or phase
- **Links**: Direct to ClinicalTrials.gov

***

### ⚙️ Configuration

#### **Keyword Types**

Medical condition:

```json
{
  "keyword": "diabetes"
}
```

Drug name:

```json
{
  "keyword": "metformin"
}
```

Procedure:

```json
{
  "keyword": "stem cell transplant"
}
```

#### **Country Filtering**

US only:

```json
{
  "country": "United States"
}
```

Multiple countries require multiple runs:

```json
{
  "keyword": "cancer immunotherapy",
  "country": "Germany"
}
```

#### **Limit Configuration**

Small sample (50 trials):

```json
{
  "limit": 50
}
```

Comprehensive (1000+ trials):

```json
{
  "limit": 1000
}
```

***

### 📈 Performance

#### **Processing Speed**

- \~2-5 seconds for 100 trials
- \~10-20 seconds for 300 trials
- \~30-60 seconds for 1000 trials
- Includes 0.2-second API rate limit delay

#### **Resource Usage**

- Memory: ~50-100MB
- CPU: ~15-20% during processing
- Network: ~500KB-2MB per search
- API calls: ~3-10 depending on limit

#### **Pagination**

- Fetches 100 trials per API request
- Automatic pagination handling
- Continues until limit or no more results

#### **Data Quality**

- **Authority**: Official government database (authoritative)
- **Completeness**: Comprehensive but not 100% complete
- **Currency**: Data updated by sponsors (not real-time)
- **Accuracy**: Depends on sponsor-submitted information
- **Verification**: Always verify with official ClinicalTrials.gov

#### **Best Practices**

- Use results for research, not medical advice
- Verify critical information independently
- Check original ClinicalTrials.gov pages for latest updates
- Monitor ongoing trials for status changes
- Review inclusion/exclusion criteria on original trial pages
- Contact trial sponsors for enrollment questions

### 📦 Changelog

#### v1.0.0 (February 2025)

**Initial Release:**

- ClinicalTrials.gov API v2 integration
- Keyword-based **Clinical Trial** search
- Country filtering support
- Multi-status trial aggregation
- Comprehensive field extraction (10+ fields)
- Automatic pagination handling
- Trial phase detection and normalization
- Trial status normalization
- Results availability checking
- URL generation for trial profiles
- Bulk trial processing
- Rate limiting (0.2s between requests)
- Asyncio executor for non-blocking requests
- Real-time Dataset push
- ISO 8601 timestamp recording
- Error handling and logging
- Configurable result limit (1-10000)

***

### 🧑‍💻 Support & Feedback

- **Issues:** Submit via Apify console
- **Documentation:** Check Actor details page
- **Community:** Apify forum discussions
- **Feature Requests:** Suggest improvements
- **Bug Reports:** Include keyword and errors

***

#### **Output Access**

- **Results Tab**: All trial records
- **Export**: JSON, CSV, Excel
- **Filter**: By status or phase
- **API**: Query via Apify API

**Disclaimer:**
Clinical Trial Aggregator Scraper is provided as-is for research purposes. Users are responsible for ensuring compliance with regulations. Always verify trial information with official ClinicalTrials.gov sources.

***

### 🎉 Get Started Today

**Deploy now for clinical trial research!**

Use for:

- 📚 Medical Research
- 🔬 Pharmaceutical Analysis
- 💊 Drug Pipeline Analysis
- 🏥 Healthcare Intelligence
- 📊 Market Research

**Perfect for:**

- Researchers
- Pharmaceutical Companies
- Healthcare Professionals
- Patients
- Investors
- Academic Institutions

***

**Last Updated:** February 2025\
**Version:** 1.0.0\
**Status:** Production Ready\
**Platform:** Apify Actor\
**Architecture:** Async/Await\
**API Source:** ClinicalTrials.gov v2\
**Data Quality:** Official/Authoritative

***

### 📚 Related Tools

- Smart Article Extractor
- Fast News Content Scraper
- Clinical Guidelines & Protocols Aggregator
- Business Social Media Finder

***

### 🏥 Clinical Trial Excellence

This Actor is optimized for **Clinical Trial** research with:

- ✅ Official ClinicalTrials.gov API integration
- ✅ Comprehensive field extraction
- ✅ Multi-status aggregation
- ✅ Automatic pagination
- ✅ URL generation
- ✅ Real-time Dataset integration
- ✅ Error recovery
- ✅ Production-ready code

# Actor input Schema

## `keyword` (type: `string`):

Condition, disease, or drug (e.g., Diabetes).

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

Filter by country (Leave empty for global).

## `limit` (type: `integer`):

Maximum number of trials to fetch. Increase this for more output.

## Actor input object example

```json
{
  "keyword": "Diabetes",
  "limit": 1000
}
```

# 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 = {
    "keyword": "Diabetes",
    "country": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/clinical-trial-aggregator-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 = {
    "keyword": "Diabetes",
    "country": "",
}

# Run the Actor and wait for it to finish
run = client.actor("datapilot/clinical-trial-aggregator-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 '{
  "keyword": "Diabetes",
  "country": ""
}' |
apify call datapilot/clinical-trial-aggregator-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clinical Trial  Aggregator Scraper",
        "description": "Clinical Trial Scraper collects research studies from ClinicalTrials.gov using keyword and country filters. It extracts status, phase, sponsor, dates, and results, then outputs structured data via Apify. Ideal for medical research and analytics",
        "version": "0.0",
        "x-build-id": "17v7Svf1nvdt6Hua0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datapilot~clinical-trial-aggregator-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datapilot-clinical-trial-aggregator-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/datapilot~clinical-trial-aggregator-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datapilot-clinical-trial-aggregator-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/datapilot~clinical-trial-aggregator-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datapilot-clinical-trial-aggregator-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",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Condition, disease, or drug (e.g., Diabetes)."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Filter by country (Leave empty for global)."
                    },
                    "limit": {
                        "title": "Max Trials",
                        "type": "integer",
                        "description": "Maximum number of trials to fetch. Increase this for more output.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
