# openFDA Device Classification Scraper (`automation-lab/openfda-device-classification-scraper`) Actor

Extract FDA medical device classification records by product code, specialty, class, panel, and regulation number from openFDA.

- **URL**: https://apify.com/automation-lab/openfda-device-classification-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Automation, Developer tools
- **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

## openFDA Device Classification Scraper

Extract FDA medical device classification records from the public openFDA Device Classification API.

Use this actor to look up product codes, device names, medical specialties, device classes, review panels, regulation numbers, GMP exemptions, implant flags, life-support flags, 510(k) cross references, and source API URLs in a structured Apify dataset.

### What does openFDA Device Classification Scraper do?

openFDA Device Classification Scraper turns the FDA device classification endpoint into a repeatable Apify workflow.

It queries `device/classification.json`, paginates through matching records, normalizes field names, and saves each classification record as one dataset item.

You can run a small product-code lookup or export hundreds of records for compliance analysis.

### Who is it for?

- 🧪 **Regulatory affairs teams** checking product codes and class metadata before submissions.
- 🏥 **Medical device companies** monitoring device categories, panels, and regulation numbers.
- 📊 **Market intelligence analysts** mapping product classes and specialty areas.
- 🔎 **Compliance vendors** enriching device registries and internal product databases.
- 🤖 **Data engineers** who need openFDA classification data in JSON, CSV, Excel, BigQuery, or an API pipeline.

### Why use this actor?

The openFDA API is public, but production teams often need a repeatable extraction job with input validation, stable field names, Apify storage, API access, and charge-aware run limits.

This actor gives you a clean dataset without writing pagination or normalization code.

### Data source

The actor uses the public openFDA endpoint:

`https://api.fda.gov/device/classification.json`

No login, cookie, or API key is required for normal use.

### What data can I extract?

| Field | Description |
| --- | --- |
| `productCode` | FDA product code |
| `deviceName` | Device classification name |
| `medicalSpecialty` | FDA specialty code |
| `medicalSpecialtyDescription` | Specialty description |
| `deviceClass` | FDA class value |
| `regulationNumber` | CFR regulation number |
| `gmpExemptFlag` | GMP exemption flag |
| `reviewPanel` | Review panel code |
| `summaryMalfunctionReporting` | Summary malfunction reporting status |
| `implantFlag` | Whether the class is implant-related |
| `lifeSustainSupportFlag` | Life-sustain/support flag |
| `openfdaKNumbers` | Related 510(k) numbers when openFDA exposes them |
| `sourceApiUrl` | Exact API URL used for the page |
| `scrapedAt` | Extraction timestamp |

### Input options

You can combine filters. Different filter groups are joined with AND logic.

- `productCodes` — product code lookup such as `JMG`.
- `keywords` — free-text search across device name, definition, specialty, and regulation number.
- `deviceNames` — device-name phrase search.
- `medicalSpecialties` — specialty code or text, such as `IM` or `Immunology`.
- `regulationNumbers` — CFR values such as `866.5340`.
- `deviceClasses` — class values like `1`, `2`, `3`, or `U`.
- `reviewPanels` — panel codes such as `CH`, `CV`, or `OR`.
- `updatedSince` — best-effort date filter for records that expose date fields.
- `maxItems` — maximum records to save.
- `includeOpenFda` — include the nested raw openFDA cross-reference object.

### Example input: product code lookup

```json
{
  "productCodes": ["JMG"],
  "maxItems": 25,
  "includeOpenFda": true
}
````

### Example input: specialty research

```json
{
  "medicalSpecialties": ["Immunology"],
  "deviceClasses": ["2"],
  "maxItems": 100
}
```

### Example input: regulation number monitoring

```json
{
  "regulationNumbers": ["866.5340"],
  "maxItems": 50
}
```

### Example output

```json
{
  "productCode": "JMG",
  "deviceName": "Radioimmunoassay (Two-Site Solid Phase), Ferritin",
  "medicalSpecialty": "IM",
  "medicalSpecialtyDescription": "Immunology",
  "deviceClass": "2",
  "regulationNumber": "866.5340",
  "gmpExemptFlag": "N",
  "reviewPanel": "CH",
  "summaryMalfunctionReporting": "Eligible",
  "implantFlag": "N",
  "lifeSustainSupportFlag": "N",
  "openfdaKNumbers": ["K963498"],
  "sourceApiUrl": "https://api.fda.gov/device/classification.json?...",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
```

### How much does it cost to scrape openFDA device classification records?

This actor uses pay-per-event pricing.

- A small one-time start event is charged per run.
- A result event is charged for each classification record saved.
- The default prefill is intentionally small so first runs stay inexpensive.

Final tier prices are calculated from cloud run costs before publication and are displayed on the Apify pricing panel.

### How to run it on Apify

1. Open the actor on Apify.
2. Add product codes, keywords, specialties, or regulation filters.
3. Set `maxItems` to the number of records you need.
4. Start the run.
5. Download results as JSON, CSV, Excel, XML, RSS, or HTML table.

### Tips for better results

- Use product codes for exact lookups.
- Use regulation numbers for CFR-specific research.
- Use specialty descriptions for broader market mapping.
- Keep `maxItems` low while testing a new query.
- Leave `updatedSince` empty unless you know the endpoint exposes comparable date fields for your query.

### Integrations

You can connect results to:

- Google Sheets for compliance review queues.
- BigQuery or Snowflake for portfolio analysis.
- Internal device master data systems.
- CRM enrichment workflows for medtech market intelligence.
- Monitoring jobs that compare output between scheduled runs.

### 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/openfda-device-classification-scraper').call({
  productCodes: ['JMG'],
  maxItems: 25,
});

console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/openfda-device-classification-scraper').call(run_input={
    'productCodes': ['JMG'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~openfda-device-classification-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"productCodes":["JMG"],"maxItems":25}'
```

### MCP usage

Use Apify MCP to call this actor from Claude Desktop, Claude Code, or any MCP-compatible client.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/openfda-device-classification-scraper`

Claude Code setup:

```bash
claude mcp add apify-openfda-device-classification \
  https://mcp.apify.com/?tools=automation-lab/openfda-device-classification-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-openfda-device-classification": {
      "url": "https://mcp.apify.com/?tools=automation-lab/openfda-device-classification-scraper"
    }
  }
}
```

Example prompts:

- “Look up FDA classification data for product code JMG.”
- “Find class 2 immunology device classifications and return the regulation numbers.”
- “Export openFDA classification records for regulation 866.5340.”

### Scheduling and monitoring

Schedule the actor weekly or monthly to capture current openFDA classification snapshots.

Compare datasets between runs to detect new or changed records in your downstream system.

### Data freshness

The actor returns data from openFDA at run time.

openFDA aggregates FDA source data and may include disclaimers or lag relative to FDA source systems.

Always verify regulatory decisions against official FDA records.

### Limitations

- The source endpoint can apply public API rate limits.
- Some records have empty optional fields.
- `updatedSince` only works for records that expose comparable dates.
- The actor does not replace regulatory advice.

### Legality

The actor accesses a public FDA/openFDA API intended for data access.

You should still use the data responsibly, respect source terms, and verify critical regulatory interpretations with official FDA sources.

### Is it legal to scrape openFDA?

Yes, this actor queries a public openFDA API endpoint rather than private pages or logged-in content.

Users remain responsible for how they use exported regulatory data.

### Related scrapers

Automation Lab provides other data actors that may complement this workflow:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### Troubleshooting: no records returned

Check whether your filter combination is too narrow.

Try one product code or one keyword first, then add filters gradually.

### Troubleshooting: updatedSince returns zero records

Most openFDA classification records do not expose update timestamps.

If you set `updatedSince`, the actor only keeps records with comparable date fields, so zero results can be expected.

### FAQ

#### Can I export all device classifications?

Yes. Leave filters empty and set `maxItems` to the number of records you want.

#### Do I need an FDA API key?

No. This actor uses the public endpoint without an API key.

#### Does the actor use a browser?

No. It is API-only and lightweight.

#### Can I monitor product codes over time?

Yes. Schedule repeated runs and compare product-code rows in your downstream system.

#### Can I use the output for regulatory submissions?

Use the output as workflow data and verify official regulatory conclusions against FDA source records.

### Changelog

- Initial version: openFDA classification search, pagination, normalized output, and source URL tracking.

# Actor input Schema

## `productCodes` (type: `array`):

FDA product codes to look up, such as JMG, DZE, or KZH.

## `keywords` (type: `array`):

Free-text terms matched against device name, definition, specialty description, and regulation number.

## `deviceNames` (type: `array`):

Exact or partial device-name phrases to search for in openFDA classification records.

## `medicalSpecialties` (type: `array`):

Medical specialty codes or descriptions, for example IM, CH, Cardiovascular, or Immunology.

## `regulationNumbers` (type: `array`):

FDA CFR regulation numbers such as 866.5340 or 870.3610.

## `deviceClasses` (type: `array`):

FDA device class values to filter by. Use 1, 2, 3, or U.

## `reviewPanels` (type: `array`):

FDA review panel codes such as CH, CV, OR, or IM.

## `updatedSince` (type: `string`):

Optional ISO date for records that expose update/effective dates. Most openFDA classification records do not expose update timestamps, so this can intentionally return zero items.

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

Maximum number of classification records to save to the dataset.

## `includeOpenFda` (type: `boolean`):

Include the nested openfda object with cross-referenced 510(k), registration, and FEI values when available.

## Actor input object example

```json
{
  "productCodes": [
    "JMG"
  ],
  "keywords": [
    "ferritin"
  ],
  "maxItems": 20,
  "includeOpenFda": 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 = {
    "productCodes": [
        "JMG"
    ],
    "keywords": [
        "ferritin"
    ],
    "maxItems": 20,
    "includeOpenFda": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/openfda-device-classification-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 = {
    "productCodes": ["JMG"],
    "keywords": ["ferritin"],
    "maxItems": 20,
    "includeOpenFda": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/openfda-device-classification-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 '{
  "productCodes": [
    "JMG"
  ],
  "keywords": [
    "ferritin"
  ],
  "maxItems": 20,
  "includeOpenFda": true
}' |
apify call automation-lab/openfda-device-classification-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "openFDA Device Classification Scraper",
        "description": "Extract FDA medical device classification records by product code, specialty, class, panel, and regulation number from openFDA.",
        "version": "0.1",
        "x-build-id": "Q4RxMkES67Htmhe2O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~openfda-device-classification-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-openfda-device-classification-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~openfda-device-classification-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-openfda-device-classification-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~openfda-device-classification-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-openfda-device-classification-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": {
                    "productCodes": {
                        "title": "Product codes",
                        "type": "array",
                        "description": "FDA product codes to look up, such as JMG, DZE, or KZH.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Device keywords",
                        "type": "array",
                        "description": "Free-text terms matched against device name, definition, specialty description, and regulation number.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deviceNames": {
                        "title": "Device names",
                        "type": "array",
                        "description": "Exact or partial device-name phrases to search for in openFDA classification records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "medicalSpecialties": {
                        "title": "Medical specialties",
                        "type": "array",
                        "description": "Medical specialty codes or descriptions, for example IM, CH, Cardiovascular, or Immunology.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regulationNumbers": {
                        "title": "Regulation numbers",
                        "type": "array",
                        "description": "FDA CFR regulation numbers such as 866.5340 or 870.3610.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deviceClasses": {
                        "title": "Device classes",
                        "type": "array",
                        "description": "FDA device class values to filter by. Use 1, 2, 3, or U.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewPanels": {
                        "title": "Review panels",
                        "type": "array",
                        "description": "FDA review panel codes such as CH, CV, OR, or IM.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "updatedSince": {
                        "title": "Updated since",
                        "type": "string",
                        "description": "Optional ISO date for records that expose update/effective dates. Most openFDA classification records do not expose update timestamps, so this can intentionally return zero items."
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of classification records to save to the dataset.",
                        "default": 20
                    },
                    "includeOpenFda": {
                        "title": "Include raw openFDA cross-reference fields",
                        "type": "boolean",
                        "description": "Include the nested openfda object with cross-referenced 510(k), registration, and FEI values when available.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```