# ClinicalTrials.gov Studies Scraper (`automation-lab/clinicaltrials-gov-studies-scraper`) Actor

Export structured ClinicalTrials.gov study records from the official API for trial monitoring, sponsor research, and healthcare market intelligence.

- **URL**: https://apify.com/automation-lab/clinicaltrials-gov-studies-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 study saveds

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

## ClinicalTrials.gov Studies Scraper

Extract structured study records from the official ClinicalTrials.gov API.

Use this Apify Actor to monitor trials, sponsors, interventions, phases, locations, eligibility fields, and study URLs without maintaining your own API pagination code.

### What does ClinicalTrials.gov Studies Scraper do?

ClinicalTrials.gov Studies Scraper searches the public ClinicalTrials.gov API v2 and saves normalized study records to an Apify dataset.

It is HTTP-only and does not use a browser.

It works with public data from ClinicalTrials.gov.

It supports broad search and precise filters.

It exports clean records for spreadsheets, BI tools, CRMs, data warehouses, and monitoring workflows.

### Who is it for?

🧪 Pharma competitive intelligence teams can monitor recruiting and completed trials by condition, intervention, or sponsor.

🏥 Clinical trial recruitment teams can discover studies by disease area, country, status, and eligibility fields.

📊 Healthcare market researchers can enrich market maps with trial phase, sponsor, country, and enrollment data.

🔬 Biotech business development teams can follow pipeline activity around drug classes, diseases, and sponsor names.

⚙️ Data engineers can schedule repeatable ClinicalTrials.gov exports from Apify and deliver them to downstream systems.

### Why use this actor?

ClinicalTrials.gov has an official API, but users still need pagination, filtering, normalization, and export handling.

This actor wraps that API in an Apify-ready workflow.

You get a dataset with stable field names.

You can schedule runs.

You can integrate output through Apify API, webhooks, dataset exports, or MCP.

You can avoid building one-off scripts for every trial monitoring request.

### Typical workflows

Monitor new recruiting oncology trials each week.

Build a sponsor-specific pipeline tracker.

Export Phase 3 studies for a therapeutic area.

Find trial countries and site locations for recruitment planning.

Enrich internal company or drug databases with ClinicalTrials.gov identifiers.

Track when studies were first posted or last updated.

### Input filters

The actor supports these filters:

- `searchTerm` for free-text ClinicalTrials.gov search.
- `condition` for disease or condition queries.
- `intervention` for drug, device, biologic, procedure, or treatment names.
- `sponsor` for sponsor or collaborator names.
- `location` for city, state, country, or facility text.
- `nctIds` for exact study IDs.
- `statuses` for recruitment status filters.
- `studyTypes` for interventional, observational, or expanded access studies.
- `phases` for trial phase filters.
- `maxItems` for output limits.
- `includeLongText` for full summary and eligibility text.
- `sort` for optional API sort expressions.

### Output data

Each dataset row is one ClinicalTrials.gov study.

The actor exports identifiers, titles, statuses, study design, conditions, interventions, sponsor data, location data, dates, eligibility fields, and URLs.

### Data fields

| Field | Description |
| --- | --- |
| `nctId` | ClinicalTrials.gov study ID. |
| `briefTitle` | Brief study title. |
| `officialTitle` | Official study title. |
| `overallStatus` | Current overall recruitment/status value. |
| `lastKnownStatus` | Last known status when available. |
| `studyType` | Interventional, observational, or expanded access. |
| `phases` | Trial phases. |
| `conditions` | Conditions or diseases. |
| `keywords` | Study keywords. |
| `interventions` | Intervention names and aliases. |
| `interventionTypes` | Intervention type categories. |
| `leadSponsor` | Lead sponsor name. |
| `leadSponsorClass` | Sponsor class. |
| `collaborators` | Collaborator names. |
| `locations` | Facility, city, state, country, and location status. |
| `countries` | Unique countries from locations. |
| `enrollmentCount` | Enrollment count. |
| `enrollmentType` | Actual or estimated enrollment. |
| `sex` | Eligibility sex. |
| `minimumAge` | Minimum eligibility age. |
| `maximumAge` | Maximum eligibility age. |
| `healthyVolunteers` | Whether healthy volunteers are accepted. |
| `startDate` | Study start date. |
| `primaryCompletionDate` | Primary completion date. |
| `completionDate` | Completion date. |
| `studyFirstSubmitDate` | First submitted date. |
| `studyFirstPostDate` | First posted date. |
| `lastUpdateSubmitDate` | Last update submitted date. |
| `lastUpdatePostDate` | Last update posted date. |
| `resultsFirstSubmitDate` | Results first submitted date when available. |
| `briefSummary` | Study summary, trimmed unless long text is enabled. |
| `eligibilityCriteria` | Eligibility criteria, trimmed unless long text is enabled. |
| `sourceUrl` | Public ClinicalTrials.gov study page. |
| `apiUrl` | API URL used for the page that returned the record. |
| `fetchedAt` | Timestamp when the actor saved the record. |

### How much does it cost to scrape ClinicalTrials.gov studies?

The actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-study charge for each saved dataset item.

The exact live price is shown on the Apify Store pricing panel.

Use `maxItems` to control run size and cost.

### Example input: recruiting cancer trials

```json
{
  "searchTerm": "cancer",
  "statuses": ["RECRUITING"],
  "maxItems": 100
}
````

### Example input: sponsor monitoring

```json
{
  "condition": "diabetes",
  "sponsor": "Pfizer",
  "maxItems": 100
}
```

### Example input: exact NCT IDs

```json
{
  "nctIds": ["NCT05162118"],
  "includeLongText": true,
  "maxItems": 1
}
```

### How to run on Apify

1. Open the actor page on Apify.
2. Enter a search term or one or more filters.
3. Set `maxItems` to the number of studies you need.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or RSS.
6. Schedule the actor if you need recurring monitoring.

### Tips for better results

Use `condition` when you know the disease area.

Use `intervention` when tracking a drug, biologic, device, or procedure.

Use `sponsor` for company or institution monitoring.

Use `statuses` to focus on recruiting or active studies.

Use `includeLongText` when you need full eligibility criteria.

Keep `maxItems` small for exploratory runs.

Increase `maxItems` for scheduled production exports.

### Integrations

Send new study records to Google Sheets for research analysts.

Push sponsor-specific trial records to a data warehouse.

Trigger webhooks when scheduled monitoring runs finish.

Use dataset exports in CSV or Excel for manual review.

Use the Apify API from Python or Node.js for automated enrichment.

Use MCP to let AI assistants query recent trial data through Apify.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/clinicaltrials-gov-studies-scraper').call({
  condition: 'Alzheimer Disease',
  phases: ['PHASE3'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/clinicaltrials-gov-studies-scraper').call(run_input={
    'condition': 'Alzheimer Disease',
    'phases': ['PHASE3'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~clinicaltrials-gov-studies-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerm":"cancer","statuses":["RECRUITING"],"maxItems":100}'
```

### MCP usage

Use Apify MCP to call this actor from Claude Code, Claude Desktop, or other MCP clients.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/clinicaltrials-gov-studies-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-clinicaltrials "https://mcp.apify.com/?tools=automation-lab/clinicaltrials-gov-studies-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-clinicaltrials": {
      "url": "https://mcp.apify.com/?tools=automation-lab/clinicaltrials-gov-studies-scraper"
    }
  }
}
```

Example prompts:

- "Run the ClinicalTrials.gov scraper for recruiting pancreatic cancer trials and summarize sponsors by country."
- "Extract Phase 3 Alzheimer studies and list the top sponsors."
- "Monitor Pfizer diabetes trials and flag newly updated studies."

### Scheduling and monitoring

Clinical trial data changes over time.

For monitoring, create a saved task with your filters.

Schedule it daily, weekly, or monthly.

Compare new datasets against previous runs by `nctId` and date fields.

Use Apify webhooks to notify your team when a scheduled run completes.

### Data freshness

The actor fetches live data from ClinicalTrials.gov API v2 at run time.

The output includes `fetchedAt` so you know when each record was saved.

ClinicalTrials.gov records may be updated by sponsors and investigators after your run.

For compliance-sensitive workflows, keep the dataset export and run timestamp with your internal record.

### Limits and caveats

This actor only exports public ClinicalTrials.gov data.

It does not infer medical meaning beyond fields returned by the API.

It does not guarantee that a study is currently accepting patients at every listed site.

Always verify clinical, regulatory, and recruitment decisions with the official study page and relevant professionals.

### Legality and responsible use

ClinicalTrials.gov provides public study information.

Use the data responsibly and comply with applicable laws, policies, and ClinicalTrials.gov terms.

Do not use exported data for unlawful profiling, spam, or unauthorized medical claims.

### Troubleshooting

If you receive fewer records than expected, broaden your filters.

If an exact NCT ID returns no result, check that the ID is typed correctly.

If summaries are too short, enable `includeLongText`.

If a scheduled monitor is too noisy, restrict by condition, sponsor, status, or phase.

### FAQ

#### Does this scrape web pages?

No. It uses the official ClinicalTrials.gov API v2.

#### Do I need a ClinicalTrials.gov account?

No. The supported data is public.

#### Can I export all studies?

Yes, within run limits. Set broad filters and a high `maxItems`, but start with a smaller run to validate your workflow.

#### Can I monitor only recruiting studies?

Yes. Set `statuses` to `RECRUITING` or combine recruiting statuses such as `RECRUITING` and `NOT_YET_RECRUITING`.

#### Can I search by sponsor?

Yes. Use the `sponsor` input field.

### Related scrapers

Explore related Automation Lab actors for healthcare, research, company, and contact enrichment workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/company-domain-finder
- https://apify.com/automation-lab/rss-feed-scraper

### Support

If you need a field that is present in ClinicalTrials.gov API v2 but not exported here, open an Apify issue with a sample NCT ID.

If a run fails, include the run ID, input, and expected result.

### Changelog

Initial version exports official ClinicalTrials.gov study records with filters, pagination, normalized fields, and pay-per-study charging.

# Actor input Schema

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

Free-text query across ClinicalTrials.gov study records, for example cancer, diabetes, mRNA vaccine, or an NCT ID.

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

Filter by condition/disease, such as pancreatic cancer, Alzheimer disease, or type 2 diabetes.

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

Filter by drug, device, procedure, biologic, or other intervention name.

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

Filter by sponsor/collaborator name, such as Pfizer, NIH, Mayo Clinic, or a university.

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

Filter by country, state, city, or facility location text.

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

Optional exact ClinicalTrials.gov study IDs to fetch or filter, e.g. NCT05162118.

## `statuses` (type: `array`):

Overall status values to include. Leave empty for all statuses.

## `studyTypes` (type: `array`):

Study types to include. Leave empty for all study types.

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

Trial phases to include. Leave empty for all phases.

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

Maximum number of ClinicalTrials.gov study records to save.

## `includeLongText` (type: `boolean`):

If enabled, exports full summaries and eligibility criteria instead of trimmed previews.

## `sort` (type: `string`):

Optional ClinicalTrials.gov API sort expression. Leave empty to use API relevance/default ordering.

## Actor input object example

```json
{
  "searchTerm": "cancer",
  "statuses": [
    "RECRUITING"
  ],
  "maxItems": 20,
  "includeLongText": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerm": "cancer",
    "statuses": [
        "RECRUITING"
    ],
    "maxItems": 20,
    "includeLongText": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/clinicaltrials-gov-studies-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 = {
    "searchTerm": "cancer",
    "statuses": ["RECRUITING"],
    "maxItems": 20,
    "includeLongText": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/clinicaltrials-gov-studies-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 '{
  "searchTerm": "cancer",
  "statuses": [
    "RECRUITING"
  ],
  "maxItems": 20,
  "includeLongText": false
}' |
apify call automation-lab/clinicaltrials-gov-studies-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ClinicalTrials.gov Studies Scraper",
        "description": "Export structured ClinicalTrials.gov study records from the official API for trial monitoring, sponsor research, and healthcare market intelligence.",
        "version": "0.1",
        "x-build-id": "RXrP6OaG5hnbhzRkK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~clinicaltrials-gov-studies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-clinicaltrials-gov-studies-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/automation-lab~clinicaltrials-gov-studies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-clinicaltrials-gov-studies-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/automation-lab~clinicaltrials-gov-studies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-clinicaltrials-gov-studies-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": {
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Free-text query across ClinicalTrials.gov study records, for example cancer, diabetes, mRNA vaccine, or an NCT ID."
                    },
                    "condition": {
                        "title": "Condition or disease",
                        "type": "string",
                        "description": "Filter by condition/disease, such as pancreatic cancer, Alzheimer disease, or type 2 diabetes."
                    },
                    "intervention": {
                        "title": "Intervention or treatment",
                        "type": "string",
                        "description": "Filter by drug, device, procedure, biologic, or other intervention name."
                    },
                    "sponsor": {
                        "title": "Sponsor or collaborator",
                        "type": "string",
                        "description": "Filter by sponsor/collaborator name, such as Pfizer, NIH, Mayo Clinic, or a university."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by country, state, city, or facility location text."
                    },
                    "nctIds": {
                        "title": "NCT IDs",
                        "type": "array",
                        "description": "Optional exact ClinicalTrials.gov study IDs to fetch or filter, e.g. NCT05162118.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Recruitment statuses",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Overall status values to include. Leave empty for all statuses.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RECRUITING",
                                "NOT_YET_RECRUITING",
                                "ACTIVE_NOT_RECRUITING",
                                "ENROLLING_BY_INVITATION",
                                "COMPLETED",
                                "SUSPENDED",
                                "TERMINATED",
                                "WITHDRAWN",
                                "UNKNOWN"
                            ]
                        }
                    },
                    "studyTypes": {
                        "title": "Study types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Study types to include. Leave empty for all study types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "INTERVENTIONAL",
                                "OBSERVATIONAL",
                                "EXPANDED_ACCESS"
                            ]
                        }
                    },
                    "phases": {
                        "title": "Phases",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Trial phases to include. Leave empty for all phases.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "EARLY_PHASE1",
                                "PHASE1",
                                "PHASE2",
                                "PHASE3",
                                "PHASE4",
                                "NA"
                            ]
                        }
                    },
                    "maxItems": {
                        "title": "Maximum studies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of ClinicalTrials.gov study records to save.",
                        "default": 20
                    },
                    "includeLongText": {
                        "title": "Include full long text",
                        "type": "boolean",
                        "description": "If enabled, exports full summaries and eligibility criteria instead of trimmed previews.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort order",
                        "type": "string",
                        "description": "Optional ClinicalTrials.gov API sort expression. Leave empty to use API relevance/default ordering."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
