# EU RASFF Food Safety Alerts Scraper (`automation-lab/eu-rasff-food-safety-alerts-scraper`) Actor

Export EU RASFF food/feed safety alerts with products, hazards, countries, risks, measures, and official details URLs.

- **URL**: https://apify.com/automation-lab/eu-rasff-food-safety-alerts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## EU RASFF Food Safety Alerts Scraper

Export structured EU RASFF food and feed safety notifications from the public RASFF Window. This actor turns the EU portal into clean datasets for compliance monitoring, supplier-risk screening, food recall workflows, and recurring alert exports.

### What does EU RASFF Food Safety Alerts Scraper do?

EU RASFF Food Safety Alerts Scraper searches the Rapid Alert System for Food and Feed (RASFF) public database and saves each matching notification as a structured dataset item. It can fetch list records only or enrich every notification with the detail API.

The actor extracts the RASFF reference, validation date, product category, product type, risk decision, notification classification, countries, hazards, measures taken, follow-up count, raw metadata, and source links.

### Who is it for?

- 🧪 Food safety and quality assurance teams that need recurring exports of EU alerts.
- 🚢 Importers and distributors that monitor supplier-country risks.
- 🛒 Retail compliance teams that track products, hazards, and withdrawals.
- 📊 Consultants and data teams that build dashboards from RASFF records.
- ⚖️ Regulatory intelligence teams that need auditable source URLs and raw metadata.

### Why use this scraper?

The RASFF portal is useful for manual searches, but repeated monitoring is easier with API-ready records. This actor gives you repeatable Apify runs, datasets, webhooks, exports, schedules, and integrations.

### Data you can extract

| Field | Description |
| --- | --- |
| `reference` | RASFF notification reference such as `2026.5919` |
| `ecValidationDate` | EC validation date from RASFF |
| `subject` | Notification subject text |
| `productCategory` | Food/feed category |
| `productType` | Product type such as food or feed |
| `notificationClassification` | Alert / information classification |
| `riskDecision` | RASFF risk decision |
| `notifyingCountry` | Country or organization that notified |
| `originCountries` | Product origin countries when available |
| `hazards` | Detailed hazard records when detail enrichment is enabled |
| `measuresTaken` | Measures and country taking action |
| `detailsUrl` | Direct RASFF detail page |

### How much does it cost to scrape EU RASFF food safety alerts?

The actor uses pay-per-event pricing with a small `$0.005` run-start fee plus a per-alert charge. Current per-alert pricing is tiered by Apify plan: FREE about `$0.00010`, BRONZE about `$0.000087`, SILVER about `$0.000068`, GOLD about `$0.000052`, PLATINUM about `$0.000035`, and DIAMOND about `$0.000024` per saved RASFF notification.

Concrete examples:

- Export 100 recent RASFF alerts on the FREE tier: about `$0.015` total (`$0.005` start + ~`$0.010` per-alert charges).
- Export 1,000 alerts on BRONZE: about `$0.092` total (`$0.005` start + ~`$0.087` per-alert charges).
- Export 10,000 alerts on GOLD: about `$0.529` total (`$0.005` start + ~`$0.524` per-alert charges).

The input prefill is intentionally modest and the actor uses the public EU RASFF API, so no paid proxy is required. A small first run of 25 alerts on the FREE plan is roughly `$0.0075`, making it inexpensive to verify the dataset before scheduling larger monitoring jobs.

### How to use it

1. Open the actor on Apify.
2. Set a date range or keyword.
3. Keep `includeDetails` enabled if you need hazards and measures.
4. Choose `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Input options

- `maxItems` controls how many notifications are saved.
- `dateFrom` and `dateTo` accept `YYYY-MM-DD` or `DD-MM-YYYY`.
- `keyword` searches notification subjects through the official RASFF API.
- `reference` fetches an exact reference when you know it.
- `productCategory`, `hazard`, `country`, and `notificationType` are human-readable text filters.
- `includeDetails` adds hazards, measures, flagged countries, and follow-up counts.

### Output example

```json
{
  "notificationId": 856316,
  "reference": "2026.5919",
  "subject": "Presence of Vibrio cholerae in raw Black Tiger shrimps from Bangladesh",
  "productCategory": "crustaceans and products thereof",
  "productType": "food",
  "riskDecision": "potentially serious",
  "notifyingCountry": { "name": "Romania", "isoCode": "RO" },
  "originCountries": [{ "name": "Bangladesh", "isoCode": "BD" }],
  "detailsUrl": "https://webgate.ec.europa.eu/rasff-window/screen/notification/856316"
}
````

### Tips for better results

Use a date range for monitoring runs. Use exact references for incident investigations. Use keyword searches for hazards such as `Listeria`, `Salmonella`, `aflatoxin`, or `pesticide`. Enable details for compliance exports and disable details only when you need a very fast list feed.

### Common workflows

- Daily alert monitor for the latest food/feed notifications.
- Country-risk export for origin-country screening.
- Product-category export for fish, tea, feed, nuts, or other categories.
- Hazard-specific monitor for pathogens, allergens, residues, or contaminants.
- Audit packet with raw RASFF metadata and details URLs.

### Integrations

Send datasets to Google Sheets, BigQuery, Snowflake, S3, Zapier, Make, n8n, Slack, or your own webhook. You can schedule the actor and trigger downstream workflows when new alerts are found.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/eu-rasff-food-safety-alerts-scraper').call({
  maxItems: 100,
  dateFrom: '2026-07-01',
  dateTo: '2026-07-06',
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/eu-rasff-food-safety-alerts-scraper').call(run_input={
    'maxItems': 100,
    'keyword': 'Listeria',
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~eu-rasff-food-safety-alerts-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"keyword":"Listeria","includeDetails":true}'
```

### MCP for Claude Desktop and Claude Code

Use Apify MCP with this actor as a tool:

```text
https://mcp.apify.com/?tools=automation-lab/eu-rasff-food-safety-alerts-scraper
```

Claude Code command:

```bash
claude mcp add apify-rasff --transport http "https://mcp.apify.com/?tools=automation-lab/eu-rasff-food-safety-alerts-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-rasff": {
      "url": "https://mcp.apify.com/?tools=automation-lab/eu-rasff-food-safety-alerts-scraper"
    }
  }
}
```

Example prompts:

- "Run the EU RASFF scraper for the last week and summarize serious fish-product alerts."
- "Export RASFF notifications mentioning Listeria and group them by country."
- "Find recent feed-related RASFF notifications and list measures taken."

### Scheduling

For monitoring, schedule a daily run with a recent date range. Connect the dataset to a webhook, Google Sheet, or BI pipeline.

### Legality

The actor reads publicly available RASFF Window data from the European Commission portal. Users are responsible for complying with Apify Terms of Service, the source website's terms, and applicable data-use rules.

### Troubleshooting

If a keyword returns no results, widen the date range or remove optional post-filters. If you need hazard details, keep `includeDetails` enabled because hazards live on the notification detail endpoint.

### Related scrapers

- https://apify.com/automation-lab/fda-food-recalls-scraper
- https://apify.com/automation-lab/eu-safety-gate-product-recalls-scraper
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Does it need a proxy?

No. The actor uses the public EU RASFF API and does not require Apify Proxy for normal runs.

#### Can I search by country?

Yes. The `country` input is a text filter matched against notifying, origin, distribution, and flagged countries.

#### Can I get hazards and measures?

Yes. Enable `includeDetails` to fetch detailed records with hazards, analytical results, measures, and follow-up counts.

### Monitoring examples

Use `keyword=Salmonella` for pathogen monitoring.
Use `productCategory=fish` for fish and seafood workflows.
Use `country=CN` or `country=China` for origin-country screening.
Use `reference=2026.5919` for an exact notification investigation.

### Dataset quality

Each item includes a `raw` object with the original RASFF API response. This helps with auditing and lets advanced users map fields that are not displayed in the default table view.

### Performance

The actor fetches search pages of up to 100 records. Detail mode adds one request per notification and includes a small delay to be respectful to the government portal.

### Changelog

- Initial private build: public RASFF search and detail export.

### Support

If you need another filter exposed as a first-class input, open an Apify issue with an example RASFF search and the expected field.

### Source transparency

Every result keeps the official RASFF detail URL.
Every enriched result keeps the raw API payload.
This makes exports easier to audit.
It also helps analysts map new fields when RASFF changes.

# Actor input Schema

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

Maximum RASFF notifications to save. Use 100+ for realistic monitoring exports.

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

Start of EC validation date range. Use YYYY-MM-DD or DD-MM-YYYY.

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

End of EC validation date range. Use YYYY-MM-DD or DD-MM-YYYY.

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

Free-text search against RASFF notification subjects, e.g. Listeria, salmonella, shrimp, tea.

## `reference` (type: `string`):

Optional exact reference such as 2026.5919. Leave empty for normal searches.

## `productCategory` (type: `string`):

Optional case-insensitive text filter applied to product category/type and raw details, e.g. fish, feed, tea.

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

Optional case-insensitive text filter applied to detailed hazards, e.g. Listeria, aflatoxin, pesticide.

## `country` (type: `string`):

Optional country name or ISO code matched across notifying, origin, distribution, and flagged countries.

## `notificationType` (type: `string`):

Optional text filter for type/classification such as food, feed, alert, follow-up, attention.

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

Fetch per-notification detail pages to include hazards, measures, follow-up counts, and flagged countries. Enabled automatically for hazard/country/product filters.

## Actor input object example

```json
{
  "maxItems": 20,
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-06",
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 20,
    "dateFrom": "2026-07-01",
    "dateTo": "2026-07-06",
    "keyword": "",
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/eu-rasff-food-safety-alerts-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 20,
    "dateFrom": "2026-07-01",
    "dateTo": "2026-07-06",
    "keyword": "",
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/eu-rasff-food-safety-alerts-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 20,
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-06",
  "keyword": "",
  "includeDetails": true
}' |
apify call automation-lab/eu-rasff-food-safety-alerts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU RASFF Food Safety Alerts Scraper",
        "description": "Export EU RASFF food/feed safety alerts with products, hazards, countries, risks, measures, and official details URLs.",
        "version": "0.1",
        "x-build-id": "n3nG5A7pzmpcgkL8B"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~eu-rasff-food-safety-alerts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-eu-rasff-food-safety-alerts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~eu-rasff-food-safety-alerts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-eu-rasff-food-safety-alerts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~eu-rasff-food-safety-alerts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-eu-rasff-food-safety-alerts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Maximum alerts",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum RASFF notifications to save. Use 100+ for realistic monitoring exports.",
                        "default": 20
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Start of EC validation date range. Use YYYY-MM-DD or DD-MM-YYYY."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "End of EC validation date range. Use YYYY-MM-DD or DD-MM-YYYY."
                    },
                    "keyword": {
                        "title": "Keyword / subject contains",
                        "type": "string",
                        "description": "Free-text search against RASFF notification subjects, e.g. Listeria, salmonella, shrimp, tea."
                    },
                    "reference": {
                        "title": "Exact RASFF reference",
                        "type": "string",
                        "description": "Optional exact reference such as 2026.5919. Leave empty for normal searches."
                    },
                    "productCategory": {
                        "title": "Product/category filter",
                        "type": "string",
                        "description": "Optional case-insensitive text filter applied to product category/type and raw details, e.g. fish, feed, tea."
                    },
                    "hazard": {
                        "title": "Hazard filter",
                        "type": "string",
                        "description": "Optional case-insensitive text filter applied to detailed hazards, e.g. Listeria, aflatoxin, pesticide."
                    },
                    "country": {
                        "title": "Country filter",
                        "type": "string",
                        "description": "Optional country name or ISO code matched across notifying, origin, distribution, and flagged countries."
                    },
                    "notificationType": {
                        "title": "Notification / product type filter",
                        "type": "string",
                        "description": "Optional text filter for type/classification such as food, feed, alert, follow-up, attention."
                    },
                    "includeDetails": {
                        "title": "Fetch detailed records",
                        "type": "boolean",
                        "description": "Fetch per-notification detail pages to include hazards, measures, follow-up counts, and flagged countries. Enabled automatically for hazard/country/product filters.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
