# Canada Product Recalls & Safety Alerts (`dromb/canada-recalls-safety-alerts`) Actor

Monitor official Government of Canada recalls and safety alerts by keyword, category, date, language, or recall ID.

- **URL**: https://apify.com/dromb/canada-recalls-safety-alerts.md
- **Developed by:** [Dmitriy Gyrbu](https://apify.com/dromb) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.009 / actor start

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## Canada Product Recalls & Safety Alerts Scraper

This actor extracts official Government of Canada product recalls and safety alerts into clean, export-ready Apify datasets. Use it for consumer safety monitoring, compliance tracking, product database enrichment, market research, and automated recall alert workflows.

This is an unofficial scraper and is not affiliated with, endorsed by, or operated by the Government of Canada.

### What This Actor Does

The actor extracts recall data from the official Government of Canada open data feeds (CSV/JSON format) and optionally enriches records with details from individual recall pages. It supports multiple operations for different use cases including fetching latest recalls, searching by keywords, filtering by category, and retrieving specific recall details.

### Supported Operations

- **categories**: Discover valid category names from the dataset
- **latest**: Retrieve the most recent recalls sorted by update date
- **search**: Search recalls by keyword across all fields
- **category**: Filter recalls by category (e.g., food, vehicles, health products)
- **detail**: Retrieve detailed information for a specific recall by ID or URL
- **since**: Retrieve recalls published or updated after a specific date
- **full_export**: Export a bounded set of recall records from the full dataset

### What to Run First

For new users, follow this recommended sequence:

1. **Run `categories`** to discover valid category names
   ```json
   {
     "operation": "categories"
   }
````

2. **Run `latest`** for recent alerts
   ```json
   {
     "operation": "latest",
     "limit": 10
   }
   ```

3. **Run `search`** for product/company/issue keywords
   ```json
   {
     "operation": "search",
     "query": "peanut butter",
     "limit": 25
   }
   ```

4. **Run `since`** for monitoring changes after a date
   ```json
   {
     "operation": "since",
     "since": "2026-01-01",
     "limit": 50
   }
   ```

5. **Run `detail`** when you need one specific recall
   ```json
   {
     "operation": "detail",
     "recallId": "82252"
   }
   ```

6. **Run `full_export`** only for bounded historical export
   ```json
   {
     "operation": "full_export",
     "limit": 100
   }
   ```

### Input Examples

#### Latest recalls

```json
{
  "operation": "latest",
  "limit": 50
}
```

#### Search by keyword

```json
{
  "operation": "search",
  "query": "peanut butter",
  "limit": 25
}
```

#### Filter by category

```json
{
  "operation": "category",
  "category": "Food",
  "limit": 100
}
```

#### Get specific recall details

```json
{
  "operation": "detail",
  "recallId": "82252"
}
```

#### Filter by date

```json
{
  "operation": "since",
  "since": "2026-01-01",
  "limit": 50
}
```

#### With detail page enrichment

```json
{
  "operation": "latest",
  "limit": 10,
  "includeDetails": true,
  "maxDetailPages": 10
}
```

#### Dataset Note

This actor provides two types of data in the output dataset:

- **Recall Records**: Detailed recall information (Default for most operations).
- **Category Discovery Rows**: When using the `categories` operation, the output contains a list of valid categories and their respective counts.

### Output Example

```json
{
  "recallId": "82252",
  "title": "Certain Thermos Stainless King Food Jars and Sportsman Food Beverage Bottles recalled",
  "sourceUrl": "https://recalls-rappels.canada.ca/en/alert-recall/certain-thermos-stainless-king-food-jars-and-sportsman-food-beverage-bottles-recalled",
  "companies": "Thermos L.L.C.",
  "affectedProducts": "Stainless King Food Jars, Sportsman Food Beverage Bottles",
  "issue": "The latch can lock in place when the jar is closed, allowing it to be opened even by a child.",
  "whatToDo": "Consumers should immediately stop using the recalled products and contact Thermos for a free replacement lid.",
  "category": "Children's products",
  "recallClass": "Class 2",
  "dateUpdated": "2024-01-15",
  "archived": false,
  "status": "active",
  "dataSource": "open.canada.ca",
  "rawSourceType": "recall_record",
  "hazard": "Injury hazard",
  "summary": "The latch can lock in place when the jar is closed, allowing it to be opened even by a child.",
  "language": "en"
}
```

### Output Field Descriptions

- **recallId**: Unique identifier for the recall (NID from source)
- **title**: Title of the recall notice
- **sourceUrl**: URL to the official recall page
- **companies**: Company or organization responsible for the recall
- **affectedProducts**: Description of affected products
- **issue**: Description of the issue or hazard
- **whatToDo**: Recommended consumer action
- **category**: Category of the recall (e.g., Food, Vehicles)
- **recallClass**: Recall classification (Class 1, Class 2, etc.)
- **dateUpdated**: Last updated date of the recall
- **archived**: Boolean indicating if recall is archived
- **status**: Status of the recall (active/archived)
- **dataSource**: Source of the data (open.canada.ca)
- **rawSourceType**: Type of output row (`recall_record` or `category_discovery`)
- **hazard**: Hazard information (extracted from detail pages where available; may be null if not explicitly provided in the source)
- **summary**: Summary of the issue
- **language**: Language of the data (en/fr)

### Performance

- Average run time: 8-25 seconds for typical operations
- CSV fetch: ~0.1-0.2 seconds
- Detail enrichment: ~0.1 seconds per page
- No rate limiting observed on official feeds
- Memory allocation is optimized for feed parsing and should be increased only if a large upstream feed requires it.

### Limitations

- **Update frequency**: The official Government of Canada feed may update daily, not instantly. There may be a delay between publication and availability in the feed.
- **Detail enrichment**: HTTP-first approach captures available fields. Note that not all recall pages have a structured 'hazard' field, and some may require JavaScript rendering which is not supported. The 'hazard' field is provided as a best-effort extraction.
- **Historical data**: Some historical records may have incomplete information or missing fields.
- **Recall ID**: The `recallId` is based on Government of Canada NID and may change if the source system changes.
- **Category names**: Category names are derived from the source data and may change over time. Use the `categories` operation to discover current valid names.
- **Proxy/browser**: Proxy and browser are not required by default. Only use proxy if you encounter rate limiting.
- **Export limits**: The maximum limit is 1000 records per run. For larger exports, run in chunks or use pagination if supported.
- **Real-time coverage**: This actor does not provide real-time monitoring. It depends on the Government of Canada publication schedule.

### Proxy Configuration

This actor uses an HTTP-first approach and does not require a proxy for basic operation. The official Government of Canada open data feeds are publicly accessible.

**Proxy is optional, not required by default.**

Proxy configuration can be used and will be applied to source HTTP requests if:

- You encounter rate limiting or IP-based restrictions
- You need to route traffic through specific geographic locations
- Your organization requires proxy usage for all outbound requests

To use a proxy, add the `proxyConfiguration` parameter to your input:

```json
{
  "operation": "latest",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Browser Usage

This actor uses an HTTP-first approach and does not require a browser for basic operation. All data is fetched via HTTP requests to official Government of Canada feeds and detail pages.

**Browser is not required.**

### Public Data Disclaimer

This actor scrapes public data from official Government of Canada sources. The data is publicly available and does not require authentication. Users should comply with the Government of Canada's terms of use for their open data.

### Troubleshooting

#### No results returned

- Verify your search query or category spelling
- Check that the `since` date is in YYYY-MM-DD format
- Some categories may have no recent recalls

Run status, totals, and structured invalid-input or upstream-download errors are written to the default key-value store under `OUTPUT`. Missing required operation fields no longer silently fall back to `latest`.

#### Detail enrichment not working

- Ensure `includeDetails` is set to `true`
- Check that the source URL is valid and accessible
- Some recall pages may have different structures

#### Rate limiting

- If you encounter rate limiting, use the proxy configuration
- Reduce the `limit` and `maxDetailPages` values
- Space out your requests if running multiple times

### Use Cases

- **Consumer Safety Monitoring**: Track latest recalls for consumer products
- **Compliance Tracking**: Monitor recalls relevant to your industry
- **Research**: Analyze recall trends and patterns over time
- **Alert Systems**: Build notification systems for specific product categories
- **Data Enrichment**: Enhance product databases with recall information

### Daily Monitoring Workflow

For automated daily monitoring:

1. **Schedule the actor** to run daily using Apify's scheduler
2. **Use the `since` operation** with yesterday's date or the last successful run date
   ```json
   {
     "operation": "since",
     "since": "2026-07-07",
     "limit": 100
   }
   ```
3. **Export the dataset** to a webhook or integration for processing
4. **Apply filters** for specific categories (food, drugs, vehicles, consumer products) as needed
5. **Set up alerts** for high-priority recalls (Class 1, specific categories)

**Note**: The source update frequency depends on Government of Canada publication schedule and is not guaranteed to be real-time. The official feed may update daily, not instantly.

### Why Not Just Download the CSV?

While you can download the CSV directly from Government of Canada, this actor provides several advantages:

- **Normalized fields**: Consistent field names and data types across all records
- **Operation-based access**: Easy filtering by search, category, date, or specific recall ID
- **Apify scheduling**: Built-in scheduling and automation without custom scripts
- **Dataset export formats**: Export to JSON, CSV, Excel, or other formats via Apify
- **Integration workflows**: Connect to webhooks, databases, or other services
- **Optional detail enrichment**: Fetch additional details from recall pages when needed
- **Cloud-ready monitoring**: Run in the cloud without local infrastructure
- **Category discovery**: Dynamically discover valid categories from the current dataset

### Language Support

The actor supports both English (en) and French (fr) data sources. Use the `language` parameter to specify:

```json
{
  "operation": "latest",
  "language": "fr"
}
```

### Data Source

- **Primary**: Government of Canada Open Data (CSV/JSON)
- **Detail Pages**: recalls-rappels.canada.ca
- **Update Frequency**: As published by Government of Canada
- **Attribution**: Data sourced from official Government of Canada open data feeds

# Actor input Schema

## `operation` (type: `string`):

Choose what recall data to extract: latest records, keyword search, category filter, category discovery, one recall detail, date filter, or bounded export.

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

Keyword to search across recall titles, companies, products, issues, and actions. Used with the search operation.

## `category` (type: `string`):

Filter recalls by category (e.g., food, health products). Only used with 'category' operation. Use 'categories' operation to discover valid category names.

## `recallId` (type: `string`):

Specific Recall ID (NID) for detail extraction. Only used with 'detail' operation.

## `url` (type: `string`):

Specific Recall URL for detail extraction. Only used with 'detail' operation.

## `since` (type: `string`):

Filter records published after this date (YYYY-MM-DD). Only used with 'since' operation.

## `limit` (type: `integer`):

Maximum number of records to return. Default 50, maximum 1000. For larger exports, run in chunks.

## `includeDetails` (type: `boolean`):

Whether to enrich records with data from detail pages. Optional enrichment.

## `maxDetailPages` (type: `integer`):

Bound for the number of detail pages to scrape. Only applies when includeDetails is true.

## `language` (type: `string`):

Language of the data source.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Proxy is NOT required by default. Use only if you encounter rate limiting or need specific geographic routing.

## Actor input object example

```json
{
  "operation": "latest",
  "limit": 50,
  "includeDetails": false,
  "maxDetailPages": 10,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Run status, totals, and structured errors stored under OUTPUT.

## `recallId` (type: `string`):

Unique identifier for the recall (NID from source)

## `title` (type: `string`):

Title of the recall notice

## `sourceUrl` (type: `string`):

URL to the official recall page

## `companies` (type: `string`):

Company or organization responsible for the recall

## `affectedProducts` (type: `string`):

Description of affected products

## `issue` (type: `string`):

Description of the issue or hazard

## `whatToDo` (type: `string`):

Recommended consumer action

## `category` (type: `string`):

Category of the recall (e.g., Food, Vehicles). For 'categories' operation, this is the category name.

## `count` (type: `string`):

Number of recalls in this category. Only present for 'categories' operation.

## `recallClass` (type: `string`):

Recall classification (Class 1, Class 2, etc.)

## `dateUpdated` (type: `string`):

Last updated date of the recall

## `archived` (type: `string`):

Boolean indicating if recall is archived

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

Status of the recall (active/archived)

## `dataSource` (type: `string`):

Source of the data (open.canada.ca)

## `rawSourceType` (type: `string`):

Type of output row: recall\_record or category\_discovery

## `hazard` (type: `string`):

Hazard information (best-effort extraction from detail pages; may be null)

## `summary` (type: `string`):

Summary of the issue

## `language` (type: `string`):

Language of the data (en/fr)

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dromb/canada-recalls-safety-alerts").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 = { "proxyConfiguration": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("dromb/canada-recalls-safety-alerts").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 '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dromb/canada-recalls-safety-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dromb/canada-recalls-safety-alerts",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada Product Recalls & Safety Alerts",
        "description": "Monitor official Government of Canada recalls and safety alerts by keyword, category, date, language, or recall ID.",
        "version": "0.1",
        "x-build-id": "Vs7aPhHBvvsM9mCdF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dromb~canada-recalls-safety-alerts/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dromb-canada-recalls-safety-alerts",
                "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/dromb~canada-recalls-safety-alerts/runs": {
            "post": {
                "operationId": "runs-sync-dromb-canada-recalls-safety-alerts",
                "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/dromb~canada-recalls-safety-alerts/run-sync": {
            "post": {
                "operationId": "run-sync-dromb-canada-recalls-safety-alerts",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "latest",
                            "search",
                            "category",
                            "categories",
                            "detail",
                            "since",
                            "full_export"
                        ],
                        "type": "string",
                        "description": "Choose what recall data to extract: latest records, keyword search, category filter, category discovery, one recall detail, date filter, or bounded export.",
                        "default": "latest"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search across recall titles, companies, products, issues, and actions. Used with the search operation."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter recalls by category (e.g., food, health products). Only used with 'category' operation. Use 'categories' operation to discover valid category names."
                    },
                    "recallId": {
                        "title": "Recall ID",
                        "type": "string",
                        "description": "Specific Recall ID (NID) for detail extraction. Only used with 'detail' operation."
                    },
                    "url": {
                        "title": "Recall URL",
                        "type": "string",
                        "description": "Specific Recall URL for detail extraction. Only used with 'detail' operation."
                    },
                    "since": {
                        "title": "Since Date",
                        "type": "string",
                        "description": "Filter records published after this date (YYYY-MM-DD). Only used with 'since' operation."
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of records to return. Default 50, maximum 1000. For larger exports, run in chunks.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include Details",
                        "type": "boolean",
                        "description": "Whether to enrich records with data from detail pages. Optional enrichment.",
                        "default": false
                    },
                    "maxDetailPages": {
                        "title": "Max Detail Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Bound for the number of detail pages to scrape. Only applies when includeDetails is true.",
                        "default": 10
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language of the data source.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Proxy is NOT required by default. Use only if you encounter rate limiting or need specific geographic routing."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```