# openFDA Drug Enforcement Reports Scraper (`automation-lab/openfda-drug-enforcement-reports-scraper`) Actor

Monitor FDA drug enforcement and recall reports by classification, status, firm, product, geography, and dates from the official openFDA API.

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

## Pricing

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

## openFDA Drug Enforcement Reports Scraper

Export FDA drug enforcement and recall reports from the official openFDA API into clean Apify datasets.

Use this actor to monitor drug recalls, enforcement classifications, recalling firms, product descriptions, dates, and distribution details without writing openFDA API queries yourself.

### What does openFDA Drug Enforcement Reports Scraper do?

This actor calls the official `drug/enforcement.json` endpoint from openFDA and saves each FDA enforcement report as a structured dataset item.

It is built for repeat compliance monitoring and due-diligence workflows.

You can filter reports by recall status, classification, firm, geography, product text, report dates, recall initiation dates, termination dates, recall number, and event ID.

The output keeps the key openFDA recall fields and adds traceability fields such as `sourceUrl` and `scrapedAt`.

### Who is it for?

- 🏥 Healthcare compliance teams monitoring recall exposure.
- 💊 Pharmaceutical operations teams tracking products and firms.
- 🚚 Supply-chain teams checking distribution patterns and affected geography.
- ⚖️ Legal and risk teams building recall evidence datasets.
- 📊 Data teams loading FDA enforcement reports into BI tools.
- 🔔 Monitoring teams scheduling repeat Apify runs for new recalls.

### Why use this actor?

openFDA is powerful, but building correct search strings and pagination takes time.

This actor wraps the official API with a friendly input form, safe pagination, typed output, and Apify integrations.

You can run it manually, schedule it, call it by API, connect it to Make or Zapier, or use it from MCP-enabled tools.

### Data source

The data comes from the official openFDA drug enforcement API.

Source endpoint:

`https://api.fda.gov/drug/enforcement.json`

The actor does not use scraped browser pages, private accounts, or unofficial mirrors.

### What data can you extract?

| Field | Description |
| --- | --- |
| `recallNumber` | FDA recall number |
| `status` | Ongoing, Completed, Terminated, or other status |
| `classification` | Class I, Class II, or Class III recall classification |
| `productDescription` | Product description supplied to FDA |
| `reasonForRecall` | Reason for the recall |
| `recallingFirm` | Firm responsible for recall action |
| `city`, `state`, `country` | Recalling firm location |
| `reportDate` | FDA report date |
| `recallInitiationDate` | Recall initiation date |
| `terminationDate` | Termination date when available |
| `distributionPattern` | Distribution notes and geography |
| `openfda` | Raw nested openFDA object |
| `sourceUrl` | Exact API URL used for the page |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape openFDA drug enforcement reports?

The actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-result fee for each FDA enforcement report saved.

Because this actor uses an official JSON API and no browser automation, compute cost is low.

Set `maxItems` to the number of reports you actually need.

### Input options

#### Search

Use `search` for free-text matching across product descriptions, recall reasons, recalling firms, and distribution patterns.

Example search terms:

- `metformin`
- `sterility`
- `Sun Pharmaceutical`
- `nitrosamine`

#### Classification

Use `classification` to filter by FDA recall class.

Common values:

- `Class I`
- `Class II`
- `Class III`

#### Status

Use `status` to track open or closed recall actions.

Common values:

- `Ongoing`
- `Completed`
- `Terminated`

#### Firm and location filters

Use `recallingFirm`, `state`, and `country` to narrow reports to one organization or geography.

This is useful for supplier monitoring and due diligence.

#### Product filters

Use `productDescription` for a drug or product phrase.

Use `productType` when you need a product-type constraint.

#### Date filters

Use report, recall initiation, and termination date ranges.

Accepted date formats:

- `YYYY-MM-DD`
- `YYYYMMDD`

### Example input

```json
{
  "search": "metformin",
  "classification": "Class II",
  "status": "Ongoing",
  "country": "United States",
  "maxItems": 100
}
````

### Example output

```json
{
  "recallNumber": "D-0000-2026",
  "status": "Ongoing",
  "classification": "Class II",
  "productDescription": "Example drug product description",
  "reasonForRecall": "Reason supplied by FDA",
  "recallingFirm": "Example Firm Inc.",
  "city": "Example City",
  "state": "CA",
  "country": "United States",
  "reportDate": "2026-01-01",
  "recallInitiationDate": "2025-12-15",
  "terminationDate": null,
  "distributionPattern": "Nationwide",
  "eventId": "00000",
  "sourceUrl": "https://api.fda.gov/drug/enforcement.json?...",
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
```

### How to run the actor

1. Open the actor on Apify.
2. Enter search terms or structured filters.
3. Set `maxItems`.
4. Optionally add your openFDA API key for higher rate limits.
5. Start the run.
6. Download results as JSON, CSV, Excel, XML, or RSS.

### Scheduling and monitoring

You can schedule this actor to run daily, weekly, or monthly.

Typical monitoring patterns:

- Daily ongoing Class I and Class II recall checks.
- Weekly supplier recall exports.
- Monthly compliance archive snapshots.
- Product-keyword monitoring for risk review.

### Integrations

Send results to your compliance workflow using Apify integrations.

Common patterns:

- Save recalls to Google Sheets.
- Send high-priority classifications to Slack.
- Load reports into a data warehouse.
- Trigger a webhook when new recall records appear.
- Compare scheduled output with a previous dataset.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/openfda-drug-enforcement-reports-scraper').call({
  search: 'metformin',
  classification: 'Class II',
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/openfda-drug-enforcement-reports-scraper').call(run_input={
    'status': 'Ongoing',
    'classification': 'Class II',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~openfda-drug-enforcement-reports-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"search":"metformin","maxItems":100}'
```

### MCP usage

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

MCP endpoint:

`https://mcp.apify.com/?tools=automation-lab/openfda-drug-enforcement-reports-scraper`

Claude Code setup:

```bash
claude mcp add apify-openfda-drug-enforcement https://mcp.apify.com/?tools=automation-lab/openfda-drug-enforcement-reports-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-openfda-drug-enforcement": {
      "url": "https://mcp.apify.com/?tools=automation-lab/openfda-drug-enforcement-reports-scraper"
    }
  }
}
```

Example prompts:

- "Run the openFDA drug enforcement reports scraper for ongoing Class II recalls."
- "Find FDA drug enforcement reports mentioning metformin from 2024 onward."
- "Export recall reports for this supplier and summarize the classification mix."

### Tips for best results

- Start with `maxItems` 100 to validate your filters.
- Use classification and status filters for high-signal monitoring.
- Use date ranges for repeat scheduled jobs.
- Add an openFDA API key if you run many large exports.
- Keep `sourceUrl` in downstream storage for audit traceability.

### FAQ

#### Is this data from the official FDA API?

Yes. The actor calls the official openFDA drug enforcement endpoint and preserves the FDA recall fields in the output dataset.

#### Can I use it for recurring monitoring?

Yes. Use Apify schedules with status, classification, product, firm, and date filters to build repeat monitoring workflows.

### Troubleshooting

#### Why did my run return zero items?

Your filters may be too narrow or the exact openFDA field value may differ from your expectation.

Try removing one filter at a time, or start with only `search` and `maxItems`.

#### Why did I get a rate-limit error?

openFDA applies public API limits.

Retry later, reduce run volume, or add an optional openFDA API key.

#### Why are some date fields empty?

Not every enforcement report has every lifecycle date.

The actor preserves missing values as `null`.

### Legality and compliance

This actor reads public data from the official openFDA API.

You are responsible for how you use and interpret FDA enforcement data.

Always verify high-impact compliance decisions against official FDA sources and your internal policies.

### Related scrapers

Explore related Automation Lab actors for public-data, compliance, and monitoring workflows:

- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/rss-feed-scraper

### Changelog

#### 0.1

Initial version with openFDA drug enforcement filters, pagination, typed output, PPE charging, and compliance-ready dataset fields.

### Support

If you need a new filter, different output mapping, or integration advice, open an issue on the actor page.

### Summary

openFDA Drug Enforcement Reports Scraper turns official FDA recall data into a repeatable Apify dataset.

It is designed for healthcare, pharma, supply-chain, legal, and risk teams that need reliable drug recall monitoring.

# Actor input Schema

## `search` (type: `string`):

Search product descriptions, recall reasons, recalling firms, and distribution patterns.

## `classification` (type: `string`):

Filter by FDA classification, for example Class I, Class II, or Class III.

## `status` (type: `string`):

Filter by recall status such as Ongoing, Completed, or Terminated.

## `state` (type: `string`):

Two-letter US state code of the recalling firm, for example CA or NY.

## `country` (type: `string`):

Country of the recalling firm.

## `recallingFirm` (type: `string`):

Exact or partial recalling firm name.

## `productDescription` (type: `string`):

Filter FDA product\_description for a drug/product term.

## `productType` (type: `string`):

openFDA product\_type value. Drug enforcement reports typically use Drugs.

## `recallNumber` (type: `string`):

FDA recall number, for example D-1234-2024.

## `eventId` (type: `string`):

FDA enforcement event\_id.

## `reportDateFrom` (type: `string`):

Earliest FDA report\_date. Use YYYY-MM-DD or YYYYMMDD.

## `reportDateTo` (type: `string`):

Latest FDA report\_date. Use YYYY-MM-DD or YYYYMMDD.

## `recallInitiationDateFrom` (type: `string`):

Earliest recall\_initiation\_date. Use YYYY-MM-DD or YYYYMMDD.

## `recallInitiationDateTo` (type: `string`):

Latest recall\_initiation\_date. Use YYYY-MM-DD or YYYYMMDD.

## `terminationDateFrom` (type: `string`):

Earliest termination\_date. Use YYYY-MM-DD or YYYYMMDD.

## `terminationDateTo` (type: `string`):

Latest termination\_date. Use YYYY-MM-DD or YYYYMMDD.

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

Maximum enforcement reports to save to the dataset.

## `apiKey` (type: `string`):

Optional openFDA API key for higher rate limits. Leave blank for normal small and medium exports.

## Actor input object example

```json
{
  "search": "metformin",
  "classification": "Class II",
  "status": "Ongoing",
  "country": "United States",
  "maxItems": 20
}
```

# 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 = {
    "search": "metformin",
    "classification": "Class II",
    "status": "Ongoing",
    "country": "United States",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/openfda-drug-enforcement-reports-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 = {
    "search": "metformin",
    "classification": "Class II",
    "status": "Ongoing",
    "country": "United States",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/openfda-drug-enforcement-reports-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 '{
  "search": "metformin",
  "classification": "Class II",
  "status": "Ongoing",
  "country": "United States",
  "maxItems": 20
}' |
apify call automation-lab/openfda-drug-enforcement-reports-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "openFDA Drug Enforcement Reports Scraper",
        "description": "Monitor FDA drug enforcement and recall reports by classification, status, firm, product, geography, and dates from the official openFDA API.",
        "version": "0.1",
        "x-build-id": "6FzIH6jhbcIPXuuBP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~openfda-drug-enforcement-reports-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-openfda-drug-enforcement-reports-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~openfda-drug-enforcement-reports-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-openfda-drug-enforcement-reports-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~openfda-drug-enforcement-reports-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-openfda-drug-enforcement-reports-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": {
                    "search": {
                        "title": "Free-text search",
                        "type": "string",
                        "description": "Search product descriptions, recall reasons, recalling firms, and distribution patterns."
                    },
                    "classification": {
                        "title": "Recall classification",
                        "enum": [
                            "",
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "Filter by FDA classification, for example Class I, Class II, or Class III."
                    },
                    "status": {
                        "title": "Recall status",
                        "enum": [
                            "",
                            "Ongoing",
                            "Completed",
                            "Terminated"
                        ],
                        "type": "string",
                        "description": "Filter by recall status such as Ongoing, Completed, or Terminated."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter US state code of the recalling firm, for example CA or NY."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country of the recalling firm."
                    },
                    "recallingFirm": {
                        "title": "Recalling firm",
                        "type": "string",
                        "description": "Exact or partial recalling firm name."
                    },
                    "productDescription": {
                        "title": "Product description contains",
                        "type": "string",
                        "description": "Filter FDA product_description for a drug/product term."
                    },
                    "productType": {
                        "title": "Product type",
                        "type": "string",
                        "description": "openFDA product_type value. Drug enforcement reports typically use Drugs."
                    },
                    "recallNumber": {
                        "title": "Recall number",
                        "type": "string",
                        "description": "FDA recall number, for example D-1234-2024."
                    },
                    "eventId": {
                        "title": "Event ID",
                        "type": "string",
                        "description": "FDA enforcement event_id."
                    },
                    "reportDateFrom": {
                        "title": "Report date from",
                        "type": "string",
                        "description": "Earliest FDA report_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "reportDateTo": {
                        "title": "Report date to",
                        "type": "string",
                        "description": "Latest FDA report_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "recallInitiationDateFrom": {
                        "title": "Recall initiation date from",
                        "type": "string",
                        "description": "Earliest recall_initiation_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "recallInitiationDateTo": {
                        "title": "Recall initiation date to",
                        "type": "string",
                        "description": "Latest recall_initiation_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "terminationDateFrom": {
                        "title": "Termination date from",
                        "type": "string",
                        "description": "Earliest termination_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "terminationDateTo": {
                        "title": "Termination date to",
                        "type": "string",
                        "description": "Latest termination_date. Use YYYY-MM-DD or YYYYMMDD."
                    },
                    "maxItems": {
                        "title": "Maximum reports",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum enforcement reports to save to the dataset.",
                        "default": 20
                    },
                    "apiKey": {
                        "title": "openFDA API key (optional)",
                        "type": "string",
                        "description": "Optional openFDA API key for higher rate limits. Leave blank for normal small and medium exports."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
