# FDA Food Recalls Scraper (`automation-lab/fda-food-recalls-scraper`) Actor

🥫 Monitor and export FDA/OpenFDA food recall records by product, firm, risk class, status, geography, and dates.

- **URL**: https://apify.com/automation-lab/fda-food-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

from $0.01 / 1,000 recall record saveds

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 Food Recalls Scraper

Export FDA/OpenFDA food recall and enforcement records for compliance monitoring, supplier risk checks, and food safety reporting.

The actor uses the official OpenFDA food enforcement API, not fragile FDA HTML pages. It returns normalized recall records with classification, status, recalling firm, product description, reason, distribution pattern, dates, geography, code information, and source links.

### What does FDA Food Recalls Scraper do?

FDA Food Recalls Scraper collects food recall and enforcement records from the public OpenFDA food enforcement endpoint.

Use it to:

- 🥫 Monitor new FDA food recalls by report date
- 🧾 Export recall evidence for compliance files
- 🏭 Track recalls for a specific recalling firm
- ⚠️ Filter Class I and Class II recalls for risk workflows
- 🌎 Watch recalls by state or country
- 🔎 Search product descriptions and recall reasons by keyword
- 📊 Feed recall data into BI dashboards, data warehouses, or alerts

### Who is it for?

This actor is built for teams that need repeatable recall monitoring instead of manual FDA searches.

Typical users include:

- Food manufacturers watching related products and ingredients
- Importers and distributors checking supplier risk
- Grocers and restaurant groups monitoring products in their supply chain
- Compliance consultants preparing recall reports
- Food safety teams tracking Class I and Class II events
- Data teams building automated recall dashboards
- Legal and insurance teams collecting recall evidence

### Why use this actor?

Manual recall monitoring is easy to miss and hard to export consistently. This actor gives you a scheduled, API-friendly workflow with structured outputs.

Benefits:

- ✅ Official OpenFDA source
- ✅ No login required
- ✅ Scheduled monitoring on Apify
- ✅ Clean dataset exports
- ✅ Stable field names for integrations
- ✅ Source API URL on every row
- ✅ FDA iRES record URL when an event ID is available

### Data source

The actor queries:

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

OpenFDA food enforcement data includes recall and enforcement report records published by the FDA. Availability and updates depend on the FDA/OpenFDA source.

### Input overview

You can run a broad recall feed or narrow the feed with structured filters.

Main filters:

- `productKeywords` searches product descriptions and recall reasons
- `recallingFirm` filters by recalling firm name
- `classifications` filters risk class values
- `statuses` filters recall status values
- `states` and `countries` filter recalling-firm geography
- `reportDateFrom` and `reportDateTo` filter FDA report dates
- `initiationDateFrom` and `initiationDateTo` filter recall initiation dates
- `query` accepts an advanced raw OpenFDA search expression
- `maxItems` limits the number of records saved

### Example input

```json
{
  "productKeywords": ["allergen"],
  "classifications": ["Class I", "Class II"],
  "statuses": ["Ongoing"],
  "reportDateFrom": "2024-01-01",
  "maxItems": 100,
  "sortBy": "report_date",
  "sortDirection": "desc"
}
````

### Advanced query input

Use `query` if you already know OpenFDA search syntax.

Example:

```json
{
  "query": "classification:\"Class I\" AND status:\"Ongoing\"",
  "maxItems": 250
}
```

Structured fields are easier for most users. Advanced query is there for teams that need exact OpenFDA expressions.

### Output data

Each dataset item is one FDA food recall/enforcement record.

| Field | Description |
| --- | --- |
| `recallNumber` | FDA recall number |
| `eventId` | FDA event ID |
| `classification` | FDA recall classification |
| `status` | Recall status |
| `productType` | Product type |
| `recallingFirm` | Firm responsible for the recall |
| `productDescription` | Product description |
| `reasonForRecall` | FDA reason for recall |
| `distributionPattern` | Distribution details |
| `recallInitiationDate` | Recall initiation date |
| `reportDate` | FDA report date |
| `centerClassificationDate` | FDA center classification date |
| `terminationDate` | Termination date when available |
| `voluntaryMandated` | Voluntary or mandated recall indicator |
| `initialFirmNotification` | Initial firm notification method |
| `productQuantity` | Product quantity |
| `codeInfo` | Code information |
| `moreCodeInfo` | Additional code information |
| `city` | Firm city |
| `state` | Firm state |
| `country` | Firm country |
| `postalCode` | Firm postal code |
| `address` | Combined address |
| `sourceApiUrl` | Exact OpenFDA API URL used for the page |
| `sourceRecordUrl` | FDA iRES event link when possible |
| `scrapedAt` | Actor extraction timestamp |

### Example output

```json
{
  "recallNumber": "F-1234-2026",
  "eventId": "98765",
  "classification": "Class I",
  "status": "Ongoing",
  "recallingFirm": "Example Foods Inc.",
  "productDescription": "Example product description",
  "reasonForRecall": "Undeclared allergen",
  "reportDate": "2026-06-10",
  "state": "CA",
  "country": "United States",
  "sourceRecordUrl": "https://www.accessdata.fda.gov/scripts/ires/?Event=98765",
  "scrapedAt": "2026-06-21T00:00:00.000Z"
}
```

### How much does it cost to scrape FDA food recalls?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each recall record saved.
- You control spend with `maxItems` and filters.

Use a small `maxItems` value for the first test run. Increase it for scheduled monitoring or historical exports.

### How to run

1. Open the actor on Apify.
2. Choose product keywords, date range, and recall classifications.
3. Set `maxItems` to the number of records you need.
4. Run the actor.
5. Export results as JSON, CSV, Excel, XML, or RSS.

### Monitoring workflow

For recall monitoring, schedule the actor daily or weekly.

Recommended monitoring setup:

- Set `reportDateFrom` to a recent date
- Filter `statuses` to `Ongoing`
- Filter `classifications` to `Class I` and `Class II`
- Use a moderate `maxItems`, such as 100 or 500
- Connect the dataset to a webhook, Slack alert, data warehouse, or dashboard

### Supplier risk workflow

For supplier checks, use `recallingFirm` with date filters.

Example use cases:

- Check a supplier before onboarding
- Monitor a high-risk vendor
- Review recent recalls during audits
- Export firm-specific recall history for compliance files

### Product keyword workflow

Use `productKeywords` for ingredients, product categories, contaminants, or allergens.

Examples:

- `peanut butter`
- `milk`
- `salmonella`
- `listeria`
- `undeclared allergen`
- `foreign material`

### Tips for better results

- Use exact FDA terms when possible.
- Start broad, then narrow with classification and date filters.
- Use `reportDateFrom` for recurring monitoring.
- Use `recallInitiationDateFrom` for operational recall timelines.
- Use the advanced `query` field only if you know OpenFDA syntax.
- Keep `maxItems` low during testing.

### Integrations

You can integrate this actor with:

- Google Sheets for recall watchlists
- Airtable for compliance tracking
- Snowflake or BigQuery for analytics
- Slack or email alerts through Apify webhooks
- CRM or supplier-risk platforms
- Internal food safety dashboards
- MCP-compatible AI workflows

### 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-food-recalls-scraper').call({
  productKeywords: ['allergen'],
  classifications: ['Class I', 'Class II'],
  statuses: ['Ongoing'],
  reportDateFrom: '2024-01-01',
  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/fda-food-recalls-scraper').call(run_input={
    'productKeywords': ['allergen'],
    'classifications': ['Class I', 'Class II'],
    'statuses': ['Ongoing'],
    'reportDateFrom': '2024-01-01',
    '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~fda-food-recalls-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"productKeywords":["allergen"],"classifications":["Class I","Class II"],"statuses":["Ongoing"],"reportDateFrom":"2024-01-01","maxItems":100}'
```

### MCP usage

Use this actor from MCP-enabled tools through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/fda-food-recalls-scraper`

Add it to Claude Code:

```bash
claude mcp add apify-fda-food-recalls https://mcp.apify.com/?tools=automation-lab/fda-food-recalls-scraper
```

Example MCP server configuration:

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

Example prompts:

- "Find the latest ongoing Class I food recalls involving allergens."
- "Export FDA food recall records for this supplier since 2024."
- "Summarize recent FDA food recalls by state and classification."

### Legality and responsible use

This actor uses publicly available OpenFDA data. You are responsible for how you use the exported records and for complying with your organization's regulatory, legal, and data-retention requirements.

OpenFDA data can change over time. Always verify high-impact compliance decisions against the original FDA record.

### FAQ

#### Why did I get zero results?

Your filters may be too narrow. Try removing `recallingFirm`, widening the date range, or using fewer keywords.

#### Why does the actor use the OpenFDA API instead of FDA web pages?

The official API is more stable, structured, and automation-friendly. FDA HTML pages may be protected or change without notice.

#### Why are some fields empty?

OpenFDA records do not always contain every field. The actor keeps optional fields as `null` when the source does not provide them.

### Related scrapers

Related Apify actors from Automation Lab may include public-data, compliance, and regulator monitoring actors as the portfolio grows:

- https://apify.com/automation-lab/company-domain-finder
- https://apify.com/automation-lab/accessibility-checker
- https://apify.com/automation-lab/website-contact-finder

### Changelog

- `0.1` — Initial FDA/OpenFDA food recalls actor with structured filters and normalized recall output.

### Support

If you need a new filter, field, or integration pattern, open an issue through the Apify actor page.

### Summary

FDA Food Recalls Scraper turns public OpenFDA food enforcement data into a repeatable monitoring and export workflow for food safety, compliance, and supply-chain risk teams.

# Actor input Schema

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

Optional raw OpenFDA search expression, for example classification:"Class I" AND status:"Ongoing". Use this only when the structured fields are not enough.

## `productKeywords` (type: `array`):

Keywords to search in product descriptions and recall reasons, such as peanut butter, salmonella, allergen, or milk.

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

Optional exact or phrase match for the recalling firm name.

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

FDA recall risk classifications to include.

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

Recall statuses to include, for example Ongoing or Completed.

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

Optional recalling-firm states, using FDA two-letter state values such as CA, NY, or TX.

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

Optional recalling-firm countries. Use United States for US records.

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

Earliest FDA report date to include. Use YYYY-MM-DD.

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

Latest FDA report date to include. Leave empty for no upper bound.

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

Earliest recall initiation date to include. Use YYYY-MM-DD.

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

Latest recall initiation date to include. Use YYYY-MM-DD.

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

Maximum number of FDA food recall records to save to the dataset.

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

FDA date field used to sort API results.

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

Newest first is recommended for monitoring workflows.

## Actor input object example

```json
{
  "productKeywords": [
    "allergen"
  ],
  "classifications": [
    "Class I",
    "Class II"
  ],
  "statuses": [
    "Ongoing"
  ],
  "states": [],
  "countries": [],
  "reportDateFrom": "2024-01-01",
  "maxItems": 20,
  "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 = {
    "query": "",
    "productKeywords": [
        "allergen"
    ],
    "recallingFirm": "",
    "classifications": [
        "Class I",
        "Class II"
    ],
    "statuses": [
        "Ongoing"
    ],
    "states": [],
    "countries": [],
    "reportDateFrom": "2024-01-01",
    "reportDateTo": "",
    "initiationDateFrom": "",
    "initiationDateTo": "",
    "maxItems": 20,
    "sortBy": "report_date",
    "sortDirection": "desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "query": "",
    "productKeywords": ["allergen"],
    "recallingFirm": "",
    "classifications": [
        "Class I",
        "Class II",
    ],
    "statuses": ["Ongoing"],
    "states": [],
    "countries": [],
    "reportDateFrom": "2024-01-01",
    "reportDateTo": "",
    "initiationDateFrom": "",
    "initiationDateTo": "",
    "maxItems": 20,
    "sortBy": "report_date",
    "sortDirection": "desc",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "query": "",
  "productKeywords": [
    "allergen"
  ],
  "recallingFirm": "",
  "classifications": [
    "Class I",
    "Class II"
  ],
  "statuses": [
    "Ongoing"
  ],
  "states": [],
  "countries": [],
  "reportDateFrom": "2024-01-01",
  "reportDateTo": "",
  "initiationDateFrom": "",
  "initiationDateTo": "",
  "maxItems": 20,
  "sortBy": "report_date",
  "sortDirection": "desc"
}' |
apify call automation-lab/fda-food-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Food Recalls Scraper",
        "description": "🥫 Monitor and export FDA/OpenFDA food recall records by product, firm, risk class, status, geography, and dates.",
        "version": "0.1",
        "x-build-id": "n7nB5c38tNbJfPey7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fda-food-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~fda-food-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~fda-food-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "properties": {
                    "query": {
                        "title": "OpenFDA search query",
                        "type": "string",
                        "description": "Optional raw OpenFDA search expression, for example classification:\"Class I\" AND status:\"Ongoing\". Use this only when the structured fields are not enough."
                    },
                    "productKeywords": {
                        "title": "Product or reason keywords",
                        "type": "array",
                        "description": "Keywords to search in product descriptions and recall reasons, such as peanut butter, salmonella, allergen, or milk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recallingFirm": {
                        "title": "Recalling firm",
                        "type": "string",
                        "description": "Optional exact or phrase match for the recalling firm name."
                    },
                    "classifications": {
                        "title": "Recall classifications",
                        "type": "array",
                        "description": "FDA recall risk classifications to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Recall status",
                        "type": "array",
                        "description": "Recall statuses to include, for example Ongoing or Completed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "US states",
                        "type": "array",
                        "description": "Optional recalling-firm states, using FDA two-letter state values such as CA, NY, or TX.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional recalling-firm countries. Use United States for US records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reportDateFrom": {
                        "title": "Report date from",
                        "type": "string",
                        "description": "Earliest FDA report date to include. Use YYYY-MM-DD."
                    },
                    "reportDateTo": {
                        "title": "Report date to",
                        "type": "string",
                        "description": "Latest FDA report date to include. Leave empty for no upper bound."
                    },
                    "initiationDateFrom": {
                        "title": "Recall initiation date from",
                        "type": "string",
                        "description": "Earliest recall initiation date to include. Use YYYY-MM-DD."
                    },
                    "initiationDateTo": {
                        "title": "Recall initiation date to",
                        "type": "string",
                        "description": "Latest recall initiation date to include. Use YYYY-MM-DD."
                    },
                    "maxItems": {
                        "title": "Maximum recall records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of FDA food recall records to save to the dataset.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort field",
                        "enum": [
                            "report_date",
                            "recall_initiation_date",
                            "center_classification_date"
                        ],
                        "type": "string",
                        "description": "FDA date field used to sort API results.",
                        "default": "report_date"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Newest first is recommended for monitoring workflows.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```