# MyChem.info Drug Annotation Scraper (`parseforge/mychem-drug-annotation-scraper`) Actor

Resolve any drug name or InChIKey into a tidy annotation from MyChem.info. Returns DrugBank name and accession, ChEMBL and PubChem ids, UNII, ATC codes, chemical formula, molecular weight, indications, and mechanism classes. Great for drug reference tables and identifier crosswalks.

- **URL**: https://apify.com/parseforge/mychem-drug-annotation-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 $2.00 / 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)

## 💊 MyChem.info Drug Annotation Scraper

> 🚀 **Turn any drug name into a clean annotation record in seconds.** Resolve imatinib, aspirin, or a whole therapeutic area into DrugBank, ChEMBL, PubChem, UNII, ATC, formula, weight, indications, and mechanism, all from one keyless source.

> 🕒 **Last updated:** 2026-06-05 · **📊 23 fields** per record · keyless public API · global drug and compound coverage

MyChem.info is the BioThings drug and chemical knowledge hub that aggregates DrugBank, ChEMBL, PubChem, DrugCentral, UNII, and more behind a single InChIKey-keyed API. This Actor queries MyChem.info, resolves each drug name or InChIKey to its annotation document, and returns a curated subset of the most useful fields instead of the full nested blob.

Coverage spans small molecules, biologics, and investigational compounds that carry a DrugBank annotation. You can look up drugs one by one, paste a batch of names or InChIKeys, or run a free-text query like a therapeutic area to pull back the best-matching annotated compounds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Pharma and biotech researchers | Build a drug reference table across DrugBank, ChEMBL, and PubChem |
| Data scientists and bioinformaticians | Map drug names to standardized identifiers and ATC codes |
| Clinical and regulatory teams | Pull indications, mechanism classes, and approval status |
| Chemistry and cheminformatics teams | Collect formula, molecular weight, SMILES, and CAS numbers |

### 📋 What the MyChem.info Drug Annotation Scraper does

- Resolves drug names (for example imatinib, metformin) or InChIKeys to their MyChem.info annotation.
- Runs a free-text search query and returns the best-matching drug-annotated compounds.
- Maps a curated subset of fields from DrugBank, ChEMBL, PubChem, DrugCentral, and UNII.
- Returns standardized identifiers, ATC codes, chemical properties, indications, and mechanism classes.
- Combines a search query and an explicit drug list in a single run when you want both.

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

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchQuery` | string | one of two | A free-text term such as a drug name or therapeutic area (for example leukemia, kinase). |
| `drugList` | array | one of two | Drug names or InChIKeys to resolve, one per entry. |
| `maxItems` | integer | no | Cap on how many records are produced. Free plan is limited to 10. |

Provide a `searchQuery`, a `drugList`, or both. At least one is required.

```json
{
  "drugList": ["imatinib", "dasatinib", "nilotinib", "aspirin", "metformin"],
  "maxItems": 10
}
````

```json
{
  "searchQuery": "leukemia",
  "maxItems": 25
}
```

> ⚠️ **Good to Know:** Only compounds carrying a DrugBank annotation are returned, so very obscure or purely chemical entries may not resolve. A few fields such as ATC codes, PubChem CID, or approval year can be absent for a given drug when the upstream source has no value, and those come back as null rather than being faked.

### 📊 Output

Each record is one drug or compound annotation.

| 🏷 Field | Description |
|---|---|
| 💊 `drugName` | Primary DrugBank name |
| 🧬 `inchikey` | InChIKey, the MyChem.info record id |
| 🆔 `drugbankId` | DrugBank accession (for example DB00619) |
| 📚 `drugbankAccessions` | All DrugBank accession numbers |
| 🧪 `chemblId` | ChEMBL molecule id |
| 🔬 `pubchemCid` | PubChem compound id |
| 🔖 `unii` | FDA UNII code |
| 🧾 `casNumber` | CAS registry number |
| 🏷 `atcCodes` | WHO ATC classification codes |
| 🧫 `moleculeType` | Molecule type, for example Small molecule |
| 📈 `maxPhase` | Highest development phase reached |
| 📅 `firstApprovalYear` | Year of first approval |
| 🗂 `drugGroups` | Status and route flags, for example approved, oral |
| ⚗️ `molecularFormula` | Chemical formula |
| ⚖️ `molecularWeight` | Molecular weight |
| 🧩 `smiles` | SMILES structure string |
| 🩺 `primaryIndication` | Lead indication |
| 📋 `indications` | Indication list |
| 🔬 `mechanism` | Mechanism and pharmacology classes |
| 🌐 `source` | Which input produced the record |
| 🔗 `url` | MyChem.info annotation endpoint |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Error message, null on success |

Real sample records from a live run:

```json
{
  "inchikey": "KTUFNOKKBVMGRW-UHFFFAOYSA-N",
  "drugName": "Imatinib",
  "drugbankId": "DB00619",
  "chemblId": "CHEMBL941",
  "pubchemCid": "5291",
  "unii": "BKJ8M8G5HI",
  "casNumber": "152459-95-5",
  "atcCodes": ["L01EA01"],
  "moleculeType": "Small molecule",
  "maxPhase": 4,
  "firstApprovalYear": 2001,
  "drugGroups": ["approved", "oral"],
  "molecularFormula": "C29H31N7O",
  "molecularWeight": 493.6,
  "primaryIndication": "Chronic Myelocytic Leukemia Accelerated Phase",
  "mechanism": ["Kinase Inhibitor", "tyrosine kinase inhibitors", "Protein Kinase Inhibitors"],
  "url": "https://mychem.info/v1/chem/KTUFNOKKBVMGRW-UHFFFAOYSA-N",
  "error": null
}
```

```json
{
  "inchikey": "ZBNZXTGUTAYRHI-UHFFFAOYSA-N",
  "drugName": "Dasatinib",
  "drugbankId": "DB01254",
  "chemblId": "CHEMBL1421",
  "pubchemCid": "3062316",
  "unii": "X78UG0A0RN",
  "casNumber": "302962-49-8",
  "atcCodes": ["L01EA02"],
  "moleculeType": "Small molecule",
  "maxPhase": 4,
  "firstApprovalYear": 2006,
  "drugGroups": ["approved", "oral"],
  "molecularFormula": "C22H26ClN7O2S",
  "molecularWeight": 488,
  "primaryIndication": "Philadelphia Chromosome Positive Chronic Myelocytic Leukemia",
  "mechanism": ["tyrosine kinase inhibitors", "Protein Kinase Inhibitors"],
  "url": "https://mychem.info/v1/chem/ZBNZXTGUTAYRHI-UHFFFAOYSA-N",
  "error": null
}
```

```json
{
  "inchikey": "HHZIURLSWUIHRB-UHFFFAOYSA-N",
  "drugName": "Nilotinib",
  "drugbankId": "DB04868",
  "chemblId": "CHEMBL255863",
  "pubchemCid": "644241",
  "unii": "F41401512X",
  "casNumber": "641571-10-0",
  "atcCodes": ["L01EA03"],
  "moleculeType": "Small molecule",
  "maxPhase": 4,
  "firstApprovalYear": 2007,
  "drugGroups": ["approved", "oral"],
  "molecularFormula": "C28H22F3N7O",
  "molecularWeight": 529.5,
  "primaryIndication": "Chronic Myelocytic Leukemia Accelerated Phase",
  "mechanism": ["Kinase Inhibitor", "tyrosine kinase inhibitors"],
  "url": "https://mychem.info/v1/chem/HHZIURLSWUIHRB-UHFFFAOYSA-N",
  "error": null
}
```

### ✨ Why choose this Actor

- One curated record instead of a deeply nested aggregation blob.
- Cross-references DrugBank, ChEMBL, PubChem, DrugCentral, and UNII in a single row.
- Accepts names, InChIKeys, and free-text queries interchangeably.
- Keyless public source, so no API account or token juggling on the source side.
- Null is honest, never invented, so your downstream joins stay clean.

### 📈 How it compares to alternatives

| Approach | Identifiers | Indications and mechanism | Setup |
|---|---|---|---|
| This Actor | DrugBank, ChEMBL, PubChem, UNII, CAS, ATC in one row | Included | Paste names and run |
| Raw MyChem.info API | Available but deeply nested | Buried in nested blobs | Write your own parser |
| Manual DrugBank lookup | One source at a time | Partial | Slow and manual |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the MyChem.info Drug Annotation Scraper.
3. Enter a `searchQuery`, a `drugList` of names or InChIKeys, or both.
4. Set `maxItems` if you want to cap the run, then start the Actor.
5. Collect your results from the dataset once the run finishes.

### 💼 Business use cases

#### Pharma competitive intelligence

| Goal | How this helps |
|---|---|
| Track approved drug classes | Pull ATC codes and approval years across a target list |
| Benchmark mechanisms | Compare mechanism classes for a therapeutic area |

#### Data engineering and reference data

| Goal | How this helps |
|---|---|
| Build an identifier crosswalk | Map names to DrugBank, ChEMBL, PubChem, and UNII |
| Enrich an existing catalog | Add formula, weight, and CAS to your records |

#### Clinical and regulatory research

| Goal | How this helps |
|---|---|
| Review indications | Read primary and full indication lists per drug |
| Check development status | Use max phase and approval year as filters |

#### Cheminformatics

| Goal | How this helps |
|---|---|
| Seed a structure dataset | Collect SMILES and molecular properties |
| Standardize compound names | Resolve free text to canonical InChIKeys |

### 🔌 Automating MyChem.info Drug Annotation Scraper

Connect runs to the tools your team already uses:

- **Make** and **Zapier** to trigger runs and route records into other apps.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub Actions** to schedule recurring pulls.
- **Google Drive** to archive each run output for your team.

### 🌟 Beyond business use cases

- **Research:** assemble a tidy drug reference table for a literature review.
- **Personal:** look up the formula, weight, and class of a medication you are curious about.
- **Non-profit:** support patient education resources with standardized drug facts.
- **Experimentation:** prototype a chatbot that answers questions about drug identifiers.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to summarize mechanisms, group drugs by ATC class, or spot gaps in your reference table.

### ❓ Frequently Asked Questions

**Is MyChem.info free to query?**
Yes, MyChem.info is a keyless public BioThings API. This Actor adds resolution, curation, and clean output on top.

**What can I put in the drug list?**
Drug names such as imatinib or metformin, or InChIKeys such as KTUFNOKKBVMGRW-UHFFFAOYSA-N. Both are accepted in the same list.

**What does the search query return?**
It returns the best-matching compounds that carry a DrugBank annotation, so you get usable drug records rather than packaging entries.

**Why is a field sometimes null?**
The upstream source had no value for that drug. Nulls are kept as null and never invented.

**Which sources are combined?**
DrugBank, ChEMBL, PubChem, DrugCentral, and UNII, all keyed by InChIKey inside MyChem.info.

**How is a name resolved to a record?**
The Actor searches MyChem.info for the name among drug-annotated compounds and selects the top match.

**Can I pull a whole therapeutic area?**
Yes, use a search query like leukemia or kinase and raise `maxItems` to collect more compounds.

**Does it return chemical structure?**
Yes, each record includes a SMILES string plus molecular formula and weight when available.

**What is the InChIKey used for?**
It is the stable record id in MyChem.info and a portable key for joining across chemical datasets.

**How many records can I get?**
Free plan runs are limited to 10. Paid plans can collect up to 1,000,000.

### 🔌 Integrate with any app

Every run writes to a structured dataset you can pull through the Apify API or connect to your stack with the integrations above.

### 🔗 Recommended Actors

- [deps.dev Package Insights Scraper](https://apify.com/parseforge) for open source package metadata.
- [Libraries.io Scraper](https://apify.com/parseforge) for cross-ecosystem library data.
- [CRAN R Packages Scraper](https://apify.com/parseforge) for the R package universe.

> 💡 **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 MyChem.info or BioThings. Only publicly available data collected.

# Actor input Schema

## `searchQuery` (type: `string`):

A free-text search term such as a therapeutic area or drug name (for example imatinib, leukemia, kinase). The Actor returns the curated annotations for the best-matching drug-annotated compounds. Leave blank when supplying a drug list below.

## `drugList` (type: `array`):

One or more drug names (for example imatinib, aspirin) or InChIKeys (for example KTUFNOKKBVMGRW-UHFFFAOYSA-N). Each entry is resolved to its curated MyChem.info annotation.

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

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

## Actor input object example

```json
{
  "searchQuery": "leukemia",
  "drugList": [
    "imatinib",
    "dasatinib",
    "nilotinib",
    "aspirin",
    "metformin"
  ],
  "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 = {
    "searchQuery": "leukemia",
    "drugList": [
        "imatinib",
        "dasatinib",
        "nilotinib",
        "aspirin",
        "metformin"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/mychem-drug-annotation-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 = {
    "searchQuery": "leukemia",
    "drugList": [
        "imatinib",
        "dasatinib",
        "nilotinib",
        "aspirin",
        "metformin",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/mychem-drug-annotation-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 '{
  "searchQuery": "leukemia",
  "drugList": [
    "imatinib",
    "dasatinib",
    "nilotinib",
    "aspirin",
    "metformin"
  ],
  "maxItems": 10
}' |
apify call parseforge/mychem-drug-annotation-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyChem.info Drug Annotation Scraper",
        "description": "Resolve any drug name or InChIKey into a tidy annotation from MyChem.info. Returns DrugBank name and accession, ChEMBL and PubChem ids, UNII, ATC codes, chemical formula, molecular weight, indications, and mechanism classes. Great for drug reference tables and identifier crosswalks.",
        "version": "0.1",
        "x-build-id": "iLRrJmj6aLsFujyRr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~mychem-drug-annotation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-mychem-drug-annotation-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~mychem-drug-annotation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-mychem-drug-annotation-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~mychem-drug-annotation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-mychem-drug-annotation-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "A free-text search term such as a therapeutic area or drug name (for example imatinib, leukemia, kinase). The Actor returns the curated annotations for the best-matching drug-annotated compounds. Leave blank when supplying a drug list below.",
                        "default": "leukemia"
                    },
                    "drugList": {
                        "title": "Drug Names or InChIKeys",
                        "type": "array",
                        "description": "One or more drug names (for example imatinib, aspirin) or InChIKeys (for example KTUFNOKKBVMGRW-UHFFFAOYSA-N). Each entry is resolved to its curated MyChem.info annotation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
