# FDA Import Alert Monitor — DWPE Red List Scraper (`araluma/fda-import-alerts-scraper`) Actor

Scrape FDA Import Alerts (Detention Without Physical Examination) with a daily added/removed change-delta feed. Public-domain data for customs brokers, importers and trade-compliance.

- **URL**: https://apify.com/araluma/fda-import-alerts-scraper.md
- **Developed by:** [Araluma](https://apify.com/araluma) (community)
- **Categories:** Lead generation, News, 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

## FDA Import Alert Monitor — DWPE Red List Scraper & Change Feed

Track **FDA Import Alerts** (Detention Without Physical Examination — **DWPE**) automatically. This Actor scrapes the official FDA Import Alert system and gives you a clean, structured feed of every **firm, product, and country** on the **Red List**, **Green List**, and **Yellow List** — plus a daily **change delta** of which firms were **added, removed, or changed** since your last run.

Built for **customs brokers, import-compliance consultants, supplier due-diligence teams, and food / pharma / dietary-supplement / cosmetic importers** who need to know — before a shipment is detained — whether a firm or product just landed on an FDA import alert.

> **Data source:** the official FDA Import Alert system at `accessdata.fda.gov/cms_ia`. FDA content is in the **public domain** (17 U.S.C. § 105). This Actor only collects publicly published regulatory data about **companies and products** — no consumer personal data. Fields the FDA redacts are left redacted.

---

### What it does

- 🔴 **Scrapes the Red / Green / Yellow lists** of any (or every) FDA import alert.
- 🔁 **Change-delta feed** — get only what's *new* since last run: firms **added** to the Red List, **removed** from it, or whose entry **changed**. (The FDA itself sells a paid "Import Alert Weekly Summary" — this is that signal, automated and structured.)
- 🌍 **Filter by country** (e.g. only `CHINA`, `INDIA`) or by **specific alert numbers**.
- 📦 **Clean structured output** — firm name, address, country, FDA product code, product description, publish date, list type, and source URL.
- 🤖 **Runs unattended on a schedule** — point Apify Scheduler at it and receive a daily/weekly delta with zero manual work.

### Use cases

| You are… | You use this to… |
|---|---|
| A **customs broker** | Pre-screen shipments against the latest DWPE Red List before entry. |
| An **importer** (food / supplements / pharma / cosmetics) | Get alerted the moment one of your suppliers appears on an import alert. |
| A **compliance / due-diligence team** | Vet new overseas suppliers against active FDA detentions. |
| A **trade-compliance SaaS / data vendor** | Ingest a structured import-alert feed instead of scraping legacy HTML yourself. |

---

### Run modes

Set the **`mode`** input:

- **`delta`** *(recommended for monitoring)* — scrape, then output **only** firms added / removed / changed since the previous run. The first run quietly establishes a baseline; every run after that emits real changes.
- **`full`** — output **every** firm/product on the selected alerts (a complete current snapshot).
- **`discover`** — list **all active import alerts** (number, type, name, publish date, URL). Great for picking which alerts to monitor.

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | string | `delta`, `full`, or `discover`. Default `delta`. |
| `alertNumbers` | array | Limit to specific alerts, e.g. `["66-41","99-30"]` (dotted number) or `["190"]` (page id). Empty = all alerts. |
| `countryFilter` | array | Keep only these countries, e.g. `["CHINA","INDIA"]`. Empty = all. |
| `listTypes` | array | Any of `red`, `green`, `yellow`. Default `["red","green"]`. |
| `maxAlerts` | integer | Safety cap on alerts per run (0 = no limit). Handy for testing. |
| `requestDelaySecs` | integer | Politeness delay between page fetches. Default `30`. The FDA robots.txt requires a 30s hit-rate, so lower values are automatically raised to 30. |
| `allowSnapshotShrink` | boolean | Advanced DELTA safety override (default `false`). Leave off unless you intentionally narrowed the scope. |
| `notifyWebhookUrl` | string | DELTA: POST a JSON change summary to your own system when changes are found. |
| `notifySlackWebhookUrl` | string | DELTA: post a formatted change summary to a Slack incoming webhook. |

#### Notifications (turn it into a monitoring service)

In `delta` mode, set `notifyWebhookUrl` and/or `notifySlackWebhookUrl`. Whenever
a scheduled run detects firms **added / removed / changed**, the Actor pushes a
summary to your endpoint — so you're alerted the moment a supplier lands on (or
leaves) an FDA import alert, with no polling. Each change row also carries a
`severity` (`high` = added to the Red List). Notifications are best-effort and
never affect the dataset or the run.

#### Example input

```json
{
  "mode": "delta",
  "countryFilter": ["CHINA", "INDIA"],
  "listTypes": ["red"],
  "requestDelaySecs": 30
}
````

### Output

Each dataset item is one firm/product row:

```json
{
  "changeType": "added",
  "alertNumber": "66-41",
  "listType": "red",
  "country": "INDIA",
  "firmName": "Example Pharma Pvt Ltd",
  "productDescription": "Isotretinoin (Keratolytic)",
  "productCode": "64 X - - 11",
  "desc": "Brand X",
  "notes": "The product appears to be an unapproved new drug…",
  "datePublished": "10/07/2020",
  "address": "Plot 12, Industrial Area, Mumbai, Maharashtra INDIA",
  "alertUrl": "https://www.accessdata.fda.gov/cms_ia/importalert_190.html",
  "hasRedaction": false
}
```

- A firm with multiple products yields **one row per product**.
- In **`delta`** mode, `changeType` is `added`, `removed`, or `changed`. `changed` rows also carry `previousProductDescription` / `previousDesc`.
- In **`full`** mode, `changeType` is `current`.
- `hasRedaction: true` means the FDA hid one or more fields on that entry (we honor it).

### Scheduling (the recommended setup)

1. Run once in `discover` mode to see all alerts.
2. Create a task in `delta` mode with your `countryFilter` / `alertNumbers`.
3. Add an **Apify Schedule** (e.g. daily at 06:00). The first run sets a baseline; from then on you get a tidy feed of only what changed — integrate it with a webhook, email, Slack, or your database.

### Notes & limitations

- The FDA Import Alert pages are **legacy HTML** and update irregularly. The Actor includes parser-health checks and fails safe.
- **DELTA integrity:** if any targeted alert fails to fetch (network error or the FDA's HTTP-200 "apology" throttle page), the run does **not** emit deltas or overwrite its baseline — preventing false "removed" rows. It also refuses to persist a snapshot that shrank implausibly. So a partial/throttled run is a safe no-op, not corrupted data.
- The Actor fetches and honors the FDA **robots.txt** (Disallow rules + the 30-second hit-rate).
- This Actor reads only **public** FDA data about firms/products. It does **not** collect consumer personal data; fields the FDA redacts are left redacted.

### Pricing

This Actor runs on **pay-per-usage** — you only pay Apify's standard platform usage for the compute and data transfer each run consumes. In `delta` mode each run is light (it fetches the alerts and emits only what changed), which keeps recurring monitoring inexpensive. You can start on the **free tier** with the monthly Apify credits.

***

*Keywords: FDA import alert scraper, DWPE scraper, FDA Red List monitor, detention without physical examination, FDA import refusal data, customs broker compliance data, FDA import alert API, import alert change feed, FDA Green List, supplier due diligence FDA.*

# Actor input Schema

## `mode` (type: `string`):

DISCOVER: list all available import alerts with their metadata (fast, good for a first look). DELTA: only output firms ADDED / REMOVED / CHANGED since the previous run (recommended for daily monitoring). FULL: scrape every firm/product on the selected alerts.

## `alertNumbers` (type: `array`):

Limit the run to specific alert numbers, e.g. \["66-41", "99-30", "190"]. You may use the official dotted format (66-41) or the raw page id (190). Leave empty to process ALL active import alerts.

## `countryFilter` (type: `array`):

Only keep firms located in these countries (matched case-insensitively against the country header, e.g. "CHINA", "INDIA"). Leave empty for all countries.

## `listTypes` (type: `array`):

Which DWPE lists to scrape. Red List = firms/products currently subject to detention. Green List = firms exempted. Yellow List = intensified surveillance.

## `maxAlerts` (type: `integer`):

Safety cap on how many import alerts to fetch in a single run (0 = no limit). Useful for testing.

## `requestDelaySecs` (type: `integer`):

Politeness delay between page fetches. The FDA robots.txt requires a 30-second hit-rate, so values below 30 are automatically raised to 30 to stay compliant and avoid the FDA's abuse-throttle page.

## `allowSnapshotShrink` (type: `boolean`):

DELTA safety: by default the run refuses to overwrite its baseline if the new scrape has far fewer firms than before (a likely partial/throttled scrape, which would emit false 'removed' rows). Enable only if you intentionally narrowed the scope and want the smaller baseline to stick.

## `notifyWebhookUrl` (type: `string`):

DELTA mode: if set, the Actor POSTs a JSON summary of the detected changes to this URL whenever a run finds added/removed/changed firms. Use it to push alerts into your own system, Zapier/Make, a database, etc.

## `notifySlackWebhookUrl` (type: `string`):

DELTA mode: if set, the Actor posts a formatted change summary to this Slack incoming webhook whenever changes are detected.

## Actor input object example

```json
{
  "mode": "discover",
  "alertNumbers": [],
  "countryFilter": [],
  "listTypes": [
    "red",
    "green"
  ],
  "maxAlerts": 0,
  "requestDelaySecs": 30,
  "allowSnapshotShrink": false
}
```

# Actor output Schema

## `results` (type: `string`):

Firm/product rows (full mode) or added/removed/changed rows (delta mode).

# 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 = {
    "mode": "discover",
    "alertNumbers": [],
    "countryFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("araluma/fda-import-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 = {
    "mode": "discover",
    "alertNumbers": [],
    "countryFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("araluma/fda-import-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 '{
  "mode": "discover",
  "alertNumbers": [],
  "countryFilter": []
}' |
apify call araluma/fda-import-alerts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDA Import Alert Monitor — DWPE Red List Scraper",
        "description": "Scrape FDA Import Alerts (Detention Without Physical Examination) with a daily added/removed change-delta feed. Public-domain data for customs brokers, importers and trade-compliance.",
        "version": "1.0",
        "x-build-id": "P2yJgtCvnlOduS1JD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/araluma~fda-import-alerts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-araluma-fda-import-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/araluma~fda-import-alerts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-araluma-fda-import-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/araluma~fda-import-alerts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-araluma-fda-import-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Run mode",
                        "enum": [
                            "discover",
                            "delta",
                            "full"
                        ],
                        "type": "string",
                        "description": "DISCOVER: list all available import alerts with their metadata (fast, good for a first look). DELTA: only output firms ADDED / REMOVED / CHANGED since the previous run (recommended for daily monitoring). FULL: scrape every firm/product on the selected alerts.",
                        "default": "discover"
                    },
                    "alertNumbers": {
                        "title": "Specific import alert numbers (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit the run to specific alert numbers, e.g. [\"66-41\", \"99-30\", \"190\"]. You may use the official dotted format (66-41) or the raw page id (190). Leave empty to process ALL active import alerts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryFilter": {
                        "title": "Country filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep firms located in these countries (matched case-insensitively against the country header, e.g. \"CHINA\", \"INDIA\"). Leave empty for all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listTypes": {
                        "title": "List types to include",
                        "type": "array",
                        "description": "Which DWPE lists to scrape. Red List = firms/products currently subject to detention. Green List = firms exempted. Yellow List = intensified surveillance.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "red",
                                "green",
                                "yellow"
                            ],
                            "enumTitles": [
                                "Red List",
                                "Green List",
                                "Yellow List"
                            ]
                        },
                        "default": [
                            "red",
                            "green"
                        ]
                    },
                    "maxAlerts": {
                        "title": "Max alerts to process",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap on how many import alerts to fetch in a single run (0 = no limit). Useful for testing.",
                        "default": 0
                    },
                    "requestDelaySecs": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 30,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Politeness delay between page fetches. The FDA robots.txt requires a 30-second hit-rate, so values below 30 are automatically raised to 30 to stay compliant and avoid the FDA's abuse-throttle page.",
                        "default": 30
                    },
                    "allowSnapshotShrink": {
                        "title": "Allow snapshot to shrink (advanced)",
                        "type": "boolean",
                        "description": "DELTA safety: by default the run refuses to overwrite its baseline if the new scrape has far fewer firms than before (a likely partial/throttled scrape, which would emit false 'removed' rows). Enable only if you intentionally narrowed the scope and want the smaller baseline to stick.",
                        "default": false
                    },
                    "notifyWebhookUrl": {
                        "title": "Notification webhook URL (optional)",
                        "type": "string",
                        "description": "DELTA mode: if set, the Actor POSTs a JSON summary of the detected changes to this URL whenever a run finds added/removed/changed firms. Use it to push alerts into your own system, Zapier/Make, a database, etc."
                    },
                    "notifySlackWebhookUrl": {
                        "title": "Slack incoming webhook URL (optional)",
                        "type": "string",
                        "description": "DELTA mode: if set, the Actor posts a formatted change summary to this Slack incoming webhook whenever changes are detected."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```