# EMA Drug Approval Watch (`automation-lab/ema-drug-approval-watch`) Actor

Monitor official EMA medicine approvals, post-authorisation changes, referrals, orphan designations, and shortages from public XLSX reports.

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

## Pricing

Pay per event

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

## EMA Drug Approval Watch

Monitor official European Medicines Agency (EMA) medicine data from public XLSX reports. The actor downloads EMA workbooks, normalizes regulatory rows, and can emit change-monitoring flags for recurring workflows.

### What does EMA Drug Approval Watch do?

EMA Drug Approval Watch turns the EMA medicine-data download page into structured Apify dataset rows.

- 📥 Downloads official EMA XLSX reports over HTTP
- 🧾 Parses centrally authorised medicines, post-authorisation procedures, referrals, orphan designations, and shortages
- 🔁 Supports recurring monitor mode with `isNew`, `isUpdated`, and `changedFields`
- 🔎 Filters by medicine name, active substance, applicant, condition, status, or any workbook text
- 📅 Filters records by date-like columns such as decision, opinion, authorisation, or update dates
- 🧩 Preserves raw workbook fields for auditability

### Who is it for?

This actor is designed for teams that need repeatable EU regulatory intelligence.

- Regulatory affairs teams tracking EMA approvals and variations
- Competitive intelligence teams monitoring competitor medicine portfolios
- Market access teams watching new products and indication movements
- Pharmacovigilance teams following shortages and safety-relevant status changes
- Business development teams scanning orphan designations and therapeutic areas
- Data vendors building healthcare intelligence feeds

### Why use this actor?

The EMA publishes useful XLSX files, but the workbooks have different columns, metadata rows, and report-specific formats. This actor provides a single normalized dataset that is easier to schedule, diff, export, and integrate.

### Official EMA data sources

The actor starts from the public EMA page:

`https://www.ema.europa.eu/en/medicines/download-medicine-data`

It discovers linked XLSX report URLs and falls back to known official file names if the page layout changes.

### Supported report types

| Report type | Input value | Typical use |
| --- | --- | --- |
| Centrally authorised medicines | `medicines` | Approved, refused, withdrawn, suspended, or authorised medicines |
| Post-authorisation procedures | `postAuthorisation` | Variations and lifecycle changes after authorisation |
| Referrals | `referrals` | EU referral procedures and outcomes |
| Orphan designations | `orphanDesignations` | Orphan medicinal product designations |
| Medicine shortages | `shortages` | Shortage and availability monitoring |
| Herbal medicines | `herbalMedicines` | Herbal medicine data when available |
| Opinions outside the EU | `opinionsOutsideEu` | CHMP opinions for medicines used outside the EU when available |

### Data you can extract

Each output row includes normalized fields where they are present in the source workbook.

| Field | Description |
| --- | --- |
| `recordId` | Stable row ID derived from report type and natural keys |
| `reportType` | Selected report identifier |
| `reportTitle` | Human-readable report title |
| `medicineName` | Medicine or product name |
| `activeSubstance` | Active substance / INN when available |
| `therapeuticArea` | Therapeutic area, condition, or indication text |
| `applicantOrMah` | Applicant, sponsor, or marketing authorisation holder |
| `procedureNumber` | EMA product, procedure, application, or designation number |
| `authorisationStatus` | Status or outcome from the workbook |
| `decisionDate` | Normalized decision/authorisation date when detected |
| `opinionDate` | Normalized opinion date when detected |
| `productCategory` | Human/veterinary/category values when present |
| `country` | Country/member-state value when present |
| `shortageStatus` | Shortage status when present |
| `rawFields` | Original workbook fields after whitespace cleanup |
| `isNew` | True if the row was not in the previous monitor snapshot |
| `isUpdated` | True if a known row changed since the previous monitor snapshot |
| `changedFields` | Raw workbook columns that changed |
| `sourceUrl` | Direct EMA workbook URL |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to monitor EMA drug approvals?

The actor uses pay-per-event pricing: a small start fee plus a per-record charge. You control cost with `maxItems`, report selection, and filters.

For scheduled monitoring, start with a focused report list and a specific `textSearch` or `sinceDate` filter. Increase `maxItems` only after confirming the output volume you need.

### How to run

1. Choose one or more EMA report types.
2. Set `maxItems` to your desired output cap.
3. Optionally add `textSearch` for a medicine, substance, applicant, or condition.
4. Optionally enable `monitorMode` for recurring delta output.
5. Run the actor and export the Apify dataset as JSON, CSV, Excel, RSS, or through the API.

### Input options

#### `reportTypes`

Array of report identifiers. If omitted, the actor uses a practical default set.

#### `maxItems`

Maximum number of dataset rows to save. In monitor mode, the actor can scan the full selected source and save up to this number of changed rows while updating the snapshot.

#### `textSearch`

Optional case-insensitive search across all workbook cells. Examples:

- `ranibizumab`
- `oncology`
- `Pfizer`
- `shortage`

#### `sinceDate`

Optional date filter. Use an ISO-style date such as `2026-01-01`. The actor checks date-like source columns and keeps records with relevant dates on or after the value.

#### `monitorMode`

When true, the actor stores a snapshot in the key-value store and marks future records as new or updated.

#### `includeUnchanged`

When false in monitor mode, the actor outputs only new or updated rows. When true, it outputs matching current rows with delta flags.

#### `snapshotKey`

Advanced setting for independent monitoring workflows. Use a different key for different report/filter combinations.

### Example input: approval watch

```json
{
  "reportTypes": ["medicines"],
  "maxItems": 250,
  "sinceDate": "2026-01-01",
  "monitorMode": true,
  "snapshotKey": "ema-medicines-approvals"
}
````

### Example input: shortages monitor

```json
{
  "reportTypes": ["shortages"],
  "maxItems": 500,
  "monitorMode": true,
  "includeUnchanged": false,
  "snapshotKey": "ema-shortages-watch"
}
```

### Example input: substance search

```json
{
  "reportTypes": ["medicines", "postAuthorisation", "orphanDesignations"],
  "textSearch": "ranibizumab",
  "maxItems": 100
}
```

### Output example

```json
{
  "reportType": "medicines",
  "medicineName": "Rexatilux",
  "activeSubstance": "ranibizumab",
  "authorisationStatus": "Authorised",
  "decisionDate": "2026-06-19",
  "isNew": true,
  "isUpdated": false,
  "changedFields": []
}
```

### Monitor and delta workflow

Use Apify schedules for daily or weekly monitoring. On the first monitor run, rows are usually marked `isNew` because no snapshot exists. Later runs compare the current workbook rows with the stored snapshot.

Recommended pattern:

1. Run once with monitor mode enabled.
2. Review the output and snapshot key.
3. Schedule the actor at your preferred cadence.
4. Send changed rows to Slack, email, Google Sheets, BigQuery, or your internal data warehouse.

### Tips for better results

- Use `textSearch` for portfolio monitoring by substance, applicant, or disease area.
- Keep separate `snapshotKey` values for separate teams or workflows.
- Select only the reports you need to reduce runtime and output noise.
- Use `includeUnchanged: true` when you need a complete current-state export plus delta flags.
- Use `sinceDate` for recent approvals or recent procedure changes.

### Integrations

EMA Drug Approval Watch works with Apify integrations and webhooks.

- Send new approvals to Slack with a dataset webhook
- Append shortage updates to Google Sheets
- Load normalized EMA rows into BigQuery or Snowflake
- Trigger an internal review workflow when `isUpdated` is true
- Combine with other automation-lab healthcare actors for wider regulatory monitoring

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ema-drug-approval-watch').call({
  reportTypes: ['medicines'],
  maxItems: 100,
  monitorMode: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/ema-drug-approval-watch').call(run_input={
    'reportTypes': ['shortages'],
    'maxItems': 100,
    'monitorMode': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ema-drug-approval-watch/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"reportTypes":["medicines"],"maxItems":100}'
```

### MCP usage

Use this actor through Apify MCP in Claude Desktop or Claude Code:

`https://mcp.apify.com/?tools=automation-lab/ema-drug-approval-watch`

Claude Code setup:

```bash
claude mcp add apify-ema-drug-approval-watch https://mcp.apify.com/?tools=automation-lab/ema-drug-approval-watch
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-ema-drug-approval-watch": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ema-drug-approval-watch"
    }
  }
}
```

Example prompts:

- “Run the EMA Drug Approval Watch for medicine shortages and summarize new rows.”
- “Find EMA records mentioning ranibizumab and return active substance, status, and decision date.”
- “Monitor EMA orphan designations weekly and flag updated rows.”

### Data quality notes

EMA workbooks are official public sources, but each report can have different columns. The actor keeps normalized fields conservative and preserves `rawFields` so analysts can verify any record against the original workbook.

### Limitations

- The actor does not interpret clinical significance.
- It does not replace legal or regulatory review.
- Some optional report links may change or be temporarily unavailable.
- Field availability depends on the selected EMA workbook.

### Troubleshooting

#### Why did the first monitor run output many new rows?

The first monitor run creates the snapshot, so matching rows are new by definition. Later runs only flag rows that are new or changed.

#### Why are some normalized fields null?

EMA report schemas differ. If a workbook does not contain a matching column, the normalized field is null and the source value remains available in `rawFields`.

#### Why did a text search return fewer rows than expected?

`textSearch` searches exact cell text after whitespace cleanup. Try a broader substance, applicant, or disease keyword.

### Legality

This actor downloads public EMA files. Users are responsible for using the data in accordance with applicable laws, regulations, EMA terms, and internal compliance policies.

### FAQ

#### Does this actor use the official EMA source?

Yes. It downloads workbooks linked from the official EMA medicine-data download page.

#### Can I schedule it as a monitor?

Yes. Enable `monitorMode`, choose a stable `snapshotKey`, and run it on an Apify schedule.

#### Can I export the output to Excel?

Yes. Apify datasets can be exported as Excel, CSV, JSON, XML, RSS, or accessed through the API.

### Related scrapers

Explore related automation-lab actors for healthcare and regulatory intelligence on Apify:

- https://apify.com/automation-lab/fda-drug-approval-watch
- https://apify.com/automation-lab/medical-device-recall-scraper
- https://apify.com/automation-lab/who-medical-news-scraper

### Changelog

Initial version: public EMA XLSX download parsing, normalized records, and KV snapshot monitor mode.

### Support

If EMA changes a workbook format or you need an additional normalized field, open an Apify issue with the report type, source row, and expected output.

# Actor input Schema

## `reportTypes` (type: `array`):

Select which official EMA downloadable medicine-data reports to parse.

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

Maximum normalized records to save across all selected reports. Keep small for smoke tests; use 500+ for monitoring.

## `textSearch` (type: `string`):

Optional case-insensitive search across all workbook cells, e.g. an active substance, medicine name, applicant, or condition.

## `sinceDate` (type: `string`):

Optional ISO date filter. The actor checks date-like workbook columns such as decision date, opinion date, and authorisation date.

## `monitorMode` (type: `boolean`):

Compare rows with a key-value-store snapshot from previous runs and mark isNew/isUpdated plus changedFields.

## `includeUnchanged` (type: `boolean`):

When disabled, monitor runs output only new or updated rows. Non-monitor runs always output current matching rows.

## `snapshotKey` (type: `string`):

Advanced: key-value-store record name used for monitor snapshots. Use different keys for independent workflows.

## Actor input object example

```json
{
  "reportTypes": [
    "medicines",
    "postAuthorisation",
    "shortages"
  ],
  "maxItems": 20,
  "monitorMode": false,
  "includeUnchanged": false,
  "snapshotKey": "ema-drug-approval-watch-snapshot"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "reportTypes": [
        "medicines",
        "postAuthorisation",
        "shortages"
    ],
    "maxItems": 20,
    "monitorMode": false,
    "includeUnchanged": false,
    "snapshotKey": "ema-drug-approval-watch-snapshot"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ema-drug-approval-watch").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 = {
    "reportTypes": [
        "medicines",
        "postAuthorisation",
        "shortages",
    ],
    "maxItems": 20,
    "monitorMode": False,
    "includeUnchanged": False,
    "snapshotKey": "ema-drug-approval-watch-snapshot",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ema-drug-approval-watch").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 '{
  "reportTypes": [
    "medicines",
    "postAuthorisation",
    "shortages"
  ],
  "maxItems": 20,
  "monitorMode": false,
  "includeUnchanged": false,
  "snapshotKey": "ema-drug-approval-watch-snapshot"
}' |
apify call automation-lab/ema-drug-approval-watch --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EMA Drug Approval Watch",
        "description": "Monitor official EMA medicine approvals, post-authorisation changes, referrals, orphan designations, and shortages from public XLSX reports.",
        "version": "0.1",
        "x-build-id": "zkXMPmEWhkhILbyZP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ema-drug-approval-watch/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ema-drug-approval-watch",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ema-drug-approval-watch/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ema-drug-approval-watch",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ema-drug-approval-watch/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ema-drug-approval-watch",
                "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": {
                    "reportTypes": {
                        "title": "Report types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select which official EMA downloadable medicine-data reports to parse.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "medicines",
                                "postAuthorisation",
                                "referrals",
                                "orphanDesignations",
                                "shortages",
                                "herbalMedicines",
                                "opinionsOutsideEu"
                            ],
                            "enumTitles": [
                                "Centrally authorised medicines",
                                "Post-authorisation procedures",
                                "Referrals",
                                "Orphan designations",
                                "Medicine shortages",
                                "Herbal medicines",
                                "Opinions outside the EU"
                            ]
                        },
                        "default": [
                            "medicines",
                            "postAuthorisation",
                            "shortages"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum normalized records to save across all selected reports. Keep small for smoke tests; use 500+ for monitoring.",
                        "default": 20
                    },
                    "textSearch": {
                        "title": "Text contains",
                        "type": "string",
                        "description": "Optional case-insensitive search across all workbook cells, e.g. an active substance, medicine name, applicant, or condition."
                    },
                    "sinceDate": {
                        "title": "Only records dated on/after",
                        "type": "string",
                        "description": "Optional ISO date filter. The actor checks date-like workbook columns such as decision date, opinion date, and authorisation date."
                    },
                    "monitorMode": {
                        "title": "Enable monitor/delta mode",
                        "type": "boolean",
                        "description": "Compare rows with a key-value-store snapshot from previous runs and mark isNew/isUpdated plus changedFields.",
                        "default": false
                    },
                    "includeUnchanged": {
                        "title": "Include unchanged records in monitor mode",
                        "type": "boolean",
                        "description": "When disabled, monitor runs output only new or updated rows. Non-monitor runs always output current matching rows.",
                        "default": false
                    },
                    "snapshotKey": {
                        "title": "Snapshot key",
                        "type": "string",
                        "description": "Advanced: key-value-store record name used for monitor snapshots. Use different keys for independent workflows.",
                        "default": "ema-drug-approval-watch-snapshot"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
