# Clinical Trials API - Normalized ClinicalTrials.gov Data (`webdata_labs/clinical-trials-api`) Actor

\[💵 $4.00 / 1K] Clean, normalized clinical trials from ClinicalTrials.gov: parsed eligibility (inclusion/exclusion + age), phase, status, sponsors, interventions, outcomes, and flattened study sites with geo. Not a raw study dump.

- **URL**: https://apify.com/webdata\_labs/clinical-trials-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Developer tools, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 trial records

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

## Clinical Trials API - Normalized ClinicalTrials.gov Data

**Clean, normalized clinical trials straight from ClinicalTrials.gov.** Search by condition, drug, sponsor, location, status, or phase - or pull specific NCT IDs - and get analysis-ready trial records: parsed eligibility, normalized phase and status, sponsors, interventions, outcomes, and flattened study sites with geo coordinates.

ClinicalTrials.gov's raw v2 API hands back a deeply nested study object - 13 protocol modules, eligibility stored as one free-text blob, and a locations array that can exceed 1,000 sites for a single trial. Most "clinical trial scrapers" dump that raw mess on you. This Actor does the hard part: it parses the eligibility free text into inclusion and exclusion lists, converts age strings to numeric years, flattens and dedupes study sites and countries, and pulls phase, status, sponsor, enrollment, and outcomes into one tidy schema - so you get usable rows, not a JSON swamp.

### ✅ What you get / ❌ what this isn't

| This Actor gives you | This Actor is not |
|---|---|
| One normalized row per trial: status, phase, sponsor, enrollment, dates | Not a raw nested study JSON dump |
| Eligibility parsed into inclusion / exclusion lists + numeric age in years | Not medical advice or trial recommendations |
| Flattened, deduped study sites with city, country, status, and lat/lng | Not affiliated with or endorsed by ClinicalTrials.gov or the NIH |
| Search by condition, drug, sponsor, location, status, and phase | Not a source of patient-level or unpublished data |
| Direct fetch by NCT ID for known trials | Not a guarantee every field is populated by every sponsor |
| Reliable official-API reads (no anti-bot, no proxy needed) | Not a substitute for reading the full protocol record |

### 🔎 Why use this Actor

- Pull every recruiting trial for a condition or drug in seconds, already normalized.
- Build site-selection and competitive-intelligence tables across sponsors and phases.
- Power patient-recruitment search by condition plus geography with clean site rows.
- Skip the plumbing - eligibility parsing, age conversion, and site flattening are done.
- Feed clean trial rows into dashboards, newsletters, models, or LLM pipelines.

### 🗂️ What data you get

One row per trial:

| Field | Type | Description |
|---|---|---|
| `nctId`, `url` | string | Trial identifier and its ClinicalTrials.gov page |
| `briefTitle`, `officialTitle` | string | Public and official study titles |
| `overallStatus` | string | Recruitment status (RECRUITING, COMPLETED...) |
| `phase`, `phases` | string / array | Normalized trial phase |
| `studyType` | string | INTERVENTIONAL or OBSERVATIONAL |
| `conditions`, `keywords` | array | Conditions studied and indexing keywords |
| `interventions`, `interventionNames` | array | Drug/device/procedure arms |
| `leadSponsor`, `leadSponsorClass`, `collaborators` | string / array | Who runs and funds the trial |
| `enrollmentCount`, `enrollmentType` | number / string | Target or actual enrollment |
| `startDate`, `primaryCompletionDate`, `completionDate` | string | Key milestone dates |
| `firstPostedDate`, `lastUpdatePostedDate` | string | Registry posting dates |
| `sex`, `minimumAge`, `maximumAge` | string | Raw eligibility fields |
| `minimumAgeYears`, `maximumAgeYears` | number | Age parsed to numeric years |
| `healthyVolunteers`, `stdAges` | string / array | Volunteer policy and age groups |
| `inclusionCriteria`, `exclusionCriteria` | array | Eligibility parsed from free text |
| `primaryOutcomes`, `secondaryOutcomeCount` | array / number | Outcome measures and time frames |
| `briefSummary` | string | Plain-language study summary |
| `numLocations`, `numCountries`, `countries` | number / array | Site footprint |
| `locations` | array | Flattened sites: facility, city, state, country, status, lat/lng |

### 👥 Who it's for

- Pharma and biotech competitive-intelligence and portfolio teams.
- CROs and site-selection teams mapping where trials run and enroll.
- Patient-recruitment companies searching by condition and geography.
- Biotech investors and equity researchers tracking pipelines.
- Academic researchers, systematic reviewers, and data teams feeding clean trial rows downstream.

### Example tasks

- [Find recruiting breast cancer trials](https://apify.com/webdata_labs/clinical-trials-api/examples/find-recruiting-breast-cancer-trials)
- [Track a sponsor's trial pipeline](https://apify.com/webdata_labs/clinical-trials-api/examples/track-a-sponsors-trial-pipeline)
- [Find trials for a drug near a location](https://apify.com/webdata_labs/clinical-trials-api/examples/find-trials-for-a-drug-near-a-location)

### ⚙️ How to get clinical trial data

1. Open the Actor on Apify.
2. Enter a `condition`, `searchTerm`, `intervention`, `sponsor`, or `location` - or paste specific `nctIds`.
3. Optionally filter by recruitment `status` and `phases`.
4. Set how many trials to return (`maxItems`) and the per-trial site cap (`maxLocationsPerTrial`).
5. Run the Actor.
6. Open the `Clinical trials` dataset view.
7. Export JSON, CSV, Excel, HTML, or XML, or call the Actor through the Apify API.

### 📥 Input

```json
{
  "condition": "breast cancer",
  "status": ["RECRUITING"],
  "phases": ["2", "3"],
  "maxItems": 200,
  "maxLocationsPerTrial": 50
}
````

### 📤 Output

```json
{
  "recordType": "trial",
  "nctId": "NCT05774678",
  "url": "https://clinicaltrials.gov/study/NCT05774678",
  "briefTitle": "Trial Of PreoperAtive Radiation (TOPAz)",
  "overallStatus": "RECRUITING",
  "phase": "PHASE3",
  "studyType": "INTERVENTIONAL",
  "conditions": ["Breast Cancer"],
  "leadSponsor": "M.D. Anderson Cancer Center",
  "enrollmentCount": 126,
  "startDate": "2023-08-01",
  "primaryCompletionDate": "2026-12-31",
  "sex": "FEMALE",
  "minimumAgeYears": 18.0,
  "inclusionCriteria": ["Age 18 years or older"],
  "exclusionCriteria": ["Patients undergoing treatment for recurrent breast cancer"],
  "numLocations": 1,
  "numCountries": 1,
  "countries": ["United States"],
  "locations": [
    {"facility": "M D Anderson Cancer Center", "city": "Houston", "state": "Texas", "country": "United States", "status": "RECRUITING", "lat": 29.76328, "lng": -95.36327}
  ]
}
```

### 💵 How much does it cost?

The launch price is about `$4.00 / 1,000 trials`, tier-discounted for higher Apify plans. One trial record is one charged result. A search returning 200 trials is 200 results.

### 🔁 Run it on the Apify platform

Schedule recurring refreshes to track new and updated trials, call it from the Apify API, export to CSV/JSON/Excel, or connect the dataset to Make, Zapier, webhooks, a warehouse, or an LLM pipeline.

### ⚠️ Limits and caveats

- This Actor reads ClinicalTrials.gov's public v2 API. It is not affiliated with ClinicalTrials.gov or the NIH and provides no medical advice.
- **Eligibility parsing is best-effort.** Inclusion/exclusion lists are split from a free-text blob; unusual sponsor formatting may merge or miss a bullet. The raw fields are always preserved.
- **Site lists can be huge.** Some trials register 1,000+ sites; `numLocations` always reports the full count, while `locations` embeds up to `maxLocationsPerTrial` rows.
- Fields a sponsor did not provide are returned as `null` or empty arrays rather than guessed.
- Data reflects what sponsors have registered, which can lag actual trial activity.

### 🧩 Related Actors

- SEC Financials API - normalized income, balance sheet, and cash flow from EDGAR.
- Prediction Markets Scraper - odds, prices, and volume across Polymarket, Kalshi, and Manifold.
- Website Tech Stack Detector - find the tools a company's site runs.
- Greenhouse, Lever & Ashby Jobs Scraper - open roles across the top startup ATS.

### ❓ FAQ

#### How do I search for trials?

Fill any of `condition`, `searchTerm`, `intervention`, `sponsor`, or `location`, and optionally filter by `status` and `phases`. To pull known trials directly, paste their `nctIds` instead.

#### Where does the data come from?

ClinicalTrials.gov's official v2 REST API - the same registry the NIH publishes. It is free, public, and authoritative.

#### Why are some fields null or empty?

Because the sponsor did not register that field for that trial. Observational studies, expanded-access records, and older entries populate fewer fields than a large interventional trial.

#### How is age normalized?

The registry stores age as text like `18 Years` or `6 Months`. This Actor keeps the raw strings and adds `minimumAgeYears` / `maximumAgeYears` as numeric years (6 months becomes 0.5) so you can filter and compare.

#### Does it need a proxy?

No. ClinicalTrials.gov is a public API served from a CDN and works without a proxy. Enable Apify Proxy only on very large batches.

### 🛠️ Support

For bugs or missing fields, open an Actor issue with the run URL, the search or NCT ID, and the field or behavior you expected.

### ⭐ Rate this Actor

If this Actor saved you time, please take 30 seconds to leave a review on the **Reviews** tab of [Clinical Trials API - Normalized ClinicalTrials.gov Data](https://apify.com/webdata_labs/clinical-trials-api) - reviews are the main trust signal other users see, and they directly decide which features get built next. If something is broken or a field is missing, please [open an issue](https://apify.com/webdata_labs/clinical-trials-api/issues) first - we typically respond within a day and would love the chance to fix it before you rate.

# Actor input Schema

## `condition` (type: `string`):

Condition / disease to search for (maps to ClinicalTrials.gov query.cond). Example: 'breast cancer', 'type 2 diabetes'.

## `searchTerm` (type: `string`):

Free-text search across the whole study record (query.term). Use for drug names, keywords, or any term not covered by the other fields.

## `intervention` (type: `string`):

Intervention or drug name (query.intr). Example: 'pembrolizumab', 'semaglutide'.

## `sponsor` (type: `string`):

Lead sponsor or collaborator name (query.spons). Example: 'Pfizer', 'National Cancer Institute'.

## `location` (type: `string`):

Location filter (query.locn): country, state, or city. Example: 'United States', 'California', 'Boston'.

## `status` (type: `array`):

Filter by overall recruitment status. Leave empty for all statuses.

## `phases` (type: `array`):

Filter by trial phase. Codes: 0 = Early Phase 1, 1 = Phase 1, 2 = Phase 2, 3 = Phase 3, 4 = Phase 4. Leave empty for all phases.

## `nctIds` (type: `array`):

Fetch specific trials by NCT ID instead of searching. When set, search fields are ignored. Format: NCT00000000.

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

Maximum number of trials to return for a search. Newest/most-relevant first.

## `maxLocationsPerTrial` (type: `integer`):

Cap on flattened study sites embedded per trial row (some trials list 1,000+ sites). The full site count is always reported in numLocations. Set 0 to omit the locations array.

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

Optional. ClinicalTrials.gov is a public API and works without a proxy; enable Apify Proxy only for very large batches.

## Actor input object example

```json
{
  "condition": "breast cancer",
  "status": [],
  "phases": [],
  "nctIds": [
    "NCT04267848",
    "NCT04368728"
  ],
  "maxItems": 200,
  "maxLocationsPerTrial": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `OUTPUT` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "condition": "covid"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/clinical-trials-api").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 = { "condition": "covid" }

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/clinical-trials-api").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 '{
  "condition": "covid"
}' |
apify call webdata_labs/clinical-trials-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clinical Trials API - Normalized ClinicalTrials.gov Data",
        "description": "[💵 $4.00 / 1K] Clean, normalized clinical trials from ClinicalTrials.gov: parsed eligibility (inclusion/exclusion + age), phase, status, sponsors, interventions, outcomes, and flattened study sites with geo. Not a raw study dump.",
        "version": "0.1",
        "x-build-id": "TzZ2W2jBag7clZIFG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~clinical-trials-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-clinical-trials-api",
                "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/webdata_labs~clinical-trials-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-clinical-trials-api",
                "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/webdata_labs~clinical-trials-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-clinical-trials-api",
                "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": {
                    "condition": {
                        "title": "Condition or disease",
                        "type": "string",
                        "description": "Condition / disease to search for (maps to ClinicalTrials.gov query.cond). Example: 'breast cancer', 'type 2 diabetes'."
                    },
                    "searchTerm": {
                        "title": "Free-text search",
                        "type": "string",
                        "description": "Free-text search across the whole study record (query.term). Use for drug names, keywords, or any term not covered by the other fields."
                    },
                    "intervention": {
                        "title": "Intervention / drug",
                        "type": "string",
                        "description": "Intervention or drug name (query.intr). Example: 'pembrolizumab', 'semaglutide'."
                    },
                    "sponsor": {
                        "title": "Sponsor / organization",
                        "type": "string",
                        "description": "Lead sponsor or collaborator name (query.spons). Example: 'Pfizer', 'National Cancer Institute'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location filter (query.locn): country, state, or city. Example: 'United States', 'California', 'Boston'."
                    },
                    "status": {
                        "title": "Recruitment status",
                        "type": "array",
                        "description": "Filter by overall recruitment status. Leave empty for all statuses.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RECRUITING",
                                "NOT_YET_RECRUITING",
                                "ACTIVE_NOT_RECRUITING",
                                "ENROLLING_BY_INVITATION",
                                "COMPLETED",
                                "SUSPENDED",
                                "TERMINATED",
                                "WITHDRAWN",
                                "UNKNOWN"
                            ],
                            "enumTitles": [
                                "Recruiting",
                                "Not yet recruiting",
                                "Active, not recruiting",
                                "Enrolling by invitation",
                                "Completed",
                                "Suspended",
                                "Terminated",
                                "Withdrawn",
                                "Unknown"
                            ]
                        },
                        "default": []
                    },
                    "phases": {
                        "title": "Phase",
                        "type": "array",
                        "description": "Filter by trial phase. Codes: 0 = Early Phase 1, 1 = Phase 1, 2 = Phase 2, 3 = Phase 3, 4 = Phase 4. Leave empty for all phases.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0",
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "Early Phase 1",
                                "Phase 1",
                                "Phase 2",
                                "Phase 3",
                                "Phase 4"
                            ]
                        },
                        "default": []
                    },
                    "nctIds": {
                        "title": "Specific NCT IDs",
                        "type": "array",
                        "description": "Fetch specific trials by NCT ID instead of searching. When set, search fields are ignored. Format: NCT00000000.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max trials",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of trials to return for a search. Newest/most-relevant first.",
                        "default": 200
                    },
                    "maxLocationsPerTrial": {
                        "title": "Max sites per trial",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on flattened study sites embedded per trial row (some trials list 1,000+ sites). The full site count is always reported in numLocations. Set 0 to omit the locations array.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. ClinicalTrials.gov is a public API and works without a proxy; enable Apify Proxy only for very large batches.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
