# FDA Food Recall Monitor (`maximedupre/fda-food-recalls-scraper`) Actor

Search, export, and monitor official openFDA Food Enforcement recalls. Filter by product, firm, class, status, location, or date, and track new or updated recalls.

- **URL**: https://apify.com/maximedupre/fda-food-recalls-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Automation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / 1,000 food recalls

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### 🥫 Find and monitor official FDA food recalls

FDA Food Recall Monitor helps food-safety, compliance, retail, and supply-chain teams search official openFDA Food Enforcement data. Return product details, recall reasons, classifications, statuses, firms, locations, dates, identifiers, and source links for review or monitoring.

- **[FDA food recalls scraper](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-food-recalls-scraper)** — collect matching recall data for analysis or archiving.
- **[FDA food recall search](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-food-recall-search)** — find recalls by product description or recall reason.
- **[FDA recall number lookup](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-recall-number-lookup)** — verify a known FDA enforcement action.
- **[FDA recall event lookup](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-recall-event-lookup)** — retrieve recalls grouped under a known FDA event identifier.
- **[FDA food recall monitor](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-food-recall-monitor)** — emit newly seen, status-changed, or otherwise updated recalls on scheduled runs.
- **[FDA food recall data export](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-food-recall-data-export)** — prepare official recall data for spreadsheets and downstream systems.
- **[FDA Class I food recalls](https://apify.com/maximedupre/fda-food-recalls-scraper/examples/fda-class-i-food-recalls)** — filter high-hazard recalls by classification, status, location, or date.

#### 📦 Returned data

Each dataset item is one official FDA Food Enforcement recall. Available fields include:

- `recallNumber`, `eventId`, `classification`, and `status`
- `productDescription`, `productQuantity`, `productType`, and `codeInfo`
- `reason`, `recallingFirm`, structured `address`, and `distributionPattern`
- `recallInitiationDate`, `reportDate`, `centerClassificationDate`, and `terminationDate`
- `voluntaryMandated` and `initialFirmNotification`
- `changeType` for monitoring output: `new`, `statusChanged`, or `updated`
- `retrievedAt`, a record-verifiable `sourceUrl`, and `fdaEventUrl` when available

Absent source values remain `null`; dates are normalized as `YYYY-MM-DD`.

#### ▶️ Running the Actor

Run the Actor in Apify Console, call it through the Apify API or MCP, or schedule it for recurring monitoring. Choose one Target per run:

- **Recall search** for keywords and structured filters
- **Recall number** or **Event identifier** for exact lookup
- **Complete feed** to retrieve the official feed up to your chosen limit
- **Recall changes** to compare a search with prior successful monitoring history

Results are saved to the default dataset and can be exported in formats including JSON, CSV, and Excel.

#### 🔎 Input

Search and change runs can filter by product or reason keywords, recalling firm, classifications, statuses, states, countries, report dates, and recall-initiation dates. `advancedSearch` accepts an openFDA Food Enforcement expression when structured filters are insufficient. Choose the ordering field and direction with `sort`, and set `maxResults` from 1 to 100,000.

Recall changes require a stable `monitorKey`. Reuse the same key and search configuration on scheduled runs; unchanged recalls are not emitted. Public recall data needs no source key, while `openFdaApiKey` accepts your own optional key for higher openFDA source rate limits.

```json
{
  "target": "search",
  "query": "salmonella",
  "classifications": ["Class I"],
  "states": ["CA"],
  "reportDateFrom": "2025-01-01",
  "sort": "reportDateDesc",
  "maxResults": 100
}
````

#### 📤 Output

A recall item is saved only when openFDA supplies its recall identity and product description. A typical item has this shape:

```json
{
  "recallNumber": "F-1234-2025",
  "eventId": "98765",
  "classification": "Class I",
  "status": "Ongoing",
  "productDescription": "Frozen smoked salmon, 4 oz packages",
  "productQuantity": "1,200 cases",
  "productType": "Food",
  "codeInfo": "Lot 24051; Best By 2025-08-31",
  "reason": "Potential contamination with Salmonella.",
  "recallingFirm": "Example Foods LLC",
  "address": {
    "street": "100 Market Street",
    "city": "Seattle",
    "state": "WA",
    "postalCode": "98101",
    "country": "United States"
  },
  "distributionPattern": "Nationwide",
  "recallInitiationDate": "2025-02-14",
  "reportDate": "2025-02-20",
  "centerClassificationDate": "2025-02-18",
  "terminationDate": null,
  "voluntaryMandated": "Voluntary: Firm initiated",
  "initialFirmNotification": "E-Mail",
  "changeType": null,
  "retrievedAt": "2026-07-18T12:30:00.000Z",
  "sourceUrl": "https://api.fda.gov/food/enforcement.json?search=recall_number%3A%22F-1234-2025%22",
  "fdaEventUrl": "https://www.accessdata.fda.gov/scripts/ires/index.cfm?Event=98765"
}
```

#### 💰 Pricing

This Actor uses pay-per-event pricing. You are charged once for each FDA food recall saved to the default dataset. Empty searches, unchanged monitoring runs, rejected input, and failed retrieval work are not charged as food recalls.

#### 🔌 Integrations

Use Apify schedules for recurring recall checks and webhooks to send completed runs or dataset data to downstream workflows. You can also access results through the Apify API and MCP or connect Apify with other apps:

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

#### ❓ FAQ

##### How do I monitor only new or changed recalls?

Choose the Recall changes Target, set your filters, and assign a stable `monitorKey`. Reuse that key and configuration in scheduled runs. The Actor emits recalls classified as new, status changed, or otherwise updated and does not advance monitoring history after an incomplete retrieval.

##### What happens when no recalls match?

The run completes with an empty dataset. No food-recall event is charged for a no-result search.

##### Do I need an openFDA API key?

No. Official openFDA Food Enforcement data is public. You can supply your own openFDA key when you need the source's higher rate limits.

##### Can I look up a specific FDA recall?

Yes. Use the Recall number Target for an exact recall number or the Event identifier Target for all matching actions under an FDA event ID.

##### Does this include drug or medical-device recalls?

No. This Actor returns food enforcement recalls only; it does not collect drug, medical-device, vehicle, or consumer-product recalls.

##### Is this the same as scraping FDA web pages?

No. The Actor retrieves records from the official openFDA Food Enforcement API and provides record-verifiable source URLs. It does not scrape FDA HTML pages.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~fda-food-recalls-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Disease Outbreak News Scraper](https://apify.com/maximedupre/disease-outbreak-news-scraper) — collect official WHO, ECDC, CDC, PAHO, and CAHEC outbreak alerts for adjacent public-health monitoring.
- [US Travel Advisories](https://apify.com/maximedupre/us-travel-advisories-scraper) — collect State Department advisories and CDC travel health notices for destination-risk monitoring.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `target` (type: `string`):

Choose the FDA Food Enforcement records this run should return. Options in sections for other Targets are ignored.

## `query` (type: `string`):

Find recalls whose product description or recall reason contains these words.

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

Return the enforcement action with this exact FDA recall number, for example F-1234-2025.

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

Return recalls belonging to this exact FDA event identifier, for example 98765.

## `monitorKey` (type: `string`):

Stable name for this change feed's history. Reuse it in scheduled runs to emit only new or changed recalls; use a different key for each independently monitored search.

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

Keep records for this recalling firm.

## `classifications` (type: `array`):

Keep recalls in one or more FDA health-hazard classes.

## `statuses` (type: `array`):

Keep recalls in one or more FDA recall statuses.

## `states` (type: `array`):

Keep recalls whose recalling-firm address matches any listed US state or territory abbreviation, for example CA or PR.

## `countries` (type: `array`):

Keep recalls whose recalling-firm address matches any listed country name, for example United States or Canada.

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

Keep recalls reported on or after this calendar date (YYYY-MM-DD).

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

Keep recalls reported on or before this calendar date (YYYY-MM-DD).

## `initiationDateFrom` (type: `string`):

Keep recalls initiated on or after this calendar date (YYYY-MM-DD).

## `initiationDateTo` (type: `string`):

Keep recalls initiated on or before this calendar date (YYYY-MM-DD).

## `advancedSearch` (type: `string`):

Add an openFDA Food Enforcement search expression when the structured filters are insufficient, for example `distribution_pattern:"Nationwide"`. It is combined with the fields above.

## `sort` (type: `string`):

Choose the source date and direction used to order records. Recall changes are classified before this display order is applied.

## `maxResults` (type: `integer`):

Maximum number of matching records to save for search, complete-feed, or changes runs. Increase it for larger exports, up to 100,000.

## `openFdaApiKey` (type: `string`):

Optional customer-supplied openFDA key for higher source rate limits. Public recall data does not require a key.

## Actor input object example

```json
{
  "target": "search",
  "query": "salmonella",
  "recallNumber": "F-1234-2025",
  "eventId": "98765",
  "monitorKey": "weekly-allergen-watch",
  "states": [
    "CA",
    "PR"
  ],
  "countries": [
    "United States",
    "Canada"
  ],
  "reportDateFrom": "2025-01-01",
  "reportDateTo": "2025-12-31",
  "initiationDateFrom": "2025-01-01",
  "initiationDateTo": "2025-12-31",
  "advancedSearch": "distribution_pattern:\"Nationwide\"",
  "sort": "reportDateDesc",
  "maxResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Official FDA food recall records with product, enforcement, location, date, monitoring-change, and provenance details.

# 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 = {
    "target": "search",
    "query": "salmonella",
    "sort": "reportDateDesc",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/fda-food-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 = {
    "target": "search",
    "query": "salmonella",
    "sort": "reportDateDesc",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/fda-food-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 '{
  "target": "search",
  "query": "salmonella",
  "sort": "reportDateDesc",
  "maxResults": 100
}' |
apify call maximedupre/fda-food-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Food Recall Monitor",
        "description": "Search, export, and monitor official openFDA Food Enforcement recalls. Filter by product, firm, class, status, location, or date, and track new or updated recalls.",
        "version": "0.0",
        "x-build-id": "6Cp4U7xlKR2zVpBV0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~fda-food-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-fda-food-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/maximedupre~fda-food-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-fda-food-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/maximedupre~fda-food-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-fda-food-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",
                "required": [
                    "target"
                ],
                "properties": {
                    "target": {
                        "title": "Target",
                        "enum": [
                            "search",
                            "recallNumber",
                            "eventId",
                            "completeFeed",
                            "changes"
                        ],
                        "type": "string",
                        "description": "Choose the FDA Food Enforcement records this run should return. Options in sections for other Targets are ignored."
                    },
                    "query": {
                        "title": "Product or reason keywords",
                        "type": "string",
                        "description": "Find recalls whose product description or recall reason contains these words."
                    },
                    "recallNumber": {
                        "title": "FDA recall number",
                        "minLength": 1,
                        "type": "string",
                        "description": "Return the enforcement action with this exact FDA recall number, for example F-1234-2025."
                    },
                    "eventId": {
                        "title": "FDA event identifier",
                        "pattern": "^[0-9]+$",
                        "type": "string",
                        "description": "Return recalls belonging to this exact FDA event identifier, for example 98765."
                    },
                    "monitorKey": {
                        "title": "Monitoring key",
                        "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$",
                        "type": "string",
                        "description": "Stable name for this change feed's history. Reuse it in scheduled runs to emit only new or changed recalls; use a different key for each independently monitored search."
                    },
                    "recallingFirm": {
                        "title": "Recalling firm",
                        "type": "string",
                        "description": "Keep records for this recalling firm."
                    },
                    "classifications": {
                        "title": "Classifications",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep recalls in one or more FDA health-hazard classes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Class I",
                                "Class II",
                                "Class III"
                            ],
                            "enumTitles": [
                                "Class I",
                                "Class II",
                                "Class III"
                            ]
                        }
                    },
                    "statuses": {
                        "title": "Statuses",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep recalls in one or more FDA recall statuses.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Ongoing",
                                "Completed",
                                "Terminated",
                                "Pending"
                            ],
                            "enumTitles": [
                                "Ongoing",
                                "Completed",
                                "Terminated",
                                "Pending"
                            ]
                        }
                    },
                    "states": {
                        "title": "States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep recalls whose recalling-firm address matches any listed US state or territory abbreviation, for example CA or PR.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep recalls whose recalling-firm address matches any listed country name, for example United States or Canada.",
                        "items": {
                            "type": "string",
                            "minLength": 2
                        }
                    },
                    "reportDateFrom": {
                        "title": "Reported from",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "Keep recalls reported on or after this calendar date (YYYY-MM-DD)."
                    },
                    "reportDateTo": {
                        "title": "Reported through",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "Keep recalls reported on or before this calendar date (YYYY-MM-DD)."
                    },
                    "initiationDateFrom": {
                        "title": "Initiated from",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "Keep recalls initiated on or after this calendar date (YYYY-MM-DD)."
                    },
                    "initiationDateTo": {
                        "title": "Initiated through",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "Keep recalls initiated on or before this calendar date (YYYY-MM-DD)."
                    },
                    "advancedSearch": {
                        "title": "Advanced openFDA expression",
                        "type": "string",
                        "description": "Add an openFDA Food Enforcement search expression when the structured filters are insufficient, for example `distribution_pattern:\"Nationwide\"`. It is combined with the fields above."
                    },
                    "sort": {
                        "title": "Order",
                        "enum": [
                            "reportDateDesc",
                            "reportDateAsc",
                            "initiationDateDesc",
                            "initiationDateAsc",
                            "classificationDateDesc",
                            "classificationDateAsc"
                        ],
                        "type": "string",
                        "description": "Choose the source date and direction used to order records. Recall changes are classified before this display order is applied."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of matching records to save for search, complete-feed, or changes runs. Increase it for larger exports, up to 100,000."
                    },
                    "openFdaApiKey": {
                        "title": "openFDA API key",
                        "type": "string",
                        "description": "Optional customer-supplied openFDA key for higher source rate limits. Public recall data does not require a key."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
