# FDA Medical Device Recalls Scraper (`automation-lab/fda-medical-device-recalls-scraper`) Actor

Extract official FDA medical device recall records from openFDA by firm, product, class, status, location, and date. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/fda-medical-device-recalls-scraper.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

## FDA Medical Device Recalls Scraper

Extract official FDA medical device recall and enforcement records from the openFDA `device/enforcement` API. Use it to monitor device recalls by firm, product text, recall class, status, location, and date range.

### What does FDA Medical Device Recalls Scraper do?

FDA Medical Device Recalls Scraper turns the public openFDA medical-device enforcement endpoint into a clean Apify dataset.

It helps you collect recall records without writing openFDA query syntax by hand.

You can filter by manufacturer, product description, class, status, dates, state, country, recall number, or event ID.

The actor saves one structured dataset item per recall record.

### Who is it for?

Regulatory affairs teams can track recall activity for manufacturers, product lines, and device classes.

Quality and compliance teams can monitor Class I and Class II recalls for risk reviews.

Supplier-risk teams can watch vendors and distributors named in FDA recall records.

Healthcare procurement teams can screen recalled devices before renewals or sourcing decisions.

Competitive-intelligence analysts can follow recall patterns across medical device companies.

### Why use this FDA recall extractor?

🧾 It uses official FDA data through openFDA.

⚙️ It runs as a repeatable API workflow on Apify.

📅 It supports date ranges for recurring monitoring.

🏷️ It includes recall class, status, event ID, recall number, and location fields.

📦 It exports to JSON, CSV, Excel, XML, RSS, and integrations through Apify datasets.

### Data source

The actor reads the openFDA device enforcement endpoint:

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

This endpoint contains FDA medical-device recall and enforcement records.

The actor does not use a browser.

The actor does not require a login.

The actor does not require an FDA API key for normal runs.

### How much does it cost to extract FDA medical device recalls?

This actor uses pay-per-event pricing.

You pay a small start event per run and a per-record event for each recall row saved.

Use `maxItems` to control run cost.

A default run collects 100 recall records.

Large monitoring jobs can increase `maxItems` up to the openFDA pagination safety limit.

### Input options

| Field | Description |
| --- | --- |
| `maxItems` | Maximum recall records to save. |
| `search` | Advanced openFDA search expression. |
| `firmName` | Recalling firm, manufacturer, or distributor. |
| `productText` | Device or product description text. |
| `recallNumber` | Exact FDA recall number. |
| `eventId` | Exact FDA event ID. |
| `classification` | Class I, Class II, or Class III. |
| `status` | Ongoing, Terminated, or Completed. |
| `state` | Recalling firm state. |
| `country` | Recalling firm country. |
| `dateField` | Date field used for range filtering. |
| `startDate` | Inclusive start date. |
| `endDate` | Inclusive end date. |
| `sortBy` | Date field used for sorting. |
| `sortDirection` | Newest or oldest first. |

### Example input

```json
{
  "maxItems": 100,
  "firmName": "Medtronic",
  "classification": "Class I",
  "dateField": "report_date",
  "startDate": "2024-01-01",
  "sortBy": "report_date",
  "sortDirection": "desc"
}
````

### Output data

Each dataset row represents one FDA medical-device recall record.

| Field | Description |
| --- | --- |
| `recallNumber` | FDA recall number. |
| `eventId` | FDA enforcement event ID. |
| `status` | Recall status. |
| `classification` | FDA recall class. |
| `recallingFirm` | Firm responsible for the recall. |
| `productDescription` | FDA product description. |
| `reasonForRecall` | Reason for recall. |
| `codeInfo` | Affected lots, codes, GTINs, or identifiers. |
| `moreCodeInfo` | Additional code information when present. |
| `distributionPattern` | Geographic distribution information. |
| `productQuantity` | Quantity affected. |
| `productType` | FDA product type. |
| `voluntaryMandated` | Voluntary or mandated recall indicator. |
| `initialFirmNotification` | How the firm notified customers. |
| `recallInitiationDate` | Recall initiation date. |
| `centerClassificationDate` | FDA center classification date. |
| `reportDate` | FDA report date. |
| `city` | Firm city. |
| `state` | Firm state. |
| `country` | Firm country. |
| `postalCode` | Firm postal code. |
| `address` | Combined firm address. |
| `openfda` | openFDA metadata object. |
| `sourceUrl` | Source endpoint URL. |
| `scrapedAt` | Timestamp when the row was saved. |

### Example output

```json
{
  "recallNumber": "Z-2372-2023",
  "eventId": "92660",
  "status": "Ongoing",
  "classification": "Class I",
  "recallingFirm": "Covidien LP",
  "productDescription": "MAHURKAR catheter...",
  "reasonForRecall": "Catheter center lumen was found to have an occlusion...",
  "reportDate": "20230823",
  "state": "MA",
  "country": "United States"
}
```

### How to scrape FDA medical device recalls

1. Open the actor on Apify.

2. Enter a firm name, device keyword, recall class, or date range.

3. Set `maxItems` for the number of records you need.

4. Start the run.

5. Download the dataset as JSON, CSV, Excel, or through the Apify API.

### Monitoring workflows

Run the actor daily with a `startDate` matching your monitoring window.

Filter `classification` to `Class I` for highest-severity alerts.

Filter by `firmName` for supplier watchlists.

Filter by `productText` for device families such as catheters, infusion pumps, stents, or syringes.

### Compliance workflow examples

🛡️ Supplier risk: monitor recalls for critical device suppliers.

📋 Audit preparation: export recall records for a product category before a quality review.

🏥 Procurement screening: check whether a vendor has active recalls before contract renewal.

📈 Competitive intelligence: compare recall frequency across device manufacturers.

### Tips for best results

Use date ranges to keep recurring runs small and focused.

Use exact recall numbers when investigating one FDA notice.

Use `productText` for broad device-family monitoring.

Use `search` only when you already know openFDA syntax.

If no records are returned, broaden firm spelling or remove optional filters.

### Advanced openFDA search

The `search` field accepts an openFDA search expression.

For example:

```text
product_description:catheter+AND+classification:"Class I"
```

When you combine `search` with UI filters, the actor joins all conditions with `AND`.

### Integrations

Send new recalls to Slack by connecting the dataset to an Apify integration.

Export CSV files to a GRC or quality-management system.

Trigger the actor from a scheduler for daily supplier monitoring.

Use webhooks to notify a compliance analyst when a run finishes.

Join output with vendor master data in your warehouse.

### 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/fda-medical-device-recalls-scraper').call({
  maxItems: 100,
  classification: 'Class I',
  startDate: '2024-01-01'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/fda-medical-device-recalls-scraper').call(run_input={
    'maxItems': 100,
    'firmName': 'Medtronic'
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~fda-medical-device-recalls-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"classification":"Class I"}'
```

### MCP usage

FDA Medical Device Recalls Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Setup for Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/fda-medical-device-recalls-scraper"
```

Setup for Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fda-medical-device-recalls-scraper"
    }
  }
}
```

Example prompts:

```text
Use automation-lab/fda-medical-device-recalls-scraper to find Class I medical device recalls reported since 2024-01-01.
```

```text
Run the FDA device recall monitor for Medtronic and summarize the latest recalled product categories.
```

```text
Extract catheter recall records from openFDA and group the results by recalling firm and recall status.
```

### Automation ideas

Schedule weekly Class I recall monitoring.

Run a monthly supplier recall report.

Watch a list of high-risk device categories.

Export new event IDs into a compliance ticketing system.

### Troubleshooting

If a run returns zero items, remove filters one by one.

If firm matching is too strict, use a shorter firm name.

If dates fail validation, use `YYYY-MM-DD` or `YYYYMMDD`.

If openFDA rate limits a run, retry later or lower the result volume.

### Limitations

The actor returns records available in openFDA.

It does not interpret clinical risk beyond FDA-provided fields.

It does not replace FDA notices, legal review, or regulatory judgment.

It is designed for monitoring and data extraction workflows.

### Legality

This actor uses a public US government API.

Users are responsible for complying with openFDA terms, Apify terms, and their internal compliance policies.

Always verify critical recall decisions against official FDA sources.

### Related scrapers

- [FDA Food Recalls Scraper](https://apify.com/automation-lab/fda-food-recalls-scraper)
- [FDA MAUDE Adverse Event Reports Scraper](https://apify.com/automation-lab/fda-maude-adverse-event-reports-scraper)
- [FDA Device Registration Scraper](https://apify.com/automation-lab/fda-device-registration-scraper)
- [OpenFDA Drug NDC Directory Scraper](https://apify.com/automation-lab/openfda-drug-ndc-directory-scraper)

### FAQ

#### Can I monitor one company?

Yes. Set `firmName` and run the actor on a schedule.

#### Can I collect only severe recalls?

Yes. Set `classification` to `Class I`.

#### Can I search by device type?

Yes. Use `productText`, for example `catheter`, `pump`, `stent`, or `syringe`.

#### Does this require an FDA API key?

No. Normal runs use the public openFDA endpoint without an API key.

#### Does the actor use proxies?

No. It is an HTTP API actor and does not need proxies.

#### Can I use it for historical exports?

Yes. Increase `maxItems` and set broad date ranges, keeping openFDA pagination limits in mind.

### Changelog

Initial version extracts FDA medical-device recall records from openFDA device enforcement data.

# Actor input Schema

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

Maximum number of FDA medical-device recall records to save.

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

Optional advanced openFDA search expression. Example: product\_description:catheter+AND+classification:"Class I".

## `firmName` (type: `string`):

Filter by recalling firm, manufacturer, or distributor name.

## `productText` (type: `string`):

Filter by text in the FDA product description, such as catheter, infusion pump, stent, or syringe.

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

Exact FDA recall number, for example Z-2372-2023.

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

Exact FDA enforcement event ID.

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

FDA recall class severity.

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

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

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

Two-letter US state abbreviation for the recalling firm location.

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

Country of the recalling firm. Default openFDA records often use United States.

## `dateField` (type: `string`):

FDA date field to apply the start/end date range to.

## `startDate` (type: `string`):

Inclusive start date in YYYY-MM-DD or YYYYMMDD format.

## `endDate` (type: `string`):

Inclusive end date in YYYY-MM-DD or YYYYMMDD format.

## `sortBy` (type: `string`):

FDA field used for sorting results.

## `sortDirection` (type: `string`):

Newest first (desc) or oldest first (asc).

## Actor input object example

```json
{
  "maxItems": 20,
  "firmName": "Medtronic",
  "dateField": "report_date",
  "startDate": "2024-01-01",
  "sortBy": "report_date",
  "sortDirection": "desc"
}
```

# 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 = {
    "maxItems": 20,
    "firmName": "Medtronic",
    "dateField": "report_date",
    "startDate": "2024-01-01",
    "sortBy": "report_date",
    "sortDirection": "desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fda-medical-device-recalls-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 = {
    "maxItems": 20,
    "firmName": "Medtronic",
    "dateField": "report_date",
    "startDate": "2024-01-01",
    "sortBy": "report_date",
    "sortDirection": "desc",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fda-medical-device-recalls-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 '{
  "maxItems": 20,
  "firmName": "Medtronic",
  "dateField": "report_date",
  "startDate": "2024-01-01",
  "sortBy": "report_date",
  "sortDirection": "desc"
}' |
apify call automation-lab/fda-medical-device-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Medical Device Recalls Scraper",
        "description": "Extract official FDA medical device recall records from openFDA by firm, product, class, status, location, and date. Export JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "Xz5QUcQFtkFHquf6j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fda-medical-device-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fda-medical-device-recalls-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~fda-medical-device-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fda-medical-device-recalls-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~fda-medical-device-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fda-medical-device-recalls-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": {
                    "maxItems": {
                        "title": "Maximum recall records",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of FDA medical-device recall records to save.",
                        "default": 20
                    },
                    "search": {
                        "title": "openFDA search query",
                        "type": "string",
                        "description": "Optional advanced openFDA search expression. Example: product_description:catheter+AND+classification:\"Class I\"."
                    },
                    "firmName": {
                        "title": "Recalling firm name",
                        "type": "string",
                        "description": "Filter by recalling firm, manufacturer, or distributor name."
                    },
                    "productText": {
                        "title": "Device or product text",
                        "type": "string",
                        "description": "Filter by text in the FDA product description, such as catheter, infusion pump, stent, or syringe."
                    },
                    "recallNumber": {
                        "title": "FDA recall number",
                        "type": "string",
                        "description": "Exact FDA recall number, for example Z-2372-2023."
                    },
                    "eventId": {
                        "title": "FDA event ID",
                        "type": "string",
                        "description": "Exact FDA enforcement event ID."
                    },
                    "classification": {
                        "title": "Recall classification",
                        "enum": [
                            "Class I",
                            "Class II",
                            "Class III"
                        ],
                        "type": "string",
                        "description": "FDA recall class severity."
                    },
                    "status": {
                        "title": "Recall status",
                        "enum": [
                            "Ongoing",
                            "Terminated",
                            "Completed"
                        ],
                        "type": "string",
                        "description": "Filter by FDA recall status, such as Ongoing, Terminated, or Completed."
                    },
                    "state": {
                        "title": "Firm state",
                        "type": "string",
                        "description": "Two-letter US state abbreviation for the recalling firm location."
                    },
                    "country": {
                        "title": "Firm country",
                        "type": "string",
                        "description": "Country of the recalling firm. Default openFDA records often use United States."
                    },
                    "dateField": {
                        "title": "Date field for range",
                        "enum": [
                            "report_date",
                            "recall_initiation_date",
                            "center_classification_date"
                        ],
                        "type": "string",
                        "description": "FDA date field to apply the start/end date range to.",
                        "default": "report_date"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Inclusive start date in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Inclusive end date in YYYY-MM-DD or YYYYMMDD format."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "report_date",
                            "recall_initiation_date",
                            "center_classification_date"
                        ],
                        "type": "string",
                        "description": "FDA field used for sorting results.",
                        "default": "report_date"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Newest first (desc) or oldest first (asc).",
                        "default": "desc"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
