# US Recall API | FDA, CPSC & USDA FSIS (`tictechid/vanzi-us-recall-intelligence`) Actor

Search US product recalls from FDA, CPSC, and USDA FSIS in one run. Filter by brand, category, or date and export normalized recall data with severity scoring.

- **URL**: https://apify.com/tictechid/vanzi-us-recall-intelligence.md
- **Developed by:** [TicTech](https://apify.com/tictechid) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## US Recall API | FDA, CPSC & USDA FSIS

Search US product recalls from **FDA**, **CPSC**, and **USDA FSIS** in one run. Filter by brand, category, date, or agency and export normalized recall data with severity scoring.

### Why use this Actor?

US recall data is spread across three federal agencies. Checking each site separately is slow, inconsistent, and easy to miss. This Actor pulls from official government APIs, normalizes every record into one schema, and lets you schedule searches on Apify — so you can monitor recalls, feed dashboards, or screen product catalogs without building three integrations yourself.

**Built on official APIs, not page scraping** — reliable FDA (openFDA), CPSC (SaferProducts), and USDA FSIS data in one place.

### Who is it for?

- **Compliance & quality teams** monitoring recalls across product lines
- **Brand managers** tracking recalls affecting their company or competitors
- **E-commerce & retail** screening catalog risk by brand or category
- **Supply chain analysts** reviewing recall trends by date or product type
- **Developers** building recall alerts, dashboards, or internal tools via the Apify API

### Use cases

- Brand recall lookup — find all recalls linked to a manufacturer or brand name
- Category monitoring — track supplement, food, toy, or electronics recalls over time
- Date-based searches — pull recalls published in a specific period
- Agency-specific exports — query FDA, CPSC, or USDA only
- Scheduled monitoring — run daily or weekly and pipe results to Slack, email, or a database
- Compliance screening — export structured recall data for internal review

### What you get

- Official government APIs (openFDA, SaferProducts, FSIS)
- One unified dataset schema across all agencies
- Smart routing by product type (supplements → FDA, meat → USDA, toys → CPSC, etc.)
- Severity scoring (`high`, `medium`, `low`) on every record
- Optional **overall analytics** summarizing the recalls returned by your search

### Input

| Field | Description |
| --- | --- |
| `brandName` | Brand, manufacturer, or company |
| `productType` | e.g. supplements, food, toys, meat |
| `dateFrom` / `dateTo` | Date range (`YYYY-MM-DD`) |
| `source` | `all`, `fda`, `cpsc`, or `usda` |
| `maxResults` | 1–1000 (default 100) |
| `includeAnalytics` | Overall result analytics (see [Analytics](#analytics)) |
| `keepStandbyAlive` | Keep HTTP API running after the run (see [Standby mode](#standby-mode)) |

At least one search field is required unless `keepStandbyAlive` is enabled.

#### Default input

The Actor starts with empty optional filters, the first three months of 2026, and all agencies:

```json
{
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "source": "all",
  "maxResults": 100,
  "includeAnalytics": false
}
````

#### Example input with filters

```json
{
  "brandName": "Example Brand Co.",
  "productType": "supplements",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "source": "all",
  "maxResults": 10,
  "includeAnalytics": true
}
```

#### Example output (dataset row)

Each recall is saved as one row in the dataset:

```json
{
  "source": "FDA",
  "date": "2026-02-15",
  "brand": "Example Brand Co.",
  "company": "Example Manufacturer LLC",
  "product": "Example Dietary Supplement Capsules",
  "category": "Food",
  "reason": "Undeclared allergen (example)",
  "severity": "medium",
  "url": "https://www.fda.gov/safety/recalls-market-withdrawals-safety-alerts?search_api_fulltext=EXAMPLE-0001-2026",
  "recall_id": "EXAMPLE-0001-2026",
  "classification": "Class II",
  "status": "Ongoing"
}
```

### Analytics

Set `includeAnalytics: true` to get an **overall summary of the recalls returned by your search** — not a separate API call, and not analytics across all US recalls. Every metric is computed from the matched result set (up to `maxResults`).

This is useful when you want a quick risk snapshot without exporting and pivoting the full dataset yourself: how many recalls matched, how severe they are, which agencies reported them, what hazards dominate, and which brands or companies appear most often.

#### Where to find analytics

| Location | What you get |
| --- | --- |
| **Recall records** (dataset) | One row per matched recall |
| **Analytics summary** (separate dataset) | One summary row when `includeAnalytics` is enabled |
| **OUTPUT** key-value record | Full `analytics` object plus all recall items (best for API integrations) |

#### What is analyzed

Analytics always reflect **your search results**:

- If you filter by `brandName` or `productType`, scope labels use those values.
- If you search by date range or agency only, scope labels use **"All matched recalls"** and rankings (top brands, companies, categories) are derived from the returned rows.

#### Analytics fields

| Section | Field | Description |
| --- | --- | --- |
| **scope** | `brandScope` | Brand filter used, or `All matched recalls` |
| | `productScope` | Product-type filter used, or `All matched recalls` |
| | `resultsAnalyzed` | Number of recall rows included in the summary |
| | `description` | Notes that stats are based on matched results only |
| **brandSummary** | `totalRecalls` | Total recalls in the result set |
| | `highSeverityRecalls` | Count with normalized severity `high` |
| | `mediumSeverityRecalls` | Count with severity `medium` |
| | `lowSeverityRecalls` | Count with severity `low` |
| | `unknownSeverityRecalls` | Count where severity could not be determined |
| | `earliestRecall` | Oldest recall date in the results |
| | `latestRecall` | Most recent recall date in the results |
| **categoryStatistics** | `topReasons` | Top 3 recall reasons/hazards in the results |
| | `topCategories` | Top product categories with counts, e.g. `[{ "name": "Food", "count": 8 }]` |
| **severityBreakdown** | `high` / `medium` / `low` / `unknown` | Full severity distribution |
| **sourceBreakdown** | `FDA` / `CPSC` / `USDA` | How many recalls came from each agency |
| **timeline** | `earliestRecall` / `latestRecall` | Date span of the matched recalls |
| | `recallDateSpanDays` | Days between earliest and latest recall |
| **topBrands** | `[{ name, count }]` | Most frequent brands in the results (up to 5) |
| **topCompanies** | `[{ name, count }]` | Most frequent recalling firms (up to 5) |

#### Example analytics output

Date-range search with no brand or product filter:

```json
{
  "items": [ "...recall rows..." ],
  "analytics": {
    "scope": {
      "brandScope": "All matched recalls",
      "productScope": "All matched recalls",
      "resultsAnalyzed": 10,
      "description": "Overall statistics computed from the recall rows returned by this search. Counts reflect matched results only, capped by maxResults."
    },
    "brandSummary": {
      "brand": "All matched recalls",
      "totalRecalls": 10,
      "highSeverityRecalls": 6,
      "mediumSeverityRecalls": 3,
      "lowSeverityRecalls": 1,
      "unknownSeverityRecalls": 0,
      "earliestRecall": "2026-01-10",
      "latestRecall": "2026-03-28"
    },
    "categoryStatistics": {
      "productType": "All matched recalls",
      "totalRecalls": 10,
      "topReasons": [
        "undeclared allergen (example)",
        "potential contamination (example)",
        "mislabeling (example)"
      ],
      "topCategories": [
        { "name": "Food", "count": 7 },
        { "name": "Meat, Poultry, and Egg Products", "count": 3 }
      ]
    },
    "severityBreakdown": { "high": 6, "medium": 3, "low": 1 },
    "sourceBreakdown": { "FDA": 7, "USDA": 3 },
    "timeline": {
      "earliestRecall": "2026-01-10",
      "latestRecall": "2026-03-28",
      "recallDateSpanDays": 77
    },
    "topBrands": [
      { "name": "Brand A", "count": 2 },
      { "name": "Brand B", "count": 1 }
    ],
    "topCompanies": [
      { "name": "Company A", "count": 3 },
      { "name": "Company B", "count": 2 }
    ]
  },
  "meta": {
    "count": 10,
    "sourcesQueried": ["fda", "cpsc", "usda"],
    "queriedAt": "2026-06-16T12:00:00Z"
  },
  "errors": []
}
```

#### Practical uses

- **Compliance triage** — see at a glance how many high-severity recalls matched and what hazards dominate (`topReasons`, `severityBreakdown`).
- **Supplier screening** — search a date window and check whether a company or brand appears in `topCompanies` / `topBrands`.
- **Agency coverage** — use `sourceBreakdown` to see whether FDA, CPSC, or USDA drove the results.
- **Monitoring dashboards** — schedule runs and read the analytics dataset or `OUTPUT.analytics` without re-aggregating recall rows.
- **Trend snapshots** — `timeline` shows how spread out recall dates are within your filtered window.

### Output fields

| Field | Description |
| --- | --- |
| `source` | Agency: FDA, CPSC, or USDA |
| `date` | Recall date |
| `severity` | Normalized risk: high, medium, low, or unknown |
| `brand` | Brand name when available |
| `company` | Manufacturer or recalling firm |
| `product` | Product name or description |
| `category` | Product category or type |
| `reason` | Recall reason or hazard summary |
| `url` | Link to the official notice |
| `recall_id` | Agency recall identifier |
| `classification` | Official class (e.g. Class I, High - Class I) |
| `status` | Recall status when reported by the source |

### Free vs paid

**Free Apify users** get **5 trial runs**. After that, upgrade to continue:

**[Upgrade to a paid plan](https://apify.com/pricing?fpr=maxknj)**

Paid users get unlimited runs.

| Event | When charged |
| --- | --- |
| `include-analytics` | A successful search produces analytics output (`includeAnalytics: true`) |

Configure event prices in the Actor **Monetization** settings on Apify Console.

### Standby mode

This Actor supports [Apify standby mode](https://docs.apify.com/platform/actors/development/programming-interface/standby): a long-running HTTP server you can call while the Actor stays alive.

#### One-shot run (default)

Leave `keepStandbyAlive` **false**. The Actor runs your search once, writes results to the dataset and `OUTPUT`, then exits. Best for scheduled jobs, webhooks, and API integrations that start a run and read the output when it finishes.

#### Standby API run

Set `keepStandbyAlive` **true** to keep the recall API listening after startup. You can optionally include search fields in the input to run an initial search before the server starts.

| Endpoint | Method | Description |
| --- | --- | --- |
| `/health` | GET | Service status and available routes |
| `/recalls` | GET | Search via query parameters (`brandName`, `productType`, `dateFrom`, …) |
| `/recalls` | POST | Search via JSON body (same fields as Actor input) |

After deploy, open the Actor’s **Standby** tab in Apify Console to browse the OpenAPI spec and send test requests without configuring API tokens.

#### Advantages

- **Interactive testing** — try searches from the Console Standby tab with Swagger UI
- **Low latency** — no cold start per request; the server is already running
- **Multiple searches per run** — call `/recalls` repeatedly without starting a new Actor run
- **Simple HTTP integration** — GET or POST JSON from your app while the standby instance is up

#### Disadvantages

- **Higher cost** — the Actor keeps consuming compute until you stop the run; standby is more expensive than short one-shot runs
- **Not for cron-style monitoring** — scheduled daily checks should use one-shot runs, not a permanently warm server
- **Single instance** — one standby run serves one URL; scale-out requires multiple runs
- **Free tier** — each Actor start (including standby) counts toward the 5 free trial runs; HTTP calls inside a standby run do not consume additional free runs

#### Example standby input

```json
{
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "source": "all",
  "keepStandbyAlive": true
}
```

Example HTTP request after the server is up:

```http
GET /recalls?dateFrom=2026-01-01&dateTo=2026-03-31&source=all&maxResults=10
```

### Output

After each run, results appear in the Apify Console **Output** tab:

| Output | Description |
| --- | --- |
| **Recall records** | Default dataset — recall rows only |
| **Analytics summary** | Separate analytics dataset when `includeAnalytics` is enabled |
| **Run summary (JSON)** | Full response under `OUTPUT` — items, analytics, meta, and errors |

Export the dataset as JSON, CSV, Excel, or HTML from the run page.

### Data sources

- [FDA openFDA](https://open.fda.gov/apis/food/enforcement/)
- [CPSC Recall API](https://www.cpsc.gov/Recalls/CPSC-Recalls-Application-Program-Interface-API-Information)
- [USDA FSIS Recall API](https://www.fsis.usda.gov/science-data/developer-resources/recall-api)

### Support & feedback

Found a bug, need a feature, or have a question?

- Open an issue on the **Issues** tab in Apify Console for this Actor
- Email the developer at **<contact@tictech.id>**

We welcome reports on missing recalls, API changes, or requests for new filters and export formats.

# Actor input Schema

## `brandName` (type: `string`):

Search recalls by brand, manufacturer, or company name.

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

Search by product category such as supplements, food, toys, electronics, meat, or medical devices.

## `dateFrom` (type: `string`):

Start date for recall search (YYYY-MM-DD).

## `dateTo` (type: `string`):

End date for recall search (YYYY-MM-DD).

## `source` (type: `string`):

Limit search to a specific agency or query all supported agencies.

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

Maximum number of normalized recall records to return.

## `includeAnalytics` (type: `boolean`):

Add an overall analytics summary to the analytics dataset and OUTPUT.

## `keepStandbyAlive` (type: `boolean`):

Keep the HTTP recall API running after the input search completes. Use for interactive API access via the Standby tab. Leave disabled for one-shot scheduled runs.

## Actor input object example

```json
{
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "source": "all",
  "maxResults": 100,
  "includeAnalytics": false,
  "keepStandbyAlive": false
}
```

# Actor output Schema

## `recalls` (type: `string`):

Normalized recall rows from FDA, CPSC, and USDA FSIS.

## `analytics` (type: `string`):

Overall statistics for the matched recalls when includeAnalytics is enabled.

## `runSummary` (type: `string`):

Full API response saved under the OUTPUT key, including items, optional analytics, query metadata, and per-source errors.

# 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 = {
    "brandName": "",
    "productType": "",
    "dateFrom": "2026-01-01",
    "dateTo": "2026-03-31",
    "source": "all",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("tictechid/vanzi-us-recall-intelligence").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 = {
    "brandName": "",
    "productType": "",
    "dateFrom": "2026-01-01",
    "dateTo": "2026-03-31",
    "source": "all",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("tictechid/vanzi-us-recall-intelligence").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 '{
  "brandName": "",
  "productType": "",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "source": "all",
  "maxResults": 100
}' |
apify call tictechid/vanzi-us-recall-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tictechid/vanzi-us-recall-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Recall API | FDA, CPSC & USDA FSIS",
        "description": "Search US product recalls from FDA, CPSC, and USDA FSIS in one run. Filter by brand, category, or date and export normalized recall data with severity scoring.",
        "version": "1.0",
        "x-build-id": "8curj3oUKefulPO7L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tictechid~vanzi-us-recall-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tictechid-vanzi-us-recall-intelligence",
                "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/tictechid~vanzi-us-recall-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-tictechid-vanzi-us-recall-intelligence",
                "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/tictechid~vanzi-us-recall-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-tictechid-vanzi-us-recall-intelligence",
                "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": {
                    "brandName": {
                        "title": "Brand name",
                        "type": "string",
                        "description": "Search recalls by brand, manufacturer, or company name."
                    },
                    "productType": {
                        "title": "Product type",
                        "type": "string",
                        "description": "Search by product category such as supplements, food, toys, electronics, meat, or medical devices."
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Start date for recall search (YYYY-MM-DD)."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "End date for recall search (YYYY-MM-DD)."
                    },
                    "source": {
                        "title": "Source",
                        "enum": [
                            "all",
                            "fda",
                            "cpsc",
                            "usda"
                        ],
                        "type": "string",
                        "description": "Limit search to a specific agency or query all supported agencies.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of normalized recall records to return.",
                        "default": 100
                    },
                    "includeAnalytics": {
                        "title": "Include analytics",
                        "type": "boolean",
                        "description": "Add an overall analytics summary to the analytics dataset and OUTPUT.",
                        "default": false
                    },
                    "keepStandbyAlive": {
                        "title": "Keep standby server alive",
                        "type": "boolean",
                        "description": "Keep the HTTP recall API running after the input search completes. Use for interactive API access via the Standby tab. Leave disabled for one-shot scheduled runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
