# ClinicalTrials.gov API — Clinical Study Data (`tugelbay/clinical-trials-api`) Actor

Search the official ClinicalTrials.gov API and export current, normalized clinical study records without recruitment contacts or email data.

- **URL**: https://apify.com/tugelbay/clinical-trials-api.md
- **Developed by:** [Tugelbay Konabayev](https://apify.com/tugelbay) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 clinical trial studies

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does ClinicalTrials.gov API do?

ClinicalTrials.gov API searches the official [ClinicalTrials.gov](https://clinicaltrials.gov/) API and returns current, normalized **clinical study data** in JSON, CSV, Excel, XML, and other Apify dataset formats. It is a low-friction ClinicalTrials.gov API wrapper for analysts, researchers, data teams, and automation workflows that do not want to maintain pagination and schema-normalization code.

For teams comparing a clinical trials API or a reusable clinical trials data export, this Actor adds Apify scheduling, datasets, webhooks, and integrations around the official source without claiming to replace the source registry.

The Actor uses the official JSON API. It does not scrape pages, use a browser, bypass access controls, provide medical advice, match patients to trials, or extract recruitment contact names, phone numbers, or email addresses.

### Why use this ClinicalTrials.gov API Actor?

- Search by condition, general terms, intervention, sponsor, or NCT identifier.
- Filter by location and one or more overall study statuses.
- Receive a stable normalized schema instead of deeply nested source JSON.
- Follow official `nextPageToken` pagination automatically.
- Stop at a clear `maxItems` cost boundary of up to 5,000 studies.
- Retry temporary source failures and HTTP 429 responses with bounded backoff.
- Store only successful study records as billable PPE events.
- Export results or connect them to Apify API, schedules, webhooks, Make, Zapier, Google Sheets, or an MCP workflow.
- Keep source attribution and freshness fields in every result.

The Actor is intentionally narrow in its first release. It focuses on reliable study search and data delivery instead of trying to become a patient-recruitment or outreach platform.

### ClinicalTrials.gov API comparison: Actor vs direct API

Both routes use the official [ClinicalTrials.gov API](https://clinicaltrials.gov/data-api/api). The better choice depends on whether you want the complete source contract or a smaller automation-ready dataset.

| Decision | This Actor | Direct official API |
| --- | --- | --- |
| Best for | Scheduled exports, Apify datasets, webhooks, and no-code integrations | Teams maintaining their own API client and source schema |
| Pagination | Follows `nextPageToken` until `maxItems` is reached | Your client owns pagination and stopping rules |
| Output | Normalized study subset with source and freshness fields | Full official response, including fields this Actor intentionally omits |
| Operations | Bounded retries, run metrics, datasets, schedules, and integrations | Your infrastructure owns retries, storage, monitoring, and orchestration |
| Cost | PPE charge per successfully stored study plus applicable Apify platform usage | Use of the public source API; your team pays its own engineering and infrastructure costs |

Use the direct API when you need every source field, FHIR resources, or complete control over the client. Use this Actor when the normalized schema and Apify operations remove more maintenance than they add. Neither route changes the source data or makes a clinical recommendation.

### What clinical trial data can it extract?

| Field group | Example fields | Description |
| --- | --- | --- |
| Identification | `nctId`, `briefTitle`, `officialTitle`, `acronym` | Public study identifiers and titles |
| Status and design | `overallStatus`, `studyType`, `phases`, `primaryPurpose` | Current status and study design summary |
| Research scope | `conditions`, `interventions`, `briefSummary` | Conditions, intervention names/types, and brief public summary |
| Organizations | `leadSponsor`, `collaborators` | Sponsor and collaborator organizations |
| Enrollment | `enrollmentCount`, `enrollmentType` | Actual or estimated enrollment |
| Eligibility summary | `sex`, `minimumAge`, `maximumAge`, `healthyVolunteers` | High-level eligibility fields, not patient-level data |
| Geography | `countries`, `locations` | Facility and geographic fields with contacts removed |
| Dates and freshness | `startDate`, `completionDate`, `lastUpdatePostedDate`, `retrievedAt` | Study dates and source freshness metadata |
| Attribution | `sourceName`, `sourceUrl`, `termsUrl` | Direct source and terms links |

### How to search ClinicalTrials.gov

1. Open the Actor input tab.
2. Choose whether your query is a condition, any terms, an intervention, a sponsor, or an NCT identifier.
3. Enter the query. For NCT identifiers, you can enter up to 100 IDs separated by commas or whitespace.
4. Optionally enter a location and select overall statuses such as `RECRUITING` or `COMPLETED`.
5. Set the maximum number of study records. Start with 10-100 while testing a workflow.
6. Run the Actor and open the dataset in the Output tab.
7. Download the dataset in JSON, HTML, CSV, Excel, XML, or another supported format, or consume it through the Apify API.

Example input:

```json
{
  "searchType": "condition",
  "query": "type 2 diabetes",
  "location": "United States",
  "overallStatuses": ["RECRUITING", "NOT_YET_RECRUITING"],
  "maxItems": 100
}
````

NCT identifier lookup:

```json
{
  "searchType": "nctId",
  "query": "NCT01234567, NCT07654321",
  "maxItems": 2
}
```

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchType` | string | `condition` | Interpret the query as a condition, terms, intervention, sponsor, or NCT identifier |
| `query` | string | required | Search text or 1-100 NCT identifiers |
| `location` | string | empty | Optional city, state, country, or other location text |
| `overallStatuses` | array | empty | Optional list of official overall status values |
| `maxItems` | integer | `25` | Maximum successful study records returned and billed, from 1 to 5,000 |

See the input tab for the complete field descriptions and available status values.

### Output

Each successful row is one current ClinicalTrials.gov study record:

```json
{
  "recordType": "study",
  "searchType": "condition",
  "searchQuery": "type 2 diabetes",
  "nctId": "NCT01234567",
  "briefTitle": "Example study of a new intervention",
  "overallStatus": "RECRUITING",
  "studyType": "INTERVENTIONAL",
  "phases": ["PHASE2"],
  "conditions": ["Type 2 Diabetes"],
  "interventions": [
    {"type": "DRUG", "name": "Example intervention"}
  ],
  "leadSponsor": {
    "name": "Example University",
    "partyClass": "OTHER"
  },
  "enrollmentCount": 120,
  "countries": ["United States"],
  "lastUpdatePostedDate": "2026-07-10",
  "sourceName": "ClinicalTrials.gov",
  "sourceUrl": "https://clinicaltrials.gov/study/NCT01234567",
  "retrievedAt": "2026-07-14T12:00:00Z"
}
```

The `OUTPUT` record in the default key-value store reports the source status, total matches when supplied by the API, studies stored, pages requested, retries, 429 responses, downloaded bytes, billable events, charge-limit state, runtime, and freshness timestamps.

### How much does ClinicalTrials.gov API cost?

The launch list price is **$0.003 per successfully stored study**, or **$3 per 1,000 studies**. Store-plan volume discounts reduce the result price to as little as **$0.0021 per study**. Empty searches, retries, source errors, and summary records do not emit the `study-result` billing event. Apify manages its synthetic `apify-actor-start` event for PPE Actors. Platform-usage pass-through is not enabled.

Examples at list price:

| Successful studies | Result charge |
| ---: | ---: |
| 100 | $0.30 + $0.00005 start |
| 1,000 | $3.00 + $0.00005 start |
| 5,000 maximum | $15.00 + $0.00005 start |

The Store pricing configuration is authoritative. Check the pricing tab before running a large job. Re-running the same query can return and bill the same studies again because deduplication applies only to the current API response and run.

### Validation evidence (2026-07-14)

Validation on 2026-07-14 established the following bounded facts:

- The official [API documentation](https://clinicaltrials.gov/data-api/api) and [Terms and Conditions](https://clinicaltrials.gov/about-site/terms-conditions) endpoints returned HTTP 200.
- The live Apify Store surface returned HTTP 200 and exposed the Actor title, description, README, and PPE `study-result` pricing.
- Nine focused release tests passed for query construction, pagination, contact omission, normalization, successful-result billing, charge limits, retries, and output summaries.
- The local strict Actor checks passed for schemas, Docker configuration, PPE declarations, links, metadata, and secret scanning before the release was deployed.

This evidence verifies the release contract and Store readiness; it does **not** claim organic rankings, search traffic, external reviews, or citation by an AI answer engine. Source behavior, Store pricing, and terms can change, so verify the linked official pages and the current pricing tab for high-impact workflows.

### Tips and limitations

- Start with a small `maxItems` value to verify a query before scheduling it.
- Use status filters to reduce result volume for recruitment or completed-study research.
- Use `lastUpdatePostedDate` and `retrievedAt` to decide whether a downstream copy is current enough for your workflow.
- The Actor requests pages sequentially and does not use proxies or rotate identities.
- A source outage, schema change, or sustained rate limit can produce partial results or a failed run. Partial data already stored remains available.
- ClinicalTrials.gov is updated daily and does not guarantee that sponsor-submitted data are complete or error-free.
- This Actor is not a historical archive and does not guarantee that a record remains unchanged between runs.
- The Actor does not download study documents, expand FHIR resources, deliver webhooks, or persist a change-monitoring database in this release.

### FAQ, terms, and responsible use

#### Is this an official ClinicalTrials.gov product?

No. This independent Actor uses the official public API but is not affiliated with or endorsed by ClinicalTrials.gov, NIH, NLM, HHS, or the United States Government.

#### Can I use the output for patient matching or medical advice?

No. The data are study-registry records, not medical advice or a clinical recommendation. Validate important information with the official study record and qualified professionals.

#### Does it return recruitment contacts or emails?

No. Contact names, phone numbers, and email addresses are intentionally omitted. The ClinicalTrials.gov terms prohibit using extracted email addresses for marketing or promotional purposes.

#### What source attribution applies?

ClinicalTrials.gov states that distributed data should attribute ClinicalTrials.gov, remain current, and display the ClinicalTrials.gov processing date. Every row includes `sourceName`, `sourceUrl`, `lastUpdatePostedDate`, `retrievedAt`, and the official terms URL. You are responsible for following the current [ClinicalTrials.gov Terms and Conditions](https://clinicaltrials.gov/about-site/terms-conditions) in your downstream use.

#### Does the Actor own or relicense the source database?

No. The Actor only transforms current API responses into a convenient schema. Do not assert proprietary rights over the ClinicalTrials.gov database or present it as anything other than a United States Government database. Some submitted content may include third-party rights.

#### What about personal data?

The Actor excludes recruitment contacts, but study locations and organization names can still relate to real-world institutions and people. Process all output for a legitimate purpose and follow applicable privacy, research, and data-protection requirements. If you are unsure, consult qualified legal or compliance advisers.

### Support

When reporting an issue, include the run ID, sanitized input, expected NCT identifier or filter behavior, and the visible error message. Do not send patient data, credentials, private research records, or recruitment contact lists.

# Actor input Schema

## `searchType` (type: `string`):

Choose how the query should be interpreted by ClinicalTrials.gov.

## `query` (type: `string`):

Search text, or 1-100 comma-separated NCT identifiers when Search by is NCT identifier.

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

Optional city, state, country, or other location text used by the official API.

## `overallStatuses` (type: `array`):

Optional study status filter. Leave empty to include all statuses.

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

Maximum number of successful study records returned and billed in this run.

## Actor input object example

```json
{
  "searchType": "condition",
  "query": "type 2 diabetes",
  "maxItems": 25
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing successful normalized study records without recruitment contacts.

## `summary` (type: `string`):

Key-value-store record containing pagination, retry, freshness, billing, and completion metrics.

# 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 = {
    "query": "type 2 diabetes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tugelbay/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 = { "query": "type 2 diabetes" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ClinicalTrials.gov API — Clinical Study Data",
        "description": "Search the official ClinicalTrials.gov API and export current, normalized clinical study records without recruitment contacts or email data.",
        "version": "0.1",
        "x-build-id": "g1Uj1HyZ27cAinbJL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tugelbay~clinical-trials-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tugelbay-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/tugelbay~clinical-trials-api/runs": {
            "post": {
                "operationId": "runs-sync-tugelbay-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/tugelbay~clinical-trials-api/run-sync": {
            "post": {
                "operationId": "run-sync-tugelbay-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",
                "required": [
                    "query"
                ],
                "properties": {
                    "searchType": {
                        "title": "Search by",
                        "enum": [
                            "condition",
                            "terms",
                            "intervention",
                            "sponsor",
                            "nctId"
                        ],
                        "type": "string",
                        "description": "Choose how the query should be interpreted by ClinicalTrials.gov.",
                        "default": "condition"
                    },
                    "query": {
                        "title": "Query",
                        "minLength": 1,
                        "maxLength": 1200,
                        "type": "string",
                        "description": "Search text, or 1-100 comma-separated NCT identifiers when Search by is NCT identifier."
                    },
                    "location": {
                        "title": "Location",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Optional city, state, country, or other location text used by the official API."
                    },
                    "overallStatuses": {
                        "title": "Overall statuses",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional study status filter. Leave empty to include all statuses.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NOT_YET_RECRUITING",
                                "RECRUITING",
                                "ENROLLING_BY_INVITATION",
                                "ACTIVE_NOT_RECRUITING",
                                "SUSPENDED",
                                "TERMINATED",
                                "COMPLETED",
                                "WITHDRAWN",
                                "UNKNOWN"
                            ],
                            "enumTitles": [
                                "Not yet recruiting",
                                "Recruiting",
                                "Enrolling by invitation",
                                "Active, not recruiting",
                                "Suspended",
                                "Terminated",
                                "Completed",
                                "Withdrawn",
                                "Unknown"
                            ]
                        }
                    },
                    "maxItems": {
                        "title": "Maximum studies",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of successful study records returned and billed in this run.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
