# US Recall Radar — CPSC, FDA & NHTSA Recall Feed (`bikram07/recall-radar`) Actor

One unified, deduplicated feed of US product recalls from CPSC, FDA (food/drug/device) and NHTSA. Filter by agency, keyword, date window, or vehicle. Official government APIs, normalized into a clean schema. Zero-config: returns the last 30 days of CPSC + FDA recalls.

- **URL**: https://apify.com/bikram07/recall-radar.md
- **Developed by:** [Bikram](https://apify.com/bikram07) (community)
- **Categories:** News, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Radar — CPSC, FDA & NHTSA Recall Feed

One unified, deduplicated feed of **United States product recalls** pulled directly from three official government APIs — the **CPSC** (Consumer Product Safety Commission), the **FDA** (food, drug, and medical-device enforcement via openFDA), and **NHTSA** (vehicle recalls). Instead of polling three separate, inconsistent government endpoints and reconciling their formats yourself, you get one clean, normalized schema with every recall mapped to the same fields, deduplicated, and sorted newest-first.

Run it with **zero configuration** to get the last 30 days of CPSC + FDA recalls, or narrow it by agency, keyword, date window, or a specific vehicle.

### What it does

The U.S. government publishes recalls across several disconnected systems:

- **CPSC** ([saferproducts.gov](https://www.saferproducts.gov/)) — consumer products: furniture, toys, appliances, electronics, batteries, etc.
- **openFDA enforcement** ([open.fda.gov](https://open.fda.gov/apis/)) — food, drugs, and medical devices.
- **NHTSA** ([nhtsa.gov](https://www.nhtsa.gov/recalls)) — motor vehicles and vehicle equipment.

Each API has its own field names, date formats, and quirks. Recall Radar queries the relevant endpoints, maps every record into **one common schema**, removes duplicates (on `source` + `recallId`), sorts by recall date descending, and writes the result to your dataset — ready to export as JSON, CSV, or Excel, feed into a webhook, or query from an AI agent over MCP.

### Why a unified US recall feed matters

- **Amazon FBA & e-commerce sellers** — a recalled product in your catalog or supply chain is a liability and a listing-takedown risk. Marketplaces remove recalled items fast; sellers who catch a recall first avoid stranded inventory, chargebacks, and account health hits.
- **Retail & safety teams** — pull recalls across product categories (CPSC) and consumables (FDA) in one pass to check against what's on your shelves or in your formulary.
- **Compliance, QA & regulatory** — monitor your own products, competitors, and component suppliers for enforcement actions without manually checking three agencies every week.
- **Insurance, legal & due diligence** — track recall history by brand or manufacturer for product-liability risk and deal diligence.

### Input

Every field is optional. **Empty input `{}` returns the last 30 days of CPSC + FDA recalls.**

| Field | Type | Default | Description |
|---|---|---|---|
| `agencies` | array | `["cpsc","fda"]` | Sources to include: `cpsc`, `fda` (= food + drug + device), or a single FDA category `fda-food` / `fda-drug` / `fda-device`, and `nhtsa`. NHTSA only runs if vehicle filters are also supplied. |
| `daysBack` | integer | `30` | Look-back window in days from today. |
| `keyword` | string | `""` | Case-insensitive filter on title, product name, brand, and manufacturer. Example: `lithium battery`. |
| `maxRecords` | integer | `200` | Cap on total records output after dedupe and sorting. |
| `vehicleMake` | string | — | NHTSA vehicle make, e.g. `Honda`. Required (with model + year) to query NHTSA. |
| `vehicleModel` | string | — | NHTSA vehicle model, e.g. `Accord`. |
| `vehicleYear` | string | — | NHTSA model year, e.g. `2018`. |

**Zero-config (last 30 days of CPSC + FDA):**
```json
{}
````

**Only Class-relevant food recalls mentioning a keyword, last 60 days:**

```json
{
    "agencies": ["fda-food"],
    "keyword": "allergen",
    "daysBack": 60
}
```

**Consumer products mentioning batteries, last 90 days:**

```json
{
    "agencies": ["cpsc"],
    "keyword": "battery",
    "daysBack": 90,
    "maxRecords": 500
}
```

**NHTSA vehicle recalls for a specific car (plus CPSC + FDA):**

```json
{
    "agencies": ["cpsc", "fda", "nhtsa"],
    "vehicleMake": "Honda",
    "vehicleModel": "Accord",
    "vehicleYear": "2018"
}
```

### Output schema

One normalized item per recall. Missing fields are `null` or empty — never fabricated.

| Field | Type | Description |
|---|---|---|
| `recallId` | string | Source-unique recall identifier (CPSC RecallID, FDA recall number, NHTSA campaign number). |
| `source` | string | `cpsc` · `fda-food` · `fda-drug` · `fda-device` · `nhtsa`. |
| `recallDate` | string | Recall date, ISO `YYYY-MM-DD`. |
| `title` | string | Human-readable recall title / headline. |
| `productName` | string | Recalled product name(s). |
| `brand` | string | Brand, when the source provides one (mostly FDA drug + NHTSA). |
| `manufacturer` | string | Manufacturer / distributor / recalling firm. |
| `hazard` | string | The hazard or reason for the recall. |
| `remedy` | string | What consumers should do (refund, repair, destroy, contact firm). |
| `unitsAffected` | string | Quantity in distribution, as reported by the source. |
| `injuriesReported` | bool / null | `true` / `false` for CPSC (from its injuries field); `null` where the source doesn't report it. |
| `recallUrl` | string | Link to the recall page (CPSC, NHTSA) or the FDA enforcement portal. |
| `imageUrls` | array | Product image URLs (CPSC only). |
| `rawCategory` | string | The source's own category / class label (e.g. FDA `Class II`, NHTSA component). |

**Sample item (CPSC):**

```json
{
    "recallId": "10816",
    "source": "cpsc",
    "recallDate": "2026-06-11",
    "title": "7-Drawer Dressers Recalled Due to Risk of Tip-Over and Entrapment Hazards",
    "productName": "Hasuit 7-Drawer Dressers",
    "brand": null,
    "manufacturer": "Shenzhen DUOMENGDUO Electronic Commerce Co., Ltd., dba Hasuit Direct",
    "hazard": "The recalled dressers are unstable if not anchored to the wall, posing tip-over and entrapment hazards.",
    "remedy": "Stop using immediately, render unusable, and email a photo to the firm for a refund.",
    "unitsAffected": "About 3,000",
    "injuriesReported": false,
    "recallUrl": "https://www.cpsc.gov/Recalls/2026/7-Drawer-Dressers-Recalled...",
    "imageUrls": ["https://www.cpsc.gov/s3fs-public/hasuit-1.gif"],
    "rawCategory": null
}
```

### Data sources

| Source | Endpoint | Auth | Covers |
|---|---|---|---|
| CPSC | `https://www.saferproducts.gov/RestWebServices/Recall` | None | Consumer products |
| openFDA — Food | `https://api.fda.gov/food/enforcement.json` | None (keyless 1,000 req/day) | Food & cosmetics |
| openFDA — Drug | `https://api.fda.gov/drug/enforcement.json` | None | Drugs |
| openFDA — Device | `https://api.fda.gov/device/enforcement.json` | None | Medical devices |
| NHTSA | `https://api.nhtsa.gov/recalls/recallsByVehicle` | None | Motor vehicles |

All five are official U.S. government open-data APIs. No scraping, no API key, no login.

### Use cases

- **FBA / marketplace seller monitoring** — schedule a daily run with a keyword for your category and get alerted the moment a competing or matching product is recalled.
- **Retail safety desk** — one feed across CPSC consumer goods and FDA consumables for store-level recall checks.
- **Compliance dashboards** — pipe the normalized feed into BigQuery, a sheet, or a BI tool and track recalls by source, brand, or hazard over time.
- **AI agents (MCP)** — let an agent answer "were there any battery recalls this month?" by calling this Actor live.
- **Vehicle-specific lookups** — check recalls for a specific make/model/year through NHTSA.

### Run on a schedule (recall alerts)

1. Set your filters (`agencies`, `keyword`, `daysBack`).
2. Create an [Apify Schedule](https://docs.apify.com/platform/schedules) — daily catches new recalls within ~24h.
3. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push results to email, Slack, Teams, or your own system.

### Use from Claude, Cursor & AI agents (MCP)

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=bikram07/recall-radar",
            "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
        }
    }
}
```

Or call the API directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/bikram07~recall-radar/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"agencies":["cpsc","fda"],"keyword":"battery","daysBack":30}'
```

### What it is NOT

- **Not legal, safety, or compliance advice.** It reports recalls as published by the agencies; it does not interpret your obligations. Confirm any action with the official recall notice and your counsel.
- **Not an enriched / scored feed.** No proprietary "AI severity" ratings or predictions — output is the official government data, normalized. Fields a source doesn't publish (e.g. FDA brand for food, injury counts for FDA) are left empty, never invented.
- **NHTSA needs vehicle filters.** NHTSA's `recallsByVehicle` endpoint requires a make + model + year, so vehicle recalls only appear when you supply all three. A zero-config run does not include NHTSA.
- **US only.** These are U.S. federal recall databases. It does not cover EU (RAPEX), UK, Canada, or other jurisdictions.
- **Not real-time to the minute.** Freshness depends on each agency's publishing cadence (FDA enforcement updates roughly weekly; CPSC and NHTSA update as recalls are posted). The Actor has only what the agencies have published.
- **Not affiliated with CPSC, FDA, or NHTSA.** Independent tool built on their public APIs.

***

Built on the official [CPSC](https://www.saferproducts.gov/), [openFDA](https://open.fda.gov/apis/), and [NHTSA](https://www.nhtsa.gov/recalls) APIs. Not affiliated with or endorsed by any U.S. government agency.

**Related searches:** US recall feed · CPSC recall API · FDA recall monitor · NHTSA vehicle recall API · product recall tracker · unified recall database · Amazon FBA recall alerts · openFDA enforcement · consumer product recall monitoring · recall compliance feed

# Actor input Schema

## `agencies` (type: `array`):

Which recall sources to include. Options: <b>cpsc</b> (consumer products), <b>fda</b> (food + drug + device), or a specific FDA category <b>fda-food</b>, <b>fda-drug</b>, <b>fda-device</b>, and <b>nhtsa</b> (vehicles — only active when you also pass vehicle filters below). Defaults to CPSC + FDA.

## `daysBack` (type: `integer`):

How many days back from today to pull recalls. Default 30.

## `keyword` (type: `string`):

Case-insensitive filter. Only recalls whose title, product name, brand, or manufacturer contains this term are returned. Example: <b>lithium battery</b>. Leave blank for all recalls.

## `maxRecords` (type: `integer`):

Maximum total normalized recall records to output (after dedupe and sorting). Default 200.

## `vehicleMake` (type: `string`):

Required to query NHTSA vehicle recalls. Example: <b>Honda</b>. Must be set together with vehicle model and year, or NHTSA is skipped.

## `vehicleModel` (type: `string`):

Required to query NHTSA vehicle recalls. Example: <b>Accord</b>.

## `vehicleYear` (type: `string`):

Required to query NHTSA vehicle recalls. Example: <b>2018</b>.

## Actor input object example

```json
{
  "agencies": [
    "cpsc",
    "fda"
  ],
  "daysBack": 30,
  "maxRecords": 200
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bikram07/recall-radar").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("bikram07/recall-radar").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 '{}' |
apify call bikram07/recall-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Recall Radar — CPSC, FDA & NHTSA Recall Feed",
        "description": "One unified, deduplicated feed of US product recalls from CPSC, FDA (food/drug/device) and NHTSA. Filter by agency, keyword, date window, or vehicle. Official government APIs, normalized into a clean schema. Zero-config: returns the last 30 days of CPSC + FDA recalls.",
        "version": "0.1",
        "x-build-id": "U2cT2dRI7LfcFXKbX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bikram07~recall-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bikram07-recall-radar",
                "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/bikram07~recall-radar/runs": {
            "post": {
                "operationId": "runs-sync-bikram07-recall-radar",
                "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/bikram07~recall-radar/run-sync": {
            "post": {
                "operationId": "run-sync-bikram07-recall-radar",
                "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": {
                    "agencies": {
                        "title": "Agencies / sources",
                        "type": "array",
                        "description": "Which recall sources to include. Options: <b>cpsc</b> (consumer products), <b>fda</b> (food + drug + device), or a specific FDA category <b>fda-food</b>, <b>fda-drug</b>, <b>fda-device</b>, and <b>nhtsa</b> (vehicles — only active when you also pass vehicle filters below). Defaults to CPSC + FDA.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "cpsc",
                                "fda",
                                "fda-food",
                                "fda-drug",
                                "fda-device",
                                "nhtsa"
                            ],
                            "enumTitles": [
                                "CPSC (consumer products)",
                                "FDA (all: food, drug, device)",
                                "FDA — Food",
                                "FDA — Drug",
                                "FDA — Device",
                                "NHTSA (vehicles, needs vehicle filters)"
                            ]
                        },
                        "default": [
                            "cpsc",
                            "fda"
                        ]
                    },
                    "daysBack": {
                        "title": "Look-back window (days)",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "How many days back from today to pull recalls. Default 30.",
                        "default": 30
                    },
                    "keyword": {
                        "title": "Keyword filter (optional)",
                        "type": "string",
                        "description": "Case-insensitive filter. Only recalls whose title, product name, brand, or manufacturer contains this term are returned. Example: <b>lithium battery</b>. Leave blank for all recalls."
                    },
                    "maxRecords": {
                        "title": "Max recall records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum total normalized recall records to output (after dedupe and sorting). Default 200.",
                        "default": 200
                    },
                    "vehicleMake": {
                        "title": "Vehicle make (NHTSA, optional)",
                        "type": "string",
                        "description": "Required to query NHTSA vehicle recalls. Example: <b>Honda</b>. Must be set together with vehicle model and year, or NHTSA is skipped."
                    },
                    "vehicleModel": {
                        "title": "Vehicle model (NHTSA, optional)",
                        "type": "string",
                        "description": "Required to query NHTSA vehicle recalls. Example: <b>Accord</b>."
                    },
                    "vehicleYear": {
                        "title": "Vehicle model year (NHTSA, optional)",
                        "type": "string",
                        "description": "Required to query NHTSA vehicle recalls. Example: <b>2018</b>."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
