# NCI Thesaurus Concept Scraper (`parseforge/nci-thesaurus-concept-scraper`) Actor

Pull biomedical and cancer concepts from the NCI Thesaurus via the NCI EVS REST API. Search by keyword or list NCIt codes to return preferred name, synonyms, definition, semantic type, status, and parent and child concepts. Great for ontology mapping and clinical research.

- **URL**: https://apify.com/parseforge/nci-thesaurus-concept-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, AI, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.52 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧬 NCI Thesaurus Concept Scraper

> 🚀 **Export biomedical and cancer concepts in seconds.** Pull NCI Thesaurus concepts straight from the official NCI EVS REST API by keyword or concept code.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 16 fields** per record · live terminology · 1,600+ concepts for a single search like "melanoma"

Turn the NCI Thesaurus into clean, structured records you can drop into an ontology, a clinical data dictionary, a research database, or a terminology mapping pipeline. Search a keyword or list exact NCIt codes and get one tidy record per concept with names, synonyms, definitions, semantic types, and the hierarchy around each term.

Coverage is the NCI Thesaurus (NCIt) as published through the NCI Enterprise Vocabulary Services (EVS) REST API: preferred names, synonyms from contributing sources like CDISC and GDC, authoritative definitions, semantic types, concept status, and the parent and child concepts that define each term's place in the cancer and biomedical hierarchy.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Clinical data and biomedical informatics teams | Map local terms onto standardized NCIt codes |
| Cancer and life-science researchers | Build concept lists for a study or registry |
| Ontology and vocabulary engineers | Seed or audit a terminology with parents and children |
| Health-tech and EHR developers | Power code lookups and synonym resolution |

### 📋 What the NCI Thesaurus Concept Scraper does

This Actor calls the public NCI EVS REST API and returns one clean record per concept, with two ways to select what you want:

- **Search by term** — find every NCI Thesaurus concept matching a keyword such as `melanoma` or `BRAF gene`.
- **By concept codes** — fetch specific concepts by their NCIt code, for example `C3224` or `C16612`.

Choose a detail level per run. **Summary** returns names, synonyms, definitions, semantic type, and status. **Full** adds the parent and child concepts plus extra properties. Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | How to select concepts. One of `search` or `codes`. Defaults to `search`. |
| `term` | string | Keyword to search the NCI Thesaurus. Used when `mode` is `search`. |
| `codes` | array | List of NCIt concept codes (for example `C3224`). Used when `mode` is `codes`. |
| `include` | select | Detail level per concept. One of `summary` or `full`. Defaults to `full`. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — search by keyword**
```json
{
    "mode": "search",
    "term": "melanoma",
    "include": "full",
    "maxItems": 25
}
````

**Example 2 — fetch specific codes**

```json
{
    "mode": "codes",
    "codes": ["C3224", "C16612", "C12434"],
    "include": "full",
    "maxItems": 3
}
```

> ⚠️ **Good to Know:** parent and child concepts are populated only when `include` is set to `full`. With `summary` they come back as empty arrays, which keeps the records lighter when you only need names, synonyms, and definitions.

### 📊 Output

Each concept record looks like this:

| Field | Description |
|---|---|
| 📌 `name` | Preferred concept name |
| 🆔 `code` | NCIt concept code |
| 🔗 `url` | NCI Thesaurus browser page for the concept |
| 🏷 `displayName` | Display name for the concept |
| 🧬 `semanticTypes` | Semantic type labels (for example Neoplastic Process) |
| 📝 `definition` | Authoritative concept definition |
| 📊 `conceptStatus` | Concept status flag |
| ✅ `active` | Whether the concept is active |
| 🍃 `leaf` | Whether the concept has no children |
| 🏷 `terminologyVersion` | NCIt version the data came from |
| 🧫 `neoplasticStatus` | Neoplastic status when present |
| 🔗 `umlsCui` | Linked UMLS concept identifier |
| 🗂 `contributingSources` | Source vocabularies that contribute terms |
| 🏷 `synonyms` | Distinct synonym names |
| ⬆ `parents` | Parent concepts (code, name) |
| ⬇ `children` | Child concepts (code, name) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — concept (full detail)**

```json
{
    "name": "Melanoma",
    "code": "C3224",
    "url": "https://ncithesaurus.nci.nih.gov/ncitbrowser/ConceptReport.jsp?dictionary=NCI_Thesaurus&code=C3224",
    "displayName": "Melanoma",
    "semanticTypes": ["Neoplastic Process"],
    "definition": "A malignant, usually aggressive tumor composed of atypical, neoplastic melanocytes. Most often, melanomas arise in the skin (cutaneous melanomas) and include the following histologic subtypes: superficial spreading melanoma, nodular melanoma, acral lentiginous melanoma, and lentigo maligna melanoma...",
    "conceptStatus": "DEFAULT",
    "active": true,
    "leaf": false,
    "terminologyVersion": "26.05d",
    "neoplasticStatus": "Malignant",
    "umlsCui": "C0025202",
    "contributingSources": ["CDISC", "Cellosaurus", "CPTAC", "CTEP", "CTRP", "GDC", "MedDRA", "NICHD"],
    "synonyms": ["Melanoma", "Malignant Melanoma", "MELANOMA, MALIGNANT", "Melanoma, NOS", "melanoma"],
    "parents": [
        { "code": "C9305", "name": "Malignant Neoplasm" },
        { "code": "C7058", "name": "Melanocytic Neoplasm" }
    ],
    "children": [
        { "code": "C3802", "name": "Amelanotic Melanoma" },
        { "code": "C3510", "name": "Cutaneous Melanoma" },
        { "code": "C8925", "name": "Metastatic Melanoma" }
    ],
    "scrapedAt": "2026-06-08T18:00:39.770Z",
    "error": null
}
```

**Real sample — pathway concept**

```json
{
    "name": "Melanoma Pathway",
    "code": "C91477",
    "url": "https://ncithesaurus.nci.nih.gov/ncitbrowser/ConceptReport.jsp?dictionary=NCI_Thesaurus&code=C91477",
    "displayName": "Melanoma Pathway",
    "semanticTypes": ["Functional Concept"],
    "definition": "Five distinct stages have been proposed in the evolution of melanoma on the basis of histological criteria...",
    "conceptStatus": "DEFAULT",
    "active": true,
    "leaf": true,
    "terminologyVersion": "26.05d",
    "neoplasticStatus": null,
    "umlsCui": "C2984289",
    "contributingSources": [],
    "synonyms": ["Melanoma", "Melanoma Pathway"],
    "parents": [{ "code": "C91436", "name": "Cancer Pathway" }],
    "children": [],
    "scrapedAt": "2026-06-08T18:02:18.402Z",
    "error": null
}
```

**Real sample — code lookup**

```json
{
    "name": "Blood",
    "code": "C12434",
    "url": "https://ncithesaurus.nci.nih.gov/ncitbrowser/ConceptReport.jsp?dictionary=NCI_Thesaurus&code=C12434",
    "displayName": "Blood",
    "semanticTypes": ["Body Substance"],
    "definition": "A liquid tissue; its major function is to transport oxygen throughout the body...",
    "conceptStatus": "DEFAULT",
    "active": true,
    "leaf": false,
    "terminologyVersion": "26.05d",
    "neoplasticStatus": null,
    "umlsCui": "C0005767",
    "contributingSources": ["CDISC", "GDC", "NCI-GLOSS"],
    "synonyms": ["Blood", "BLOOD", "blood"],
    "parents": [{ "code": "C13236", "name": "Body Fluid or Substance" }],
    "children": [],
    "scrapedAt": "2026-06-08T18:02:18.402Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per concept, with consistent field names that map onto a database schema.
- Two selection modes in one Actor, so keyword discovery and exact code lookup share the same output shape.
- Synonyms are de-duplicated and definitions favor the authoritative NCI source.
- Parent and child concepts come fully named, not as bare codes.
- No login, no API key, and direct from the official NCI EVS REST API.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Hierarchy included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Hand-copying from the NCIt browser | Hours | Inconsistent | Manual | Constant |
| Writing your own EVS API client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the NCI Thesaurus Concept Scraper.
3. Choose a `mode` (search a term or list concept codes).
4. Set `include` to `summary` or `full`, and `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Clinical data and informatics

| Goal | How this helps |
|---|---|
| Standardize local terms | Map free text onto NCIt codes and synonyms |
| Build a study code list | Search a topic and capture every matching concept |

#### Ontology and vocabulary work

| Goal | How this helps |
|---|---|
| Audit a terminology branch | Pull a concept with its parents and children |
| Resolve synonyms | Use the de-duplicated synonym arrays |

#### Research and analytics

| Goal | How this helps |
|---|---|
| Assemble a cancer concept set | Search by disease and export the records |
| Link to other vocabularies | Use the UMLS CUI and contributing sources |

#### Product and engineering

| Goal | How this helps |
|---|---|
| Power a code lookup feature | Fetch concepts by NCIt code on demand |
| Seed a reference table | Snapshot a topic into your database |

### 🔌 Automating NCI Thesaurus Concept Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots of a concept set.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** assemble concept lists for a systematic review or registry.
- **Personal:** explore the cancer terminology hierarchy around a diagnosis.
- **Non-profit:** power a patient-education glossary with authoritative definitions.
- **Experimentation:** prototype a terminology app without writing an API client.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to group concepts by semantic type, summarize a definition, or build a concept hierarchy from the parent and child fields.

### ❓ Frequently Asked Questions

**Do I need an NCI or NIH account?**
No. The Actor reads the public NCI EVS REST API, which needs no login.

**Do I need an API key?**
No key is required.

**What is the NCI Thesaurus?**
It is the National Cancer Institute's reference terminology of cancer and biomedical concepts, published as NCIt through NCI Enterprise Vocabulary Services.

**How do I find a concept code?**
Run a search by term first, then read the `code` field, or enter codes you already know in `codes` mode.

**What is the difference between summary and full detail?**
Summary returns names, synonyms, definitions, semantic type, and status. Full adds parent and child concepts plus extra properties.

**Why are parents or children empty on some records?**
They are populated only when `include` is `full`, and some concepts genuinely have no children (a leaf) or sit near the top of the hierarchy.

**How many concepts can a search return?**
A broad search like "melanoma" matches over 1,600 concepts; you control how many come back with `maxItems`.

**Are synonyms de-duplicated?**
Yes. Synonym names are collapsed to a distinct list per concept.

**Which definition is shown?**
The Actor favors the authoritative NCI definition and falls back to another source when NCI does not provide one.

**How fresh is the data?**
Each run pulls live from the NCI EVS API and records the NCIt version in `terminologyVersion`.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the National Cancer Institute or the National Institutes of Health. Only publicly available data is collected.

# Actor input Schema

## `mode` (type: `string`):

How to select concepts. 'Search by term' finds NCI Thesaurus concepts matching a keyword. 'By concept codes' fetches specific concepts by their NCIt code (for example C3224).

## `term` (type: `string`):

Only used when Mode is 'Search by term'. A keyword to search the NCI Thesaurus, for example 'melanoma' or 'BRAF gene'. Leave empty when using concept codes.

## `codes` (type: `array`):

Only used when Mode is 'By concept codes'. A list of NCIt concept codes, for example C3224 or C16612. Leave empty when searching by term.

## `include` (type: `string`):

How much detail to pull per concept. 'Summary' returns names, synonyms, definitions, semantic type, and status. 'Full' adds parent and child concepts plus extra properties.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "mode": "search",
  "term": "melanoma",
  "codes": [
    "C3224",
    "C16612"
  ],
  "include": "full",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "term": "melanoma",
    "codes": [
        "C3224",
        "C16612"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nci-thesaurus-concept-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 = {
    "term": "melanoma",
    "codes": [
        "C3224",
        "C16612",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nci-thesaurus-concept-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 '{
  "term": "melanoma",
  "codes": [
    "C3224",
    "C16612"
  ],
  "maxItems": 10
}' |
apify call parseforge/nci-thesaurus-concept-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NCI Thesaurus Concept Scraper",
        "description": "Pull biomedical and cancer concepts from the NCI Thesaurus via the NCI EVS REST API. Search by keyword or list NCIt codes to return preferred name, synonyms, definition, semantic type, status, and parent and child concepts. Great for ontology mapping and clinical research.",
        "version": "0.1",
        "x-build-id": "z8W6gqfgCcPC1kTcx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nci-thesaurus-concept-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nci-thesaurus-concept-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/parseforge~nci-thesaurus-concept-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nci-thesaurus-concept-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/parseforge~nci-thesaurus-concept-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nci-thesaurus-concept-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "codes"
                        ],
                        "type": "string",
                        "description": "How to select concepts. 'Search by term' finds NCI Thesaurus concepts matching a keyword. 'By concept codes' fetches specific concepts by their NCIt code (for example C3224).",
                        "default": "search"
                    },
                    "term": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Only used when Mode is 'Search by term'. A keyword to search the NCI Thesaurus, for example 'melanoma' or 'BRAF gene'. Leave empty when using concept codes."
                    },
                    "codes": {
                        "title": "Concept codes",
                        "type": "array",
                        "description": "Only used when Mode is 'By concept codes'. A list of NCIt concept codes, for example C3224 or C16612. Leave empty when searching by term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "include": {
                        "title": "Detail level",
                        "enum": [
                            "summary",
                            "full"
                        ],
                        "type": "string",
                        "description": "How much detail to pull per concept. 'Summary' returns names, synonyms, definitions, semantic type, and status. 'Full' adds parent and child concepts plus extra properties.",
                        "default": "full"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
